Pull throttle into release branch
[linux-2.6] / fs / afs / flock.c
1 /* AFS file locking support
2  *
3  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  */
11
12 #include <linux/smp_lock.h>
13 #include "internal.h"
14
15 #define AFS_LOCK_GRANTED        0
16 #define AFS_LOCK_PENDING        1
17
18 static void afs_fl_copy_lock(struct file_lock *new, struct file_lock *fl);
19 static void afs_fl_release_private(struct file_lock *fl);
20
21 static struct workqueue_struct *afs_lock_manager;
22
23 static struct file_lock_operations afs_lock_ops = {
24         .fl_copy_lock           = afs_fl_copy_lock,
25         .fl_release_private     = afs_fl_release_private,
26 };
27
28 /*
29  * initialise the lock manager thread if it isn't already running
30  */
31 static int afs_init_lock_manager(void)
32 {
33         if (!afs_lock_manager) {
34                 afs_lock_manager = create_singlethread_workqueue("kafs_lockd");
35                 if (!afs_lock_manager)
36                         return -ENOMEM;
37         }
38         return 0;
39 }
40
41 /*
42  * destroy the lock manager thread if it's running
43  */
44 void __exit afs_kill_lock_manager(void)
45 {
46         if (afs_lock_manager)
47                 destroy_workqueue(afs_lock_manager);
48 }
49
50 /*
51  * if the callback is broken on this vnode, then the lock may now be available
52  */
53 void afs_lock_may_be_available(struct afs_vnode *vnode)
54 {
55         _enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode);
56
57         queue_delayed_work(afs_lock_manager, &vnode->lock_work, 0);
58 }
59
60 /*
61  * the lock will time out in 5 minutes unless we extend it, so schedule
62  * extension in a bit less than that time
63  */
64 static void afs_schedule_lock_extension(struct afs_vnode *vnode)
65 {
66         queue_delayed_work(afs_lock_manager, &vnode->lock_work,
67                            AFS_LOCKWAIT * HZ / 2);
68 }
69
70 /*
71  * do work for a lock, including:
72  * - probing for a lock we're waiting on but didn't get immediately
73  * - extending a lock that's close to timing out
74  */
75 void afs_lock_work(struct work_struct *work)
76 {
77         struct afs_vnode *vnode =
78                 container_of(work, struct afs_vnode, lock_work.work);
79         struct file_lock *fl;
80         afs_lock_type_t type;
81         struct key *key;
82         int ret;
83
84         _enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode);
85
86         spin_lock(&vnode->lock);
87
88         if (test_bit(AFS_VNODE_UNLOCKING, &vnode->flags)) {
89                 _debug("unlock");
90                 spin_unlock(&vnode->lock);
91
92                 /* attempt to release the server lock; if it fails, we just
93                  * wait 5 minutes and it'll time out anyway */
94                 ret = afs_vnode_release_lock(vnode, vnode->unlock_key);
95                 if (ret < 0)
96                         printk(KERN_WARNING "AFS:"
97                                " Failed to release lock on {%x:%x} error %d\n",
98                                vnode->fid.vid, vnode->fid.vnode, ret);
99
100                 spin_lock(&vnode->lock);
101                 key_put(vnode->unlock_key);
102                 vnode->unlock_key = NULL;
103                 clear_bit(AFS_VNODE_UNLOCKING, &vnode->flags);
104         }
105
106         /* if we've got a lock, then it must be time to extend that lock as AFS
107          * locks time out after 5 minutes */
108         if (!list_empty(&vnode->granted_locks)) {
109                 _debug("extend");
110
111                 if (test_and_set_bit(AFS_VNODE_LOCKING, &vnode->flags))
112                         BUG();
113                 fl = list_entry(vnode->granted_locks.next,
114                                 struct file_lock, fl_u.afs.link);
115                 key = key_get(fl->fl_file->private_data);
116                 spin_unlock(&vnode->lock);
117
118                 ret = afs_vnode_extend_lock(vnode, key);
119                 clear_bit(AFS_VNODE_LOCKING, &vnode->flags);
120                 key_put(key);
121                 switch (ret) {
122                 case 0:
123                         afs_schedule_lock_extension(vnode);
124                         break;
125                 default:
126                         /* ummm... we failed to extend the lock - retry
127                          * extension shortly */
128                         printk(KERN_WARNING "AFS:"
129                                " Failed to extend lock on {%x:%x} error %d\n",
130                                vnode->fid.vid, vnode->fid.vnode, ret);
131                         queue_delayed_work(afs_lock_manager, &vnode->lock_work,
132                                            HZ * 10);
133                         break;
134                 }
135                 _leave(" [extend]");
136                 return;
137         }
138
139         /* if we don't have a granted lock, then we must've been called back by
140          * the server, and so if might be possible to get a lock we're
141          * currently waiting for */
142         if (!list_empty(&vnode->pending_locks)) {
143                 _debug("get");
144
145                 if (test_and_set_bit(AFS_VNODE_LOCKING, &vnode->flags))
146                         BUG();
147                 fl = list_entry(vnode->pending_locks.next,
148                                 struct file_lock, fl_u.afs.link);
149                 key = key_get(fl->fl_file->private_data);
150                 type = (fl->fl_type == F_RDLCK) ?
151                         AFS_LOCK_READ : AFS_LOCK_WRITE;
152                 spin_unlock(&vnode->lock);
153
154                 ret = afs_vnode_set_lock(vnode, key, type);
155                 clear_bit(AFS_VNODE_LOCKING, &vnode->flags);
156                 switch (ret) {
157                 case -EWOULDBLOCK:
158                         _debug("blocked");
159                         break;
160                 case 0:
161                         _debug("acquired");
162                         if (type == AFS_LOCK_READ)
163                                 set_bit(AFS_VNODE_READLOCKED, &vnode->flags);
164                         else
165                                 set_bit(AFS_VNODE_WRITELOCKED, &vnode->flags);
166                         ret = AFS_LOCK_GRANTED;
167                 default:
168                         spin_lock(&vnode->lock);
169                         /* the pending lock may have been withdrawn due to a
170                          * signal */
171                         if (list_entry(vnode->pending_locks.next,
172                                        struct file_lock, fl_u.afs.link) == fl) {
173                                 fl->fl_u.afs.state = ret;
174                                 if (ret == AFS_LOCK_GRANTED)
175                                         list_move_tail(&fl->fl_u.afs.link,
176                                                        &vnode->granted_locks);
177                                 else
178                                         list_del_init(&fl->fl_u.afs.link);
179                                 wake_up(&fl->fl_wait);
180                                 spin_unlock(&vnode->lock);
181                         } else {
182                                 _debug("withdrawn");
183                                 clear_bit(AFS_VNODE_READLOCKED, &vnode->flags);
184                                 clear_bit(AFS_VNODE_WRITELOCKED, &vnode->flags);
185                                 spin_unlock(&vnode->lock);
186                                 afs_vnode_release_lock(vnode, key);
187                                 if (!list_empty(&vnode->pending_locks))
188                                         afs_lock_may_be_available(vnode);
189                         }
190                         break;
191                 }
192                 key_put(key);
193                 _leave(" [pend]");
194                 return;
195         }
196
197         /* looks like the lock request was withdrawn on a signal */
198         spin_unlock(&vnode->lock);
199         _leave(" [no locks]");
200 }
201
202 /*
203  * pass responsibility for the unlocking of a vnode on the server to the
204  * manager thread, lest a pending signal in the calling thread interrupt
205  * AF_RXRPC
206  * - the caller must hold the vnode lock
207  */
208 static void afs_defer_unlock(struct afs_vnode *vnode, struct key *key)
209 {
210         cancel_delayed_work(&vnode->lock_work);
211         if (!test_and_clear_bit(AFS_VNODE_READLOCKED, &vnode->flags) &&
212             !test_and_clear_bit(AFS_VNODE_WRITELOCKED, &vnode->flags))
213                 BUG();
214         if (test_and_set_bit(AFS_VNODE_UNLOCKING, &vnode->flags))
215                 BUG();
216         vnode->unlock_key = key_get(key);
217         afs_lock_may_be_available(vnode);
218 }
219
220 /*
221  * request a lock on a file on the server
222  */
223 static int afs_do_setlk(struct file *file, struct file_lock *fl)
224 {
225         struct afs_vnode *vnode = AFS_FS_I(file->f_mapping->host);
226         afs_lock_type_t type;
227         struct key *key = file->private_data;
228         int ret;
229
230         _enter("{%x:%u},%u", vnode->fid.vid, vnode->fid.vnode, fl->fl_type);
231
232         /* only whole-file locks are supported */
233         if (fl->fl_start != 0 || fl->fl_end != OFFSET_MAX)
234                 return -EINVAL;
235
236         ret = afs_init_lock_manager();
237         if (ret < 0)
238                 return ret;
239
240         fl->fl_ops = &afs_lock_ops;
241         INIT_LIST_HEAD(&fl->fl_u.afs.link);
242         fl->fl_u.afs.state = AFS_LOCK_PENDING;
243
244         type = (fl->fl_type == F_RDLCK) ? AFS_LOCK_READ : AFS_LOCK_WRITE;
245
246         lock_kernel();
247
248         /* make sure we've got a callback on this file and that our view of the
249          * data version is up to date */
250         ret = afs_vnode_fetch_status(vnode, NULL, key);
251         if (ret < 0)
252                 goto error;
253
254         if (vnode->status.lock_count != 0 && !(fl->fl_flags & FL_SLEEP)) {
255                 ret = -EAGAIN;
256                 goto error;
257         }
258
259         spin_lock(&vnode->lock);
260
261         if (list_empty(&vnode->pending_locks)) {
262                 /* if there's no-one else with a lock on this vnode, then we
263                  * need to ask the server for a lock */
264                 if (list_empty(&vnode->granted_locks)) {
265                         _debug("not locked");
266                         ASSERTCMP(vnode->flags &
267                                   ((1 << AFS_VNODE_LOCKING) |
268                                    (1 << AFS_VNODE_READLOCKED) |
269                                    (1 << AFS_VNODE_WRITELOCKED)), ==, 0);
270                         list_add_tail(&fl->fl_u.afs.link, &vnode->pending_locks);
271                         set_bit(AFS_VNODE_LOCKING, &vnode->flags);
272                         spin_unlock(&vnode->lock);
273
274                         ret = afs_vnode_set_lock(vnode, key, type);
275                         clear_bit(AFS_VNODE_LOCKING, &vnode->flags);
276                         switch (ret) {
277                         case 0:
278                                 goto acquired_server_lock;
279                         case -EWOULDBLOCK:
280                                 spin_lock(&vnode->lock);
281                                 ASSERT(list_empty(&vnode->granted_locks));
282                                 ASSERTCMP(vnode->pending_locks.next, ==,
283                                           &fl->fl_u.afs.link);
284                                 goto wait;
285                         default:
286                                 spin_lock(&vnode->lock);
287                                 list_del_init(&fl->fl_u.afs.link);
288                                 spin_unlock(&vnode->lock);
289                                 goto error;
290                         }
291                 }
292
293                 /* if we've already got a readlock on the server and no waiting
294                  * writelocks, then we might be able to instantly grant another
295                  * readlock */
296                 if (type == AFS_LOCK_READ &&
297                     vnode->flags & (1 << AFS_VNODE_READLOCKED)) {
298                         _debug("instant readlock");
299                         ASSERTCMP(vnode->flags &
300                                   ((1 << AFS_VNODE_LOCKING) |
301                                    (1 << AFS_VNODE_WRITELOCKED)), ==, 0);
302                         ASSERT(!list_empty(&vnode->granted_locks));
303                         goto sharing_existing_lock;
304                 }
305         }
306
307         /* otherwise, we need to wait for a local lock to become available */
308         _debug("wait local");
309         list_add_tail(&fl->fl_u.afs.link, &vnode->pending_locks);
310 wait:
311         if (!(fl->fl_flags & FL_SLEEP)) {
312                 _debug("noblock");
313                 ret = -EAGAIN;
314                 goto abort_attempt;
315         }
316         spin_unlock(&vnode->lock);
317
318         /* now we need to sleep and wait for the lock manager thread to get the
319          * lock from the server */
320         _debug("sleep");
321         ret = wait_event_interruptible(fl->fl_wait,
322                                        fl->fl_u.afs.state <= AFS_LOCK_GRANTED);
323         if (fl->fl_u.afs.state <= AFS_LOCK_GRANTED) {
324                 ret = fl->fl_u.afs.state;
325                 if (ret < 0)
326                         goto error;
327                 spin_lock(&vnode->lock);
328                 goto given_lock;
329         }
330
331         /* we were interrupted, but someone may still be in the throes of
332          * giving us the lock */
333         _debug("intr");
334         ASSERTCMP(ret, ==, -ERESTARTSYS);
335
336         spin_lock(&vnode->lock);
337         if (fl->fl_u.afs.state <= AFS_LOCK_GRANTED) {
338                 ret = fl->fl_u.afs.state;
339                 if (ret < 0) {
340                         spin_unlock(&vnode->lock);
341                         goto error;
342                 }
343                 goto given_lock;
344         }
345
346 abort_attempt:
347         /* we aren't going to get the lock, either because we're unwilling to
348          * wait, or because some signal happened */
349         _debug("abort");
350         if (list_empty(&vnode->granted_locks) &&
351             vnode->pending_locks.next == &fl->fl_u.afs.link) {
352                 if (vnode->pending_locks.prev != &fl->fl_u.afs.link) {
353                         /* kick the next pending lock into having a go */
354                         list_del_init(&fl->fl_u.afs.link);
355                         afs_lock_may_be_available(vnode);
356                 }
357         } else {
358                 list_del_init(&fl->fl_u.afs.link);
359         }
360         spin_unlock(&vnode->lock);
361         goto error;
362
363 acquired_server_lock:
364         /* we've acquired a server lock, but it needs to be renewed after 5
365          * mins */
366         spin_lock(&vnode->lock);
367         afs_schedule_lock_extension(vnode);
368         if (type == AFS_LOCK_READ)
369                 set_bit(AFS_VNODE_READLOCKED, &vnode->flags);
370         else
371                 set_bit(AFS_VNODE_WRITELOCKED, &vnode->flags);
372 sharing_existing_lock:
373         /* the lock has been granted as far as we're concerned... */
374         fl->fl_u.afs.state = AFS_LOCK_GRANTED;
375         list_move_tail(&fl->fl_u.afs.link, &vnode->granted_locks);
376 given_lock:
377         /* ... but we do still need to get the VFS's blessing */
378         ASSERT(!(vnode->flags & (1 << AFS_VNODE_LOCKING)));
379         ASSERT((vnode->flags & ((1 << AFS_VNODE_READLOCKED) |
380                                 (1 << AFS_VNODE_WRITELOCKED))) != 0);
381         ret = posix_lock_file(file, fl, NULL);
382         if (ret < 0)
383                 goto vfs_rejected_lock;
384         spin_unlock(&vnode->lock);
385
386         /* again, make sure we've got a callback on this file and, again, make
387          * sure that our view of the data version is up to date (we ignore
388          * errors incurred here and deal with the consequences elsewhere) */
389         afs_vnode_fetch_status(vnode, NULL, key);
390
391 error:
392         unlock_kernel();
393         _leave(" = %d", ret);
394         return ret;
395
396 vfs_rejected_lock:
397         /* the VFS rejected the lock we just obtained, so we have to discard
398          * what we just got */
399         _debug("vfs refused %d", ret);
400         list_del_init(&fl->fl_u.afs.link);
401         if (list_empty(&vnode->granted_locks))
402                 afs_defer_unlock(vnode, key);
403         spin_unlock(&vnode->lock);
404         goto abort_attempt;
405 }
406
407 /*
408  * unlock on a file on the server
409  */
410 static int afs_do_unlk(struct file *file, struct file_lock *fl)
411 {
412         struct afs_vnode *vnode = AFS_FS_I(file->f_mapping->host);
413         struct key *key = file->private_data;
414         int ret;
415
416         _enter("{%x:%u},%u", vnode->fid.vid, vnode->fid.vnode, fl->fl_type);
417
418         /* only whole-file unlocks are supported */
419         if (fl->fl_start != 0 || fl->fl_end != OFFSET_MAX)
420                 return -EINVAL;
421
422         fl->fl_ops = &afs_lock_ops;
423         INIT_LIST_HEAD(&fl->fl_u.afs.link);
424         fl->fl_u.afs.state = AFS_LOCK_PENDING;
425
426         spin_lock(&vnode->lock);
427         ret = posix_lock_file(file, fl, NULL);
428         if (ret < 0) {
429                 spin_unlock(&vnode->lock);
430                 _leave(" = %d [vfs]", ret);
431                 return ret;
432         }
433
434         /* discard the server lock only if all granted locks are gone */
435         if (list_empty(&vnode->granted_locks))
436                 afs_defer_unlock(vnode, key);
437         spin_unlock(&vnode->lock);
438         _leave(" = 0");
439         return 0;
440 }
441
442 /*
443  * return information about a lock we currently hold, if indeed we hold one
444  */
445 static int afs_do_getlk(struct file *file, struct file_lock *fl)
446 {
447         struct afs_vnode *vnode = AFS_FS_I(file->f_mapping->host);
448         struct key *key = file->private_data;
449         int ret, lock_count;
450
451         _enter("");
452
453         fl->fl_type = F_UNLCK;
454
455         mutex_lock(&vnode->vfs_inode.i_mutex);
456
457         /* check local lock records first */
458         ret = 0;
459         posix_test_lock(file, fl);
460         if (fl->fl_type == F_UNLCK) {
461                 /* no local locks; consult the server */
462                 ret = afs_vnode_fetch_status(vnode, NULL, key);
463                 if (ret < 0)
464                         goto error;
465                 lock_count = vnode->status.lock_count;
466                 if (lock_count) {
467                         if (lock_count > 0)
468                                 fl->fl_type = F_RDLCK;
469                         else
470                                 fl->fl_type = F_WRLCK;
471                         fl->fl_start = 0;
472                         fl->fl_end = OFFSET_MAX;
473                 }
474         }
475
476 error:
477         mutex_unlock(&vnode->vfs_inode.i_mutex);
478         _leave(" = %d [%hd]", ret, fl->fl_type);
479         return ret;
480 }
481
482 /*
483  * manage POSIX locks on a file
484  */
485 int afs_lock(struct file *file, int cmd, struct file_lock *fl)
486 {
487         struct afs_vnode *vnode = AFS_FS_I(file->f_dentry->d_inode);
488
489         _enter("{%x:%u},%d,{t=%x,fl=%x,r=%Ld:%Ld}",
490                vnode->fid.vid, vnode->fid.vnode, cmd,
491                fl->fl_type, fl->fl_flags,
492                (long long) fl->fl_start, (long long) fl->fl_end);
493
494         /* AFS doesn't support mandatory locks */
495         if ((vnode->vfs_inode.i_mode & (S_ISGID | S_IXGRP)) == S_ISGID &&
496             fl->fl_type != F_UNLCK)
497                 return -ENOLCK;
498
499         if (IS_GETLK(cmd))
500                 return afs_do_getlk(file, fl);
501         if (fl->fl_type == F_UNLCK)
502                 return afs_do_unlk(file, fl);
503         return afs_do_setlk(file, fl);
504 }
505
506 /*
507  * manage FLOCK locks on a file
508  */
509 int afs_flock(struct file *file, int cmd, struct file_lock *fl)
510 {
511         struct afs_vnode *vnode = AFS_FS_I(file->f_dentry->d_inode);
512
513         _enter("{%x:%u},%d,{t=%x,fl=%x}",
514                vnode->fid.vid, vnode->fid.vnode, cmd,
515                fl->fl_type, fl->fl_flags);
516
517         /*
518          * No BSD flocks over NFS allowed.
519          * Note: we could try to fake a POSIX lock request here by
520          * using ((u32) filp | 0x80000000) or some such as the pid.
521          * Not sure whether that would be unique, though, or whether
522          * that would break in other places.
523          */
524         if (!(fl->fl_flags & FL_FLOCK))
525                 return -ENOLCK;
526
527         /* we're simulating flock() locks using posix locks on the server */
528         fl->fl_owner = (fl_owner_t) file;
529         fl->fl_start = 0;
530         fl->fl_end = OFFSET_MAX;
531
532         if (fl->fl_type == F_UNLCK)
533                 return afs_do_unlk(file, fl);
534         return afs_do_setlk(file, fl);
535 }
536
537 /*
538  * the POSIX lock management core VFS code copies the lock record and adds the
539  * copy into its own list, so we need to add that copy to the vnode's lock
540  * queue in the same place as the original (which will be deleted shortly
541  * after)
542  */
543 static void afs_fl_copy_lock(struct file_lock *new, struct file_lock *fl)
544 {
545         _enter("");
546
547         list_add(&new->fl_u.afs.link, &fl->fl_u.afs.link);
548 }
549
550 /*
551  * need to remove this lock from the vnode queue when it's removed from the
552  * VFS's list
553  */
554 static void afs_fl_release_private(struct file_lock *fl)
555 {
556         _enter("");
557
558         list_del_init(&fl->fl_u.afs.link);
559 }