[DLM] fs/dlm/ast.c should #include "ast.h"
[linux-3.10.git] / fs / dlm / ast.c
1 /******************************************************************************
2 *******************************************************************************
3 **
4 **  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
5 **  Copyright (C) 2004-2005 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)
37 {
38         if (lkb->lkb_flags & DLM_IFL_USER) {
39                 dlm_user_add_ast(lkb, type);
40                 return;
41         }
42         DLM_ASSERT(lkb->lkb_astaddr != DLM_FAKE_USER_AST, dlm_print_lkb(lkb););
43
44         spin_lock(&ast_queue_lock);
45         if (!(lkb->lkb_ast_type & (AST_COMP | AST_BAST))) {
46                 kref_get(&lkb->lkb_ref);
47                 list_add_tail(&lkb->lkb_astqueue, &ast_queue);
48         }
49         lkb->lkb_ast_type |= type;
50         spin_unlock(&ast_queue_lock);
51
52         set_bit(WAKE_ASTS, &astd_wakeflags);
53         wake_up_process(astd_task);
54 }
55
56 static void process_asts(void)
57 {
58         struct dlm_ls *ls = NULL;
59         struct dlm_rsb *r = NULL;
60         struct dlm_lkb *lkb;
61         void (*cast) (long param);
62         void (*bast) (long param, int mode);
63         int type = 0, found, bmode;
64
65         for (;;) {
66                 found = 0;
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                         found = 1;
79                         break;
80                 }
81                 spin_unlock(&ast_queue_lock);
82
83                 if (!found)
84                         break;
85
86                 cast = lkb->lkb_astaddr;
87                 bast = lkb->lkb_bastaddr;
88                 bmode = lkb->lkb_bastmode;
89
90                 if ((type & AST_COMP) && cast)
91                         cast(lkb->lkb_astparam);
92
93                 /* FIXME: Is it safe to look at lkb_grmode here
94                    without doing a lock_rsb() ?
95                    Look at other checks in v1 to avoid basts. */
96
97                 if ((type & AST_BAST) && bast)
98                         if (!dlm_modes_compat(lkb->lkb_grmode, bmode))
99                                 bast(lkb->lkb_astparam, bmode);
100
101                 /* this removes the reference added by dlm_add_ast
102                    and may result in the lkb being freed */
103                 dlm_put_lkb(lkb);
104
105                 schedule();
106         }
107 }
108
109 static inline int no_asts(void)
110 {
111         int ret;
112
113         spin_lock(&ast_queue_lock);
114         ret = list_empty(&ast_queue);
115         spin_unlock(&ast_queue_lock);
116         return ret;
117 }
118
119 static int dlm_astd(void *data)
120 {
121         while (!kthread_should_stop()) {
122                 set_current_state(TASK_INTERRUPTIBLE);
123                 if (!test_bit(WAKE_ASTS, &astd_wakeflags))
124                         schedule();
125                 set_current_state(TASK_RUNNING);
126
127                 mutex_lock(&astd_running);
128                 if (test_and_clear_bit(WAKE_ASTS, &astd_wakeflags))
129                         process_asts();
130                 mutex_unlock(&astd_running);
131         }
132         return 0;
133 }
134
135 void dlm_astd_wake(void)
136 {
137         if (!no_asts()) {
138                 set_bit(WAKE_ASTS, &astd_wakeflags);
139                 wake_up_process(astd_task);
140         }
141 }
142
143 int dlm_astd_start(void)
144 {
145         struct task_struct *p;
146         int error = 0;
147
148         INIT_LIST_HEAD(&ast_queue);
149         spin_lock_init(&ast_queue_lock);
150         mutex_init(&astd_running);
151
152         p = kthread_run(dlm_astd, NULL, "dlm_astd");
153         if (IS_ERR(p))
154                 error = PTR_ERR(p);
155         else
156                 astd_task = p;
157         return error;
158 }
159
160 void dlm_astd_stop(void)
161 {
162         kthread_stop(astd_task);
163 }
164
165 void dlm_astd_suspend(void)
166 {
167         mutex_lock(&astd_running);
168 }
169
170 void dlm_astd_resume(void)
171 {
172         mutex_unlock(&astd_running);
173 }
174