Merge git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-unstable
[linux-2.6] / fs / dlm / ast.c
1 /******************************************************************************
2 *******************************************************************************
3 **
4 **  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
5 **  Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
6 **
7 **  This copyrighted material is made available to anyone wishing to use,
8 **  modify, copy, or redistribute it subject to the terms and conditions
9 **  of the GNU General Public License v.2.
10 **
11 *******************************************************************************
12 ******************************************************************************/
13
14 #include "dlm_internal.h"
15 #include "lock.h"
16 #include "user.h"
17 #include "ast.h"
18
19 #define WAKE_ASTS  0
20
21 static struct list_head         ast_queue;
22 static spinlock_t               ast_queue_lock;
23 static struct task_struct *     astd_task;
24 static unsigned long            astd_wakeflags;
25 static struct mutex             astd_running;
26
27
28 void dlm_del_ast(struct dlm_lkb *lkb)
29 {
30         spin_lock(&ast_queue_lock);
31         if (lkb->lkb_ast_type & (AST_COMP | AST_BAST))
32                 list_del(&lkb->lkb_astqueue);
33         spin_unlock(&ast_queue_lock);
34 }
35
36 void dlm_add_ast(struct dlm_lkb *lkb, int type, int bastmode)
37 {
38         if (lkb->lkb_flags & DLM_IFL_USER) {
39                 dlm_user_add_ast(lkb, type, bastmode);
40                 return;
41         }
42
43         spin_lock(&ast_queue_lock);
44         if (!(lkb->lkb_ast_type & (AST_COMP | AST_BAST))) {
45                 kref_get(&lkb->lkb_ref);
46                 list_add_tail(&lkb->lkb_astqueue, &ast_queue);
47         }
48         lkb->lkb_ast_type |= type;
49         if (bastmode)
50                 lkb->lkb_bastmode = bastmode;
51         spin_unlock(&ast_queue_lock);
52
53         set_bit(WAKE_ASTS, &astd_wakeflags);
54         wake_up_process(astd_task);
55 }
56
57 static void process_asts(void)
58 {
59         struct dlm_ls *ls = NULL;
60         struct dlm_rsb *r = NULL;
61         struct dlm_lkb *lkb;
62         void (*cast) (void *astparam);
63         void (*bast) (void *astparam, int mode);
64         int type = 0, bastmode;
65
66 repeat:
67         spin_lock(&ast_queue_lock);
68         list_for_each_entry(lkb, &ast_queue, lkb_astqueue) {
69                 r = lkb->lkb_resource;
70                 ls = r->res_ls;
71
72                 if (dlm_locking_stopped(ls))
73                         continue;
74
75                 list_del(&lkb->lkb_astqueue);
76                 type = lkb->lkb_ast_type;
77                 lkb->lkb_ast_type = 0;
78                 bastmode = lkb->lkb_bastmode;
79
80                 spin_unlock(&ast_queue_lock);
81                 cast = lkb->lkb_astfn;
82                 bast = lkb->lkb_bastfn;
83
84                 if ((type & AST_COMP) && cast)
85                         cast(lkb->lkb_astparam);
86
87                 if ((type & AST_BAST) && bast)
88                         bast(lkb->lkb_astparam, bastmode);
89
90                 /* this removes the reference added by dlm_add_ast
91                    and may result in the lkb being freed */
92                 dlm_put_lkb(lkb);
93
94                 cond_resched();
95                 goto repeat;
96         }
97         spin_unlock(&ast_queue_lock);
98 }
99
100 static inline int no_asts(void)
101 {
102         int ret;
103
104         spin_lock(&ast_queue_lock);
105         ret = list_empty(&ast_queue);
106         spin_unlock(&ast_queue_lock);
107         return ret;
108 }
109
110 static int dlm_astd(void *data)
111 {
112         while (!kthread_should_stop()) {
113                 set_current_state(TASK_INTERRUPTIBLE);
114                 if (!test_bit(WAKE_ASTS, &astd_wakeflags))
115                         schedule();
116                 set_current_state(TASK_RUNNING);
117
118                 mutex_lock(&astd_running);
119                 if (test_and_clear_bit(WAKE_ASTS, &astd_wakeflags))
120                         process_asts();
121                 mutex_unlock(&astd_running);
122         }
123         return 0;
124 }
125
126 void dlm_astd_wake(void)
127 {
128         if (!no_asts()) {
129                 set_bit(WAKE_ASTS, &astd_wakeflags);
130                 wake_up_process(astd_task);
131         }
132 }
133
134 int dlm_astd_start(void)
135 {
136         struct task_struct *p;
137         int error = 0;
138
139         INIT_LIST_HEAD(&ast_queue);
140         spin_lock_init(&ast_queue_lock);
141         mutex_init(&astd_running);
142
143         p = kthread_run(dlm_astd, NULL, "dlm_astd");
144         if (IS_ERR(p))
145                 error = PTR_ERR(p);
146         else
147                 astd_task = p;
148         return error;
149 }
150
151 void dlm_astd_stop(void)
152 {
153         kthread_stop(astd_task);
154 }
155
156 void dlm_astd_suspend(void)
157 {
158         mutex_lock(&astd_running);
159 }
160
161 void dlm_astd_resume(void)
162 {
163         mutex_unlock(&astd_running);
164 }
165