[PATCH] NLM: fix a client-side race on blocking locks.
[linux-2.6.git] / fs / lockd / clntlock.c
1 /*
2  * linux/fs/lockd/clntlock.c
3  *
4  * Lock handling for the client side NLM implementation
5  *
6  * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
7  */
8
9 #include <linux/module.h>
10 #include <linux/types.h>
11 #include <linux/time.h>
12 #include <linux/nfs_fs.h>
13 #include <linux/sunrpc/clnt.h>
14 #include <linux/sunrpc/svc.h>
15 #include <linux/lockd/lockd.h>
16 #include <linux/smp_lock.h>
17
18 #define NLMDBG_FACILITY         NLMDBG_CLIENT
19
20 /*
21  * Local function prototypes
22  */
23 static int                      reclaimer(void *ptr);
24
25 /*
26  * The following functions handle blocking and granting from the
27  * client perspective.
28  */
29
30 /*
31  * This is the representation of a blocked client lock.
32  */
33 struct nlm_wait {
34         struct list_head        b_list;         /* linked list */
35         wait_queue_head_t       b_wait;         /* where to wait on */
36         struct nlm_host *       b_host;
37         struct file_lock *      b_lock;         /* local file lock */
38         unsigned short          b_reclaim;      /* got to reclaim lock */
39         u32                     b_status;       /* grant callback status */
40 };
41
42 static LIST_HEAD(nlm_blocked);
43
44 /*
45  * Queue up a lock for blocking so that the GRANTED request can see it
46  */
47 int nlmclnt_prepare_block(struct nlm_rqst *req, struct nlm_host *host, struct file_lock *fl)
48 {
49         struct nlm_wait *block;
50
51         BUG_ON(req->a_block != NULL);
52         block = kmalloc(sizeof(*block), GFP_KERNEL);
53         if (block == NULL)
54                 return -ENOMEM;
55         block->b_host = host;
56         block->b_lock = fl;
57         init_waitqueue_head(&block->b_wait);
58         block->b_status = NLM_LCK_BLOCKED;
59
60         list_add(&block->b_list, &nlm_blocked);
61         req->a_block = block;
62
63         return 0;
64 }
65
66 void nlmclnt_finish_block(struct nlm_rqst *req)
67 {
68         struct nlm_wait *block = req->a_block;
69
70         if (block == NULL)
71                 return;
72         req->a_block = NULL;
73         list_del(&block->b_list);
74         kfree(block);
75 }
76
77 /*
78  * Block on a lock
79  */
80 long nlmclnt_block(struct nlm_rqst *req, long timeout)
81 {
82         struct nlm_wait *block = req->a_block;
83         long ret;
84
85         /* A borken server might ask us to block even if we didn't
86          * request it. Just say no!
87          */
88         if (!req->a_args.block)
89                 return -EAGAIN;
90
91         /* Go to sleep waiting for GRANT callback. Some servers seem
92          * to lose callbacks, however, so we're going to poll from
93          * time to time just to make sure.
94          *
95          * For now, the retry frequency is pretty high; normally 
96          * a 1 minute timeout would do. See the comment before
97          * nlmclnt_lock for an explanation.
98          */
99         ret = wait_event_interruptible_timeout(block->b_wait,
100                         block->b_status != NLM_LCK_BLOCKED,
101                         timeout);
102
103         if (block->b_status != NLM_LCK_BLOCKED) {
104                 req->a_res.status = block->b_status;
105                 block->b_status = NLM_LCK_BLOCKED;
106         }
107
108         return ret;
109 }
110
111 /*
112  * The server lockd has called us back to tell us the lock was granted
113  */
114 u32
115 nlmclnt_grant(struct nlm_lock *lock)
116 {
117         struct nlm_wait *block;
118         u32 res = nlm_lck_denied;
119
120         /*
121          * Look up blocked request based on arguments. 
122          * Warning: must not use cookie to match it!
123          */
124         list_for_each_entry(block, &nlm_blocked, b_list) {
125                 if (nlm_compare_locks(block->b_lock, &lock->fl)) {
126                         /* Alright, we found a lock. Set the return status
127                          * and wake up the caller
128                          */
129                         block->b_status = NLM_LCK_GRANTED;
130                         wake_up(&block->b_wait);
131                         res = nlm_granted;
132                 }
133         }
134         return res;
135 }
136
137 /*
138  * The following procedures deal with the recovery of locks after a
139  * server crash.
140  */
141
142 /*
143  * Mark the locks for reclaiming.
144  * FIXME: In 2.5 we don't want to iterate through any global file_lock_list.
145  *        Maintain NLM lock reclaiming lists in the nlm_host instead.
146  */
147 static
148 void nlmclnt_mark_reclaim(struct nlm_host *host)
149 {
150         struct file_lock *fl;
151         struct inode *inode;
152         struct list_head *tmp;
153
154         list_for_each(tmp, &file_lock_list) {
155                 fl = list_entry(tmp, struct file_lock, fl_link);
156
157                 inode = fl->fl_file->f_dentry->d_inode;
158                 if (inode->i_sb->s_magic != NFS_SUPER_MAGIC)
159                         continue;
160                 if (fl->fl_u.nfs_fl.owner->host != host)
161                         continue;
162                 if (!(fl->fl_u.nfs_fl.flags & NFS_LCK_GRANTED))
163                         continue;
164                 fl->fl_u.nfs_fl.flags |= NFS_LCK_RECLAIM;
165         }
166 }
167
168 /*
169  * Someone has sent us an SM_NOTIFY. Ensure we bind to the new port number,
170  * that we mark locks for reclaiming, and that we bump the pseudo NSM state.
171  */
172 static inline
173 void nlmclnt_prepare_reclaim(struct nlm_host *host, u32 newstate)
174 {
175         host->h_monitored = 0;
176         host->h_nsmstate = newstate;
177         host->h_state++;
178         host->h_nextrebind = 0;
179         nlm_rebind_host(host);
180         nlmclnt_mark_reclaim(host);
181         dprintk("NLM: reclaiming locks for host %s", host->h_name);
182 }
183
184 /*
185  * Reclaim all locks on server host. We do this by spawning a separate
186  * reclaimer thread.
187  */
188 void
189 nlmclnt_recovery(struct nlm_host *host, u32 newstate)
190 {
191         if (host->h_reclaiming++) {
192                 if (host->h_nsmstate == newstate)
193                         return;
194                 nlmclnt_prepare_reclaim(host, newstate);
195         } else {
196                 nlmclnt_prepare_reclaim(host, newstate);
197                 nlm_get_host(host);
198                 __module_get(THIS_MODULE);
199                 if (kernel_thread(reclaimer, host, CLONE_KERNEL) < 0)
200                         module_put(THIS_MODULE);
201         }
202 }
203
204 static int
205 reclaimer(void *ptr)
206 {
207         struct nlm_host   *host = (struct nlm_host *) ptr;
208         struct nlm_wait   *block;
209         struct list_head *tmp;
210         struct file_lock *fl;
211         struct inode *inode;
212
213         daemonize("%s-reclaim", host->h_name);
214         allow_signal(SIGKILL);
215
216         /* This one ensures that our parent doesn't terminate while the
217          * reclaim is in progress */
218         lock_kernel();
219         lockd_up();
220
221         /* First, reclaim all locks that have been marked. */
222 restart:
223         list_for_each(tmp, &file_lock_list) {
224                 fl = list_entry(tmp, struct file_lock, fl_link);
225
226                 inode = fl->fl_file->f_dentry->d_inode;
227                 if (inode->i_sb->s_magic != NFS_SUPER_MAGIC)
228                         continue;
229                 if (fl->fl_u.nfs_fl.owner->host != host)
230                         continue;
231                 if (!(fl->fl_u.nfs_fl.flags & NFS_LCK_RECLAIM))
232                         continue;
233
234                 fl->fl_u.nfs_fl.flags &= ~NFS_LCK_RECLAIM;
235                 nlmclnt_reclaim(host, fl);
236                 if (signalled())
237                         break;
238                 goto restart;
239         }
240
241         host->h_reclaiming = 0;
242
243         /* Now, wake up all processes that sleep on a blocked lock */
244         list_for_each_entry(block, &nlm_blocked, b_list) {
245                 if (block->b_host == host) {
246                         block->b_status = NLM_LCK_DENIED_GRACE_PERIOD;
247                         wake_up(&block->b_wait);
248                 }
249         }
250
251         /* Release host handle after use */
252         nlm_release_host(host);
253         lockd_down();
254         unlock_kernel();
255         module_put_and_exit(0);
256 }