Merge branch 'for-3.11' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/libata
[platform/adaptation/renesas_rcar/renesas_kernel.git] / fs / locks.c
1 /*
2  *  linux/fs/locks.c
3  *
4  *  Provide support for fcntl()'s F_GETLK, F_SETLK, and F_SETLKW calls.
5  *  Doug Evans (dje@spiff.uucp), August 07, 1992
6  *
7  *  Deadlock detection added.
8  *  FIXME: one thing isn't handled yet:
9  *      - mandatory locks (requires lots of changes elsewhere)
10  *  Kelly Carmichael (kelly@[142.24.8.65]), September 17, 1994.
11  *
12  *  Miscellaneous edits, and a total rewrite of posix_lock_file() code.
13  *  Kai Petzke (wpp@marie.physik.tu-berlin.de), 1994
14  *  
15  *  Converted file_lock_table to a linked list from an array, which eliminates
16  *  the limits on how many active file locks are open.
17  *  Chad Page (pageone@netcom.com), November 27, 1994
18  * 
19  *  Removed dependency on file descriptors. dup()'ed file descriptors now
20  *  get the same locks as the original file descriptors, and a close() on
21  *  any file descriptor removes ALL the locks on the file for the current
22  *  process. Since locks still depend on the process id, locks are inherited
23  *  after an exec() but not after a fork(). This agrees with POSIX, and both
24  *  BSD and SVR4 practice.
25  *  Andy Walker (andy@lysaker.kvaerner.no), February 14, 1995
26  *
27  *  Scrapped free list which is redundant now that we allocate locks
28  *  dynamically with kmalloc()/kfree().
29  *  Andy Walker (andy@lysaker.kvaerner.no), February 21, 1995
30  *
31  *  Implemented two lock personalities - FL_FLOCK and FL_POSIX.
32  *
33  *  FL_POSIX locks are created with calls to fcntl() and lockf() through the
34  *  fcntl() system call. They have the semantics described above.
35  *
36  *  FL_FLOCK locks are created with calls to flock(), through the flock()
37  *  system call, which is new. Old C libraries implement flock() via fcntl()
38  *  and will continue to use the old, broken implementation.
39  *
40  *  FL_FLOCK locks follow the 4.4 BSD flock() semantics. They are associated
41  *  with a file pointer (filp). As a result they can be shared by a parent
42  *  process and its children after a fork(). They are removed when the last
43  *  file descriptor referring to the file pointer is closed (unless explicitly
44  *  unlocked). 
45  *
46  *  FL_FLOCK locks never deadlock, an existing lock is always removed before
47  *  upgrading from shared to exclusive (or vice versa). When this happens
48  *  any processes blocked by the current lock are woken up and allowed to
49  *  run before the new lock is applied.
50  *  Andy Walker (andy@lysaker.kvaerner.no), June 09, 1995
51  *
52  *  Removed some race conditions in flock_lock_file(), marked other possible
53  *  races. Just grep for FIXME to see them. 
54  *  Dmitry Gorodchanin (pgmdsg@ibi.com), February 09, 1996.
55  *
56  *  Addressed Dmitry's concerns. Deadlock checking no longer recursive.
57  *  Lock allocation changed to GFP_ATOMIC as we can't afford to sleep
58  *  once we've checked for blocking and deadlocking.
59  *  Andy Walker (andy@lysaker.kvaerner.no), April 03, 1996.
60  *
61  *  Initial implementation of mandatory locks. SunOS turned out to be
62  *  a rotten model, so I implemented the "obvious" semantics.
63  *  See 'Documentation/filesystems/mandatory-locking.txt' for details.
64  *  Andy Walker (andy@lysaker.kvaerner.no), April 06, 1996.
65  *
66  *  Don't allow mandatory locks on mmap()'ed files. Added simple functions to
67  *  check if a file has mandatory locks, used by mmap(), open() and creat() to
68  *  see if system call should be rejected. Ref. HP-UX/SunOS/Solaris Reference
69  *  Manual, Section 2.
70  *  Andy Walker (andy@lysaker.kvaerner.no), April 09, 1996.
71  *
72  *  Tidied up block list handling. Added '/proc/locks' interface.
73  *  Andy Walker (andy@lysaker.kvaerner.no), April 24, 1996.
74  *
75  *  Fixed deadlock condition for pathological code that mixes calls to
76  *  flock() and fcntl().
77  *  Andy Walker (andy@lysaker.kvaerner.no), April 29, 1996.
78  *
79  *  Allow only one type of locking scheme (FL_POSIX or FL_FLOCK) to be in use
80  *  for a given file at a time. Changed the CONFIG_LOCK_MANDATORY scheme to
81  *  guarantee sensible behaviour in the case where file system modules might
82  *  be compiled with different options than the kernel itself.
83  *  Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996.
84  *
85  *  Added a couple of missing wake_up() calls. Thanks to Thomas Meckel
86  *  (Thomas.Meckel@mni.fh-giessen.de) for spotting this.
87  *  Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996.
88  *
89  *  Changed FL_POSIX locks to use the block list in the same way as FL_FLOCK
90  *  locks. Changed process synchronisation to avoid dereferencing locks that
91  *  have already been freed.
92  *  Andy Walker (andy@lysaker.kvaerner.no), Sep 21, 1996.
93  *
94  *  Made the block list a circular list to minimise searching in the list.
95  *  Andy Walker (andy@lysaker.kvaerner.no), Sep 25, 1996.
96  *
97  *  Made mandatory locking a mount option. Default is not to allow mandatory
98  *  locking.
99  *  Andy Walker (andy@lysaker.kvaerner.no), Oct 04, 1996.
100  *
101  *  Some adaptations for NFS support.
102  *  Olaf Kirch (okir@monad.swb.de), Dec 1996,
103  *
104  *  Fixed /proc/locks interface so that we can't overrun the buffer we are handed.
105  *  Andy Walker (andy@lysaker.kvaerner.no), May 12, 1997.
106  *
107  *  Use slab allocator instead of kmalloc/kfree.
108  *  Use generic list implementation from <linux/list.h>.
109  *  Sped up posix_locks_deadlock by only considering blocked locks.
110  *  Matthew Wilcox <willy@debian.org>, March, 2000.
111  *
112  *  Leases and LOCK_MAND
113  *  Matthew Wilcox <willy@debian.org>, June, 2000.
114  *  Stephen Rothwell <sfr@canb.auug.org.au>, June, 2000.
115  */
116
117 #include <linux/capability.h>
118 #include <linux/file.h>
119 #include <linux/fdtable.h>
120 #include <linux/fs.h>
121 #include <linux/init.h>
122 #include <linux/module.h>
123 #include <linux/security.h>
124 #include <linux/slab.h>
125 #include <linux/syscalls.h>
126 #include <linux/time.h>
127 #include <linux/rcupdate.h>
128 #include <linux/pid_namespace.h>
129 #include <linux/hashtable.h>
130
131 #include <asm/uaccess.h>
132
133 #define IS_POSIX(fl)    (fl->fl_flags & FL_POSIX)
134 #define IS_FLOCK(fl)    (fl->fl_flags & FL_FLOCK)
135 #define IS_LEASE(fl)    (fl->fl_flags & FL_LEASE)
136
137 static bool lease_breaking(struct file_lock *fl)
138 {
139         return fl->fl_flags & (FL_UNLOCK_PENDING | FL_DOWNGRADE_PENDING);
140 }
141
142 static int target_leasetype(struct file_lock *fl)
143 {
144         if (fl->fl_flags & FL_UNLOCK_PENDING)
145                 return F_UNLCK;
146         if (fl->fl_flags & FL_DOWNGRADE_PENDING)
147                 return F_RDLCK;
148         return fl->fl_type;
149 }
150
151 int leases_enable = 1;
152 int lease_break_time = 45;
153
154 #define for_each_lock(inode, lockp) \
155         for (lockp = &inode->i_flock; *lockp != NULL; lockp = &(*lockp)->fl_next)
156
157 /*
158  * The global file_lock_list is only used for displaying /proc/locks. Protected
159  * by the file_lock_lock.
160  */
161 static HLIST_HEAD(file_lock_list);
162 static DEFINE_SPINLOCK(file_lock_lock);
163
164 /*
165  * The blocked_hash is used to find POSIX lock loops for deadlock detection.
166  * It is protected by blocked_lock_lock.
167  *
168  * We hash locks by lockowner in order to optimize searching for the lock a
169  * particular lockowner is waiting on.
170  *
171  * FIXME: make this value scale via some heuristic? We generally will want more
172  * buckets when we have more lockowners holding locks, but that's a little
173  * difficult to determine without knowing what the workload will look like.
174  */
175 #define BLOCKED_HASH_BITS       7
176 static DEFINE_HASHTABLE(blocked_hash, BLOCKED_HASH_BITS);
177
178 /*
179  * This lock protects the blocked_hash. Generally, if you're accessing it, you
180  * want to be holding this lock.
181  *
182  * In addition, it also protects the fl->fl_block list, and the fl->fl_next
183  * pointer for file_lock structures that are acting as lock requests (in
184  * contrast to those that are acting as records of acquired locks).
185  *
186  * Note that when we acquire this lock in order to change the above fields,
187  * we often hold the i_lock as well. In certain cases, when reading the fields
188  * protected by this lock, we can skip acquiring it iff we already hold the
189  * i_lock.
190  *
191  * In particular, adding an entry to the fl_block list requires that you hold
192  * both the i_lock and the blocked_lock_lock (acquired in that order). Deleting
193  * an entry from the list however only requires the file_lock_lock.
194  */
195 static DEFINE_SPINLOCK(blocked_lock_lock);
196
197 static struct kmem_cache *filelock_cache __read_mostly;
198
199 static void locks_init_lock_heads(struct file_lock *fl)
200 {
201         INIT_HLIST_NODE(&fl->fl_link);
202         INIT_LIST_HEAD(&fl->fl_block);
203         init_waitqueue_head(&fl->fl_wait);
204 }
205
206 /* Allocate an empty lock structure. */
207 struct file_lock *locks_alloc_lock(void)
208 {
209         struct file_lock *fl = kmem_cache_zalloc(filelock_cache, GFP_KERNEL);
210
211         if (fl)
212                 locks_init_lock_heads(fl);
213
214         return fl;
215 }
216 EXPORT_SYMBOL_GPL(locks_alloc_lock);
217
218 void locks_release_private(struct file_lock *fl)
219 {
220         if (fl->fl_ops) {
221                 if (fl->fl_ops->fl_release_private)
222                         fl->fl_ops->fl_release_private(fl);
223                 fl->fl_ops = NULL;
224         }
225         fl->fl_lmops = NULL;
226
227 }
228 EXPORT_SYMBOL_GPL(locks_release_private);
229
230 /* Free a lock which is not in use. */
231 void locks_free_lock(struct file_lock *fl)
232 {
233         BUG_ON(waitqueue_active(&fl->fl_wait));
234         BUG_ON(!list_empty(&fl->fl_block));
235         BUG_ON(!hlist_unhashed(&fl->fl_link));
236
237         locks_release_private(fl);
238         kmem_cache_free(filelock_cache, fl);
239 }
240 EXPORT_SYMBOL(locks_free_lock);
241
242 void locks_init_lock(struct file_lock *fl)
243 {
244         memset(fl, 0, sizeof(struct file_lock));
245         locks_init_lock_heads(fl);
246 }
247
248 EXPORT_SYMBOL(locks_init_lock);
249
250 static void locks_copy_private(struct file_lock *new, struct file_lock *fl)
251 {
252         if (fl->fl_ops) {
253                 if (fl->fl_ops->fl_copy_lock)
254                         fl->fl_ops->fl_copy_lock(new, fl);
255                 new->fl_ops = fl->fl_ops;
256         }
257         if (fl->fl_lmops)
258                 new->fl_lmops = fl->fl_lmops;
259 }
260
261 /*
262  * Initialize a new lock from an existing file_lock structure.
263  */
264 void __locks_copy_lock(struct file_lock *new, const struct file_lock *fl)
265 {
266         new->fl_owner = fl->fl_owner;
267         new->fl_pid = fl->fl_pid;
268         new->fl_file = NULL;
269         new->fl_flags = fl->fl_flags;
270         new->fl_type = fl->fl_type;
271         new->fl_start = fl->fl_start;
272         new->fl_end = fl->fl_end;
273         new->fl_ops = NULL;
274         new->fl_lmops = NULL;
275 }
276 EXPORT_SYMBOL(__locks_copy_lock);
277
278 void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
279 {
280         locks_release_private(new);
281
282         __locks_copy_lock(new, fl);
283         new->fl_file = fl->fl_file;
284         new->fl_ops = fl->fl_ops;
285         new->fl_lmops = fl->fl_lmops;
286
287         locks_copy_private(new, fl);
288 }
289
290 EXPORT_SYMBOL(locks_copy_lock);
291
292 static inline int flock_translate_cmd(int cmd) {
293         if (cmd & LOCK_MAND)
294                 return cmd & (LOCK_MAND | LOCK_RW);
295         switch (cmd) {
296         case LOCK_SH:
297                 return F_RDLCK;
298         case LOCK_EX:
299                 return F_WRLCK;
300         case LOCK_UN:
301                 return F_UNLCK;
302         }
303         return -EINVAL;
304 }
305
306 /* Fill in a file_lock structure with an appropriate FLOCK lock. */
307 static int flock_make_lock(struct file *filp, struct file_lock **lock,
308                 unsigned int cmd)
309 {
310         struct file_lock *fl;
311         int type = flock_translate_cmd(cmd);
312         if (type < 0)
313                 return type;
314         
315         fl = locks_alloc_lock();
316         if (fl == NULL)
317                 return -ENOMEM;
318
319         fl->fl_file = filp;
320         fl->fl_pid = current->tgid;
321         fl->fl_flags = FL_FLOCK;
322         fl->fl_type = type;
323         fl->fl_end = OFFSET_MAX;
324         
325         *lock = fl;
326         return 0;
327 }
328
329 static int assign_type(struct file_lock *fl, long type)
330 {
331         switch (type) {
332         case F_RDLCK:
333         case F_WRLCK:
334         case F_UNLCK:
335                 fl->fl_type = type;
336                 break;
337         default:
338                 return -EINVAL;
339         }
340         return 0;
341 }
342
343 /* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX
344  * style lock.
345  */
346 static int flock_to_posix_lock(struct file *filp, struct file_lock *fl,
347                                struct flock *l)
348 {
349         off_t start, end;
350
351         switch (l->l_whence) {
352         case SEEK_SET:
353                 start = 0;
354                 break;
355         case SEEK_CUR:
356                 start = filp->f_pos;
357                 break;
358         case SEEK_END:
359                 start = i_size_read(file_inode(filp));
360                 break;
361         default:
362                 return -EINVAL;
363         }
364
365         /* POSIX-1996 leaves the case l->l_len < 0 undefined;
366            POSIX-2001 defines it. */
367         start += l->l_start;
368         if (start < 0)
369                 return -EINVAL;
370         fl->fl_end = OFFSET_MAX;
371         if (l->l_len > 0) {
372                 end = start + l->l_len - 1;
373                 fl->fl_end = end;
374         } else if (l->l_len < 0) {
375                 end = start - 1;
376                 fl->fl_end = end;
377                 start += l->l_len;
378                 if (start < 0)
379                         return -EINVAL;
380         }
381         fl->fl_start = start;   /* we record the absolute position */
382         if (fl->fl_end < fl->fl_start)
383                 return -EOVERFLOW;
384         
385         fl->fl_owner = current->files;
386         fl->fl_pid = current->tgid;
387         fl->fl_file = filp;
388         fl->fl_flags = FL_POSIX;
389         fl->fl_ops = NULL;
390         fl->fl_lmops = NULL;
391
392         return assign_type(fl, l->l_type);
393 }
394
395 #if BITS_PER_LONG == 32
396 static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl,
397                                  struct flock64 *l)
398 {
399         loff_t start;
400
401         switch (l->l_whence) {
402         case SEEK_SET:
403                 start = 0;
404                 break;
405         case SEEK_CUR:
406                 start = filp->f_pos;
407                 break;
408         case SEEK_END:
409                 start = i_size_read(file_inode(filp));
410                 break;
411         default:
412                 return -EINVAL;
413         }
414
415         start += l->l_start;
416         if (start < 0)
417                 return -EINVAL;
418         fl->fl_end = OFFSET_MAX;
419         if (l->l_len > 0) {
420                 fl->fl_end = start + l->l_len - 1;
421         } else if (l->l_len < 0) {
422                 fl->fl_end = start - 1;
423                 start += l->l_len;
424                 if (start < 0)
425                         return -EINVAL;
426         }
427         fl->fl_start = start;   /* we record the absolute position */
428         if (fl->fl_end < fl->fl_start)
429                 return -EOVERFLOW;
430         
431         fl->fl_owner = current->files;
432         fl->fl_pid = current->tgid;
433         fl->fl_file = filp;
434         fl->fl_flags = FL_POSIX;
435         fl->fl_ops = NULL;
436         fl->fl_lmops = NULL;
437
438         return assign_type(fl, l->l_type);
439 }
440 #endif
441
442 /* default lease lock manager operations */
443 static void lease_break_callback(struct file_lock *fl)
444 {
445         kill_fasync(&fl->fl_fasync, SIGIO, POLL_MSG);
446 }
447
448 static const struct lock_manager_operations lease_manager_ops = {
449         .lm_break = lease_break_callback,
450         .lm_change = lease_modify,
451 };
452
453 /*
454  * Initialize a lease, use the default lock manager operations
455  */
456 static int lease_init(struct file *filp, long type, struct file_lock *fl)
457  {
458         if (assign_type(fl, type) != 0)
459                 return -EINVAL;
460
461         fl->fl_owner = current->files;
462         fl->fl_pid = current->tgid;
463
464         fl->fl_file = filp;
465         fl->fl_flags = FL_LEASE;
466         fl->fl_start = 0;
467         fl->fl_end = OFFSET_MAX;
468         fl->fl_ops = NULL;
469         fl->fl_lmops = &lease_manager_ops;
470         return 0;
471 }
472
473 /* Allocate a file_lock initialised to this type of lease */
474 static struct file_lock *lease_alloc(struct file *filp, long type)
475 {
476         struct file_lock *fl = locks_alloc_lock();
477         int error = -ENOMEM;
478
479         if (fl == NULL)
480                 return ERR_PTR(error);
481
482         error = lease_init(filp, type, fl);
483         if (error) {
484                 locks_free_lock(fl);
485                 return ERR_PTR(error);
486         }
487         return fl;
488 }
489
490 /* Check if two locks overlap each other.
491  */
492 static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2)
493 {
494         return ((fl1->fl_end >= fl2->fl_start) &&
495                 (fl2->fl_end >= fl1->fl_start));
496 }
497
498 /*
499  * Check whether two locks have the same owner.
500  */
501 static int posix_same_owner(struct file_lock *fl1, struct file_lock *fl2)
502 {
503         if (fl1->fl_lmops && fl1->fl_lmops->lm_compare_owner)
504                 return fl2->fl_lmops == fl1->fl_lmops &&
505                         fl1->fl_lmops->lm_compare_owner(fl1, fl2);
506         return fl1->fl_owner == fl2->fl_owner;
507 }
508
509 static inline void
510 locks_insert_global_locks(struct file_lock *fl)
511 {
512         spin_lock(&file_lock_lock);
513         hlist_add_head(&fl->fl_link, &file_lock_list);
514         spin_unlock(&file_lock_lock);
515 }
516
517 static inline void
518 locks_delete_global_locks(struct file_lock *fl)
519 {
520         spin_lock(&file_lock_lock);
521         hlist_del_init(&fl->fl_link);
522         spin_unlock(&file_lock_lock);
523 }
524
525 static unsigned long
526 posix_owner_key(struct file_lock *fl)
527 {
528         if (fl->fl_lmops && fl->fl_lmops->lm_owner_key)
529                 return fl->fl_lmops->lm_owner_key(fl);
530         return (unsigned long)fl->fl_owner;
531 }
532
533 static inline void
534 locks_insert_global_blocked(struct file_lock *waiter)
535 {
536         hash_add(blocked_hash, &waiter->fl_link, posix_owner_key(waiter));
537 }
538
539 static inline void
540 locks_delete_global_blocked(struct file_lock *waiter)
541 {
542         hash_del(&waiter->fl_link);
543 }
544
545 /* Remove waiter from blocker's block list.
546  * When blocker ends up pointing to itself then the list is empty.
547  *
548  * Must be called with blocked_lock_lock held.
549  */
550 static void __locks_delete_block(struct file_lock *waiter)
551 {
552         locks_delete_global_blocked(waiter);
553         list_del_init(&waiter->fl_block);
554         waiter->fl_next = NULL;
555 }
556
557 static void locks_delete_block(struct file_lock *waiter)
558 {
559         spin_lock(&blocked_lock_lock);
560         __locks_delete_block(waiter);
561         spin_unlock(&blocked_lock_lock);
562 }
563
564 /* Insert waiter into blocker's block list.
565  * We use a circular list so that processes can be easily woken up in
566  * the order they blocked. The documentation doesn't require this but
567  * it seems like the reasonable thing to do.
568  *
569  * Must be called with both the i_lock and blocked_lock_lock held. The fl_block
570  * list itself is protected by the file_lock_list, but by ensuring that the
571  * i_lock is also held on insertions we can avoid taking the blocked_lock_lock
572  * in some cases when we see that the fl_block list is empty.
573  */
574 static void __locks_insert_block(struct file_lock *blocker,
575                                         struct file_lock *waiter)
576 {
577         BUG_ON(!list_empty(&waiter->fl_block));
578         waiter->fl_next = blocker;
579         list_add_tail(&waiter->fl_block, &blocker->fl_block);
580         if (IS_POSIX(blocker))
581                 locks_insert_global_blocked(waiter);
582 }
583
584 /* Must be called with i_lock held. */
585 static void locks_insert_block(struct file_lock *blocker,
586                                         struct file_lock *waiter)
587 {
588         spin_lock(&blocked_lock_lock);
589         __locks_insert_block(blocker, waiter);
590         spin_unlock(&blocked_lock_lock);
591 }
592
593 /*
594  * Wake up processes blocked waiting for blocker.
595  *
596  * Must be called with the inode->i_lock held!
597  */
598 static void locks_wake_up_blocks(struct file_lock *blocker)
599 {
600         /*
601          * Avoid taking global lock if list is empty. This is safe since new
602          * blocked requests are only added to the list under the i_lock, and
603          * the i_lock is always held here. Note that removal from the fl_block
604          * list does not require the i_lock, so we must recheck list_empty()
605          * after acquiring the blocked_lock_lock.
606          */
607         if (list_empty(&blocker->fl_block))
608                 return;
609
610         spin_lock(&blocked_lock_lock);
611         while (!list_empty(&blocker->fl_block)) {
612                 struct file_lock *waiter;
613
614                 waiter = list_first_entry(&blocker->fl_block,
615                                 struct file_lock, fl_block);
616                 __locks_delete_block(waiter);
617                 if (waiter->fl_lmops && waiter->fl_lmops->lm_notify)
618                         waiter->fl_lmops->lm_notify(waiter);
619                 else
620                         wake_up(&waiter->fl_wait);
621         }
622         spin_unlock(&blocked_lock_lock);
623 }
624
625 /* Insert file lock fl into an inode's lock list at the position indicated
626  * by pos. At the same time add the lock to the global file lock list.
627  *
628  * Must be called with the i_lock held!
629  */
630 static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl)
631 {
632         fl->fl_nspid = get_pid(task_tgid(current));
633
634         /* insert into file's list */
635         fl->fl_next = *pos;
636         *pos = fl;
637
638         locks_insert_global_locks(fl);
639 }
640
641 /*
642  * Delete a lock and then free it.
643  * Wake up processes that are blocked waiting for this lock,
644  * notify the FS that the lock has been cleared and
645  * finally free the lock.
646  *
647  * Must be called with the i_lock held!
648  */
649 static void locks_delete_lock(struct file_lock **thisfl_p)
650 {
651         struct file_lock *fl = *thisfl_p;
652
653         locks_delete_global_locks(fl);
654
655         *thisfl_p = fl->fl_next;
656         fl->fl_next = NULL;
657
658         if (fl->fl_nspid) {
659                 put_pid(fl->fl_nspid);
660                 fl->fl_nspid = NULL;
661         }
662
663         locks_wake_up_blocks(fl);
664         locks_free_lock(fl);
665 }
666
667 /* Determine if lock sys_fl blocks lock caller_fl. Common functionality
668  * checks for shared/exclusive status of overlapping locks.
669  */
670 static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
671 {
672         if (sys_fl->fl_type == F_WRLCK)
673                 return 1;
674         if (caller_fl->fl_type == F_WRLCK)
675                 return 1;
676         return 0;
677 }
678
679 /* Determine if lock sys_fl blocks lock caller_fl. POSIX specific
680  * checking before calling the locks_conflict().
681  */
682 static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
683 {
684         /* POSIX locks owned by the same process do not conflict with
685          * each other.
686          */
687         if (!IS_POSIX(sys_fl) || posix_same_owner(caller_fl, sys_fl))
688                 return (0);
689
690         /* Check whether they overlap */
691         if (!locks_overlap(caller_fl, sys_fl))
692                 return 0;
693
694         return (locks_conflict(caller_fl, sys_fl));
695 }
696
697 /* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific
698  * checking before calling the locks_conflict().
699  */
700 static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
701 {
702         /* FLOCK locks referring to the same filp do not conflict with
703          * each other.
704          */
705         if (!IS_FLOCK(sys_fl) || (caller_fl->fl_file == sys_fl->fl_file))
706                 return (0);
707         if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND))
708                 return 0;
709
710         return (locks_conflict(caller_fl, sys_fl));
711 }
712
713 void
714 posix_test_lock(struct file *filp, struct file_lock *fl)
715 {
716         struct file_lock *cfl;
717         struct inode *inode = file_inode(filp);
718
719         spin_lock(&inode->i_lock);
720         for (cfl = file_inode(filp)->i_flock; cfl; cfl = cfl->fl_next) {
721                 if (!IS_POSIX(cfl))
722                         continue;
723                 if (posix_locks_conflict(fl, cfl))
724                         break;
725         }
726         if (cfl) {
727                 __locks_copy_lock(fl, cfl);
728                 if (cfl->fl_nspid)
729                         fl->fl_pid = pid_vnr(cfl->fl_nspid);
730         } else
731                 fl->fl_type = F_UNLCK;
732         spin_unlock(&inode->i_lock);
733         return;
734 }
735 EXPORT_SYMBOL(posix_test_lock);
736
737 /*
738  * Deadlock detection:
739  *
740  * We attempt to detect deadlocks that are due purely to posix file
741  * locks.
742  *
743  * We assume that a task can be waiting for at most one lock at a time.
744  * So for any acquired lock, the process holding that lock may be
745  * waiting on at most one other lock.  That lock in turns may be held by
746  * someone waiting for at most one other lock.  Given a requested lock
747  * caller_fl which is about to wait for a conflicting lock block_fl, we
748  * follow this chain of waiters to ensure we are not about to create a
749  * cycle.
750  *
751  * Since we do this before we ever put a process to sleep on a lock, we
752  * are ensured that there is never a cycle; that is what guarantees that
753  * the while() loop in posix_locks_deadlock() eventually completes.
754  *
755  * Note: the above assumption may not be true when handling lock
756  * requests from a broken NFS client. It may also fail in the presence
757  * of tasks (such as posix threads) sharing the same open file table.
758  *
759  * To handle those cases, we just bail out after a few iterations.
760  */
761
762 #define MAX_DEADLK_ITERATIONS 10
763
764 /* Find a lock that the owner of the given block_fl is blocking on. */
765 static struct file_lock *what_owner_is_waiting_for(struct file_lock *block_fl)
766 {
767         struct file_lock *fl;
768
769         hash_for_each_possible(blocked_hash, fl, fl_link, posix_owner_key(block_fl)) {
770                 if (posix_same_owner(fl, block_fl))
771                         return fl->fl_next;
772         }
773         return NULL;
774 }
775
776 /* Must be called with the blocked_lock_lock held! */
777 static int posix_locks_deadlock(struct file_lock *caller_fl,
778                                 struct file_lock *block_fl)
779 {
780         int i = 0;
781
782         while ((block_fl = what_owner_is_waiting_for(block_fl))) {
783                 if (i++ > MAX_DEADLK_ITERATIONS)
784                         return 0;
785                 if (posix_same_owner(caller_fl, block_fl))
786                         return 1;
787         }
788         return 0;
789 }
790
791 /* Try to create a FLOCK lock on filp. We always insert new FLOCK locks
792  * after any leases, but before any posix locks.
793  *
794  * Note that if called with an FL_EXISTS argument, the caller may determine
795  * whether or not a lock was successfully freed by testing the return
796  * value for -ENOENT.
797  */
798 static int flock_lock_file(struct file *filp, struct file_lock *request)
799 {
800         struct file_lock *new_fl = NULL;
801         struct file_lock **before;
802         struct inode * inode = file_inode(filp);
803         int error = 0;
804         int found = 0;
805
806         if (!(request->fl_flags & FL_ACCESS) && (request->fl_type != F_UNLCK)) {
807                 new_fl = locks_alloc_lock();
808                 if (!new_fl)
809                         return -ENOMEM;
810         }
811
812         spin_lock(&inode->i_lock);
813         if (request->fl_flags & FL_ACCESS)
814                 goto find_conflict;
815
816         for_each_lock(inode, before) {
817                 struct file_lock *fl = *before;
818                 if (IS_POSIX(fl))
819                         break;
820                 if (IS_LEASE(fl))
821                         continue;
822                 if (filp != fl->fl_file)
823                         continue;
824                 if (request->fl_type == fl->fl_type)
825                         goto out;
826                 found = 1;
827                 locks_delete_lock(before);
828                 break;
829         }
830
831         if (request->fl_type == F_UNLCK) {
832                 if ((request->fl_flags & FL_EXISTS) && !found)
833                         error = -ENOENT;
834                 goto out;
835         }
836
837         /*
838          * If a higher-priority process was blocked on the old file lock,
839          * give it the opportunity to lock the file.
840          */
841         if (found) {
842                 spin_unlock(&inode->i_lock);
843                 cond_resched();
844                 spin_lock(&inode->i_lock);
845         }
846
847 find_conflict:
848         for_each_lock(inode, before) {
849                 struct file_lock *fl = *before;
850                 if (IS_POSIX(fl))
851                         break;
852                 if (IS_LEASE(fl))
853                         continue;
854                 if (!flock_locks_conflict(request, fl))
855                         continue;
856                 error = -EAGAIN;
857                 if (!(request->fl_flags & FL_SLEEP))
858                         goto out;
859                 error = FILE_LOCK_DEFERRED;
860                 locks_insert_block(fl, request);
861                 goto out;
862         }
863         if (request->fl_flags & FL_ACCESS)
864                 goto out;
865         locks_copy_lock(new_fl, request);
866         locks_insert_lock(before, new_fl);
867         new_fl = NULL;
868         error = 0;
869
870 out:
871         spin_unlock(&inode->i_lock);
872         if (new_fl)
873                 locks_free_lock(new_fl);
874         return error;
875 }
876
877 static int __posix_lock_file(struct inode *inode, struct file_lock *request, struct file_lock *conflock)
878 {
879         struct file_lock *fl;
880         struct file_lock *new_fl = NULL;
881         struct file_lock *new_fl2 = NULL;
882         struct file_lock *left = NULL;
883         struct file_lock *right = NULL;
884         struct file_lock **before;
885         int error;
886         bool added = false;
887
888         /*
889          * We may need two file_lock structures for this operation,
890          * so we get them in advance to avoid races.
891          *
892          * In some cases we can be sure, that no new locks will be needed
893          */
894         if (!(request->fl_flags & FL_ACCESS) &&
895             (request->fl_type != F_UNLCK ||
896              request->fl_start != 0 || request->fl_end != OFFSET_MAX)) {
897                 new_fl = locks_alloc_lock();
898                 new_fl2 = locks_alloc_lock();
899         }
900
901         spin_lock(&inode->i_lock);
902         /*
903          * New lock request. Walk all POSIX locks and look for conflicts. If
904          * there are any, either return error or put the request on the
905          * blocker's list of waiters and the global blocked_hash.
906          */
907         if (request->fl_type != F_UNLCK) {
908                 for_each_lock(inode, before) {
909                         fl = *before;
910                         if (!IS_POSIX(fl))
911                                 continue;
912                         if (!posix_locks_conflict(request, fl))
913                                 continue;
914                         if (conflock)
915                                 __locks_copy_lock(conflock, fl);
916                         error = -EAGAIN;
917                         if (!(request->fl_flags & FL_SLEEP))
918                                 goto out;
919                         /*
920                          * Deadlock detection and insertion into the blocked
921                          * locks list must be done while holding the same lock!
922                          */
923                         error = -EDEADLK;
924                         spin_lock(&blocked_lock_lock);
925                         if (likely(!posix_locks_deadlock(request, fl))) {
926                                 error = FILE_LOCK_DEFERRED;
927                                 __locks_insert_block(fl, request);
928                         }
929                         spin_unlock(&blocked_lock_lock);
930                         goto out;
931                 }
932         }
933
934         /* If we're just looking for a conflict, we're done. */
935         error = 0;
936         if (request->fl_flags & FL_ACCESS)
937                 goto out;
938
939         /*
940          * Find the first old lock with the same owner as the new lock.
941          */
942         
943         before = &inode->i_flock;
944
945         /* First skip locks owned by other processes.  */
946         while ((fl = *before) && (!IS_POSIX(fl) ||
947                                   !posix_same_owner(request, fl))) {
948                 before = &fl->fl_next;
949         }
950
951         /* Process locks with this owner. */
952         while ((fl = *before) && posix_same_owner(request, fl)) {
953                 /* Detect adjacent or overlapping regions (if same lock type)
954                  */
955                 if (request->fl_type == fl->fl_type) {
956                         /* In all comparisons of start vs end, use
957                          * "start - 1" rather than "end + 1". If end
958                          * is OFFSET_MAX, end + 1 will become negative.
959                          */
960                         if (fl->fl_end < request->fl_start - 1)
961                                 goto next_lock;
962                         /* If the next lock in the list has entirely bigger
963                          * addresses than the new one, insert the lock here.
964                          */
965                         if (fl->fl_start - 1 > request->fl_end)
966                                 break;
967
968                         /* If we come here, the new and old lock are of the
969                          * same type and adjacent or overlapping. Make one
970                          * lock yielding from the lower start address of both
971                          * locks to the higher end address.
972                          */
973                         if (fl->fl_start > request->fl_start)
974                                 fl->fl_start = request->fl_start;
975                         else
976                                 request->fl_start = fl->fl_start;
977                         if (fl->fl_end < request->fl_end)
978                                 fl->fl_end = request->fl_end;
979                         else
980                                 request->fl_end = fl->fl_end;
981                         if (added) {
982                                 locks_delete_lock(before);
983                                 continue;
984                         }
985                         request = fl;
986                         added = true;
987                 }
988                 else {
989                         /* Processing for different lock types is a bit
990                          * more complex.
991                          */
992                         if (fl->fl_end < request->fl_start)
993                                 goto next_lock;
994                         if (fl->fl_start > request->fl_end)
995                                 break;
996                         if (request->fl_type == F_UNLCK)
997                                 added = true;
998                         if (fl->fl_start < request->fl_start)
999                                 left = fl;
1000                         /* If the next lock in the list has a higher end
1001                          * address than the new one, insert the new one here.
1002                          */
1003                         if (fl->fl_end > request->fl_end) {
1004                                 right = fl;
1005                                 break;
1006                         }
1007                         if (fl->fl_start >= request->fl_start) {
1008                                 /* The new lock completely replaces an old
1009                                  * one (This may happen several times).
1010                                  */
1011                                 if (added) {
1012                                         locks_delete_lock(before);
1013                                         continue;
1014                                 }
1015                                 /* Replace the old lock with the new one.
1016                                  * Wake up anybody waiting for the old one,
1017                                  * as the change in lock type might satisfy
1018                                  * their needs.
1019                                  */
1020                                 locks_wake_up_blocks(fl);
1021                                 fl->fl_start = request->fl_start;
1022                                 fl->fl_end = request->fl_end;
1023                                 fl->fl_type = request->fl_type;
1024                                 locks_release_private(fl);
1025                                 locks_copy_private(fl, request);
1026                                 request = fl;
1027                                 added = true;
1028                         }
1029                 }
1030                 /* Go on to next lock.
1031                  */
1032         next_lock:
1033                 before = &fl->fl_next;
1034         }
1035
1036         /*
1037          * The above code only modifies existing locks in case of merging or
1038          * replacing. If new lock(s) need to be inserted all modifications are
1039          * done below this, so it's safe yet to bail out.
1040          */
1041         error = -ENOLCK; /* "no luck" */
1042         if (right && left == right && !new_fl2)
1043                 goto out;
1044
1045         error = 0;
1046         if (!added) {
1047                 if (request->fl_type == F_UNLCK) {
1048                         if (request->fl_flags & FL_EXISTS)
1049                                 error = -ENOENT;
1050                         goto out;
1051                 }
1052
1053                 if (!new_fl) {
1054                         error = -ENOLCK;
1055                         goto out;
1056                 }
1057                 locks_copy_lock(new_fl, request);
1058                 locks_insert_lock(before, new_fl);
1059                 new_fl = NULL;
1060         }
1061         if (right) {
1062                 if (left == right) {
1063                         /* The new lock breaks the old one in two pieces,
1064                          * so we have to use the second new lock.
1065                          */
1066                         left = new_fl2;
1067                         new_fl2 = NULL;
1068                         locks_copy_lock(left, right);
1069                         locks_insert_lock(before, left);
1070                 }
1071                 right->fl_start = request->fl_end + 1;
1072                 locks_wake_up_blocks(right);
1073         }
1074         if (left) {
1075                 left->fl_end = request->fl_start - 1;
1076                 locks_wake_up_blocks(left);
1077         }
1078  out:
1079         spin_unlock(&inode->i_lock);
1080         /*
1081          * Free any unused locks.
1082          */
1083         if (new_fl)
1084                 locks_free_lock(new_fl);
1085         if (new_fl2)
1086                 locks_free_lock(new_fl2);
1087         return error;
1088 }
1089
1090 /**
1091  * posix_lock_file - Apply a POSIX-style lock to a file
1092  * @filp: The file to apply the lock to
1093  * @fl: The lock to be applied
1094  * @conflock: Place to return a copy of the conflicting lock, if found.
1095  *
1096  * Add a POSIX style lock to a file.
1097  * We merge adjacent & overlapping locks whenever possible.
1098  * POSIX locks are sorted by owner task, then by starting address
1099  *
1100  * Note that if called with an FL_EXISTS argument, the caller may determine
1101  * whether or not a lock was successfully freed by testing the return
1102  * value for -ENOENT.
1103  */
1104 int posix_lock_file(struct file *filp, struct file_lock *fl,
1105                         struct file_lock *conflock)
1106 {
1107         return __posix_lock_file(file_inode(filp), fl, conflock);
1108 }
1109 EXPORT_SYMBOL(posix_lock_file);
1110
1111 /**
1112  * posix_lock_file_wait - Apply a POSIX-style lock to a file
1113  * @filp: The file to apply the lock to
1114  * @fl: The lock to be applied
1115  *
1116  * Add a POSIX style lock to a file.
1117  * We merge adjacent & overlapping locks whenever possible.
1118  * POSIX locks are sorted by owner task, then by starting address
1119  */
1120 int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
1121 {
1122         int error;
1123         might_sleep ();
1124         for (;;) {
1125                 error = posix_lock_file(filp, fl, NULL);
1126                 if (error != FILE_LOCK_DEFERRED)
1127                         break;
1128                 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
1129                 if (!error)
1130                         continue;
1131
1132                 locks_delete_block(fl);
1133                 break;
1134         }
1135         return error;
1136 }
1137 EXPORT_SYMBOL(posix_lock_file_wait);
1138
1139 /**
1140  * locks_mandatory_locked - Check for an active lock
1141  * @inode: the file to check
1142  *
1143  * Searches the inode's list of locks to find any POSIX locks which conflict.
1144  * This function is called from locks_verify_locked() only.
1145  */
1146 int locks_mandatory_locked(struct inode *inode)
1147 {
1148         fl_owner_t owner = current->files;
1149         struct file_lock *fl;
1150
1151         /*
1152          * Search the lock list for this inode for any POSIX locks.
1153          */
1154         spin_lock(&inode->i_lock);
1155         for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
1156                 if (!IS_POSIX(fl))
1157                         continue;
1158                 if (fl->fl_owner != owner)
1159                         break;
1160         }
1161         spin_unlock(&inode->i_lock);
1162         return fl ? -EAGAIN : 0;
1163 }
1164
1165 /**
1166  * locks_mandatory_area - Check for a conflicting lock
1167  * @read_write: %FLOCK_VERIFY_WRITE for exclusive access, %FLOCK_VERIFY_READ
1168  *              for shared
1169  * @inode:      the file to check
1170  * @filp:       how the file was opened (if it was)
1171  * @offset:     start of area to check
1172  * @count:      length of area to check
1173  *
1174  * Searches the inode's list of locks to find any POSIX locks which conflict.
1175  * This function is called from rw_verify_area() and
1176  * locks_verify_truncate().
1177  */
1178 int locks_mandatory_area(int read_write, struct inode *inode,
1179                          struct file *filp, loff_t offset,
1180                          size_t count)
1181 {
1182         struct file_lock fl;
1183         int error;
1184
1185         locks_init_lock(&fl);
1186         fl.fl_owner = current->files;
1187         fl.fl_pid = current->tgid;
1188         fl.fl_file = filp;
1189         fl.fl_flags = FL_POSIX | FL_ACCESS;
1190         if (filp && !(filp->f_flags & O_NONBLOCK))
1191                 fl.fl_flags |= FL_SLEEP;
1192         fl.fl_type = (read_write == FLOCK_VERIFY_WRITE) ? F_WRLCK : F_RDLCK;
1193         fl.fl_start = offset;
1194         fl.fl_end = offset + count - 1;
1195
1196         for (;;) {
1197                 error = __posix_lock_file(inode, &fl, NULL);
1198                 if (error != FILE_LOCK_DEFERRED)
1199                         break;
1200                 error = wait_event_interruptible(fl.fl_wait, !fl.fl_next);
1201                 if (!error) {
1202                         /*
1203                          * If we've been sleeping someone might have
1204                          * changed the permissions behind our back.
1205                          */
1206                         if (__mandatory_lock(inode))
1207                                 continue;
1208                 }
1209
1210                 locks_delete_block(&fl);
1211                 break;
1212         }
1213
1214         return error;
1215 }
1216
1217 EXPORT_SYMBOL(locks_mandatory_area);
1218
1219 static void lease_clear_pending(struct file_lock *fl, int arg)
1220 {
1221         switch (arg) {
1222         case F_UNLCK:
1223                 fl->fl_flags &= ~FL_UNLOCK_PENDING;
1224                 /* fall through: */
1225         case F_RDLCK:
1226                 fl->fl_flags &= ~FL_DOWNGRADE_PENDING;
1227         }
1228 }
1229
1230 /* We already had a lease on this file; just change its type */
1231 int lease_modify(struct file_lock **before, int arg)
1232 {
1233         struct file_lock *fl = *before;
1234         int error = assign_type(fl, arg);
1235
1236         if (error)
1237                 return error;
1238         lease_clear_pending(fl, arg);
1239         locks_wake_up_blocks(fl);
1240         if (arg == F_UNLCK) {
1241                 struct file *filp = fl->fl_file;
1242
1243                 f_delown(filp);
1244                 filp->f_owner.signum = 0;
1245                 fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync);
1246                 if (fl->fl_fasync != NULL) {
1247                         printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync);
1248                         fl->fl_fasync = NULL;
1249                 }
1250                 locks_delete_lock(before);
1251         }
1252         return 0;
1253 }
1254
1255 EXPORT_SYMBOL(lease_modify);
1256
1257 static bool past_time(unsigned long then)
1258 {
1259         if (!then)
1260                 /* 0 is a special value meaning "this never expires": */
1261                 return false;
1262         return time_after(jiffies, then);
1263 }
1264
1265 static void time_out_leases(struct inode *inode)
1266 {
1267         struct file_lock **before;
1268         struct file_lock *fl;
1269
1270         before = &inode->i_flock;
1271         while ((fl = *before) && IS_LEASE(fl) && lease_breaking(fl)) {
1272                 if (past_time(fl->fl_downgrade_time))
1273                         lease_modify(before, F_RDLCK);
1274                 if (past_time(fl->fl_break_time))
1275                         lease_modify(before, F_UNLCK);
1276                 if (fl == *before)      /* lease_modify may have freed fl */
1277                         before = &fl->fl_next;
1278         }
1279 }
1280
1281 /**
1282  *      __break_lease   -       revoke all outstanding leases on file
1283  *      @inode: the inode of the file to return
1284  *      @mode: the open mode (read or write)
1285  *
1286  *      break_lease (inlined for speed) has checked there already is at least
1287  *      some kind of lock (maybe a lease) on this file.  Leases are broken on
1288  *      a call to open() or truncate().  This function can sleep unless you
1289  *      specified %O_NONBLOCK to your open().
1290  */
1291 int __break_lease(struct inode *inode, unsigned int mode)
1292 {
1293         int error = 0;
1294         struct file_lock *new_fl, *flock;
1295         struct file_lock *fl;
1296         unsigned long break_time;
1297         int i_have_this_lease = 0;
1298         int want_write = (mode & O_ACCMODE) != O_RDONLY;
1299
1300         new_fl = lease_alloc(NULL, want_write ? F_WRLCK : F_RDLCK);
1301         if (IS_ERR(new_fl))
1302                 return PTR_ERR(new_fl);
1303
1304         spin_lock(&inode->i_lock);
1305
1306         time_out_leases(inode);
1307
1308         flock = inode->i_flock;
1309         if ((flock == NULL) || !IS_LEASE(flock))
1310                 goto out;
1311
1312         if (!locks_conflict(flock, new_fl))
1313                 goto out;
1314
1315         for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next)
1316                 if (fl->fl_owner == current->files)
1317                         i_have_this_lease = 1;
1318
1319         break_time = 0;
1320         if (lease_break_time > 0) {
1321                 break_time = jiffies + lease_break_time * HZ;
1322                 if (break_time == 0)
1323                         break_time++;   /* so that 0 means no break time */
1324         }
1325
1326         for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) {
1327                 if (want_write) {
1328                         if (fl->fl_flags & FL_UNLOCK_PENDING)
1329                                 continue;
1330                         fl->fl_flags |= FL_UNLOCK_PENDING;
1331                         fl->fl_break_time = break_time;
1332                 } else {
1333                         if (lease_breaking(flock))
1334                                 continue;
1335                         fl->fl_flags |= FL_DOWNGRADE_PENDING;
1336                         fl->fl_downgrade_time = break_time;
1337                 }
1338                 fl->fl_lmops->lm_break(fl);
1339         }
1340
1341         if (i_have_this_lease || (mode & O_NONBLOCK)) {
1342                 error = -EWOULDBLOCK;
1343                 goto out;
1344         }
1345
1346 restart:
1347         break_time = flock->fl_break_time;
1348         if (break_time != 0) {
1349                 break_time -= jiffies;
1350                 if (break_time == 0)
1351                         break_time++;
1352         }
1353         locks_insert_block(flock, new_fl);
1354         spin_unlock(&inode->i_lock);
1355         error = wait_event_interruptible_timeout(new_fl->fl_wait,
1356                                                 !new_fl->fl_next, break_time);
1357         spin_lock(&inode->i_lock);
1358         locks_delete_block(new_fl);
1359         if (error >= 0) {
1360                 if (error == 0)
1361                         time_out_leases(inode);
1362                 /*
1363                  * Wait for the next conflicting lease that has not been
1364                  * broken yet
1365                  */
1366                 for (flock = inode->i_flock; flock && IS_LEASE(flock);
1367                                 flock = flock->fl_next) {
1368                         if (locks_conflict(new_fl, flock))
1369                                 goto restart;
1370                 }
1371                 error = 0;
1372         }
1373
1374 out:
1375         spin_unlock(&inode->i_lock);
1376         locks_free_lock(new_fl);
1377         return error;
1378 }
1379
1380 EXPORT_SYMBOL(__break_lease);
1381
1382 /**
1383  *      lease_get_mtime - get the last modified time of an inode
1384  *      @inode: the inode
1385  *      @time:  pointer to a timespec which will contain the last modified time
1386  *
1387  * This is to force NFS clients to flush their caches for files with
1388  * exclusive leases.  The justification is that if someone has an
1389  * exclusive lease, then they could be modifying it.
1390  */
1391 void lease_get_mtime(struct inode *inode, struct timespec *time)
1392 {
1393         struct file_lock *flock = inode->i_flock;
1394         if (flock && IS_LEASE(flock) && (flock->fl_type == F_WRLCK))
1395                 *time = current_fs_time(inode->i_sb);
1396         else
1397                 *time = inode->i_mtime;
1398 }
1399
1400 EXPORT_SYMBOL(lease_get_mtime);
1401
1402 /**
1403  *      fcntl_getlease - Enquire what lease is currently active
1404  *      @filp: the file
1405  *
1406  *      The value returned by this function will be one of
1407  *      (if no lease break is pending):
1408  *
1409  *      %F_RDLCK to indicate a shared lease is held.
1410  *
1411  *      %F_WRLCK to indicate an exclusive lease is held.
1412  *
1413  *      %F_UNLCK to indicate no lease is held.
1414  *
1415  *      (if a lease break is pending):
1416  *
1417  *      %F_RDLCK to indicate an exclusive lease needs to be
1418  *              changed to a shared lease (or removed).
1419  *
1420  *      %F_UNLCK to indicate the lease needs to be removed.
1421  *
1422  *      XXX: sfr & willy disagree over whether F_INPROGRESS
1423  *      should be returned to userspace.
1424  */
1425 int fcntl_getlease(struct file *filp)
1426 {
1427         struct file_lock *fl;
1428         struct inode *inode = file_inode(filp);
1429         int type = F_UNLCK;
1430
1431         spin_lock(&inode->i_lock);
1432         time_out_leases(file_inode(filp));
1433         for (fl = file_inode(filp)->i_flock; fl && IS_LEASE(fl);
1434                         fl = fl->fl_next) {
1435                 if (fl->fl_file == filp) {
1436                         type = target_leasetype(fl);
1437                         break;
1438                 }
1439         }
1440         spin_unlock(&inode->i_lock);
1441         return type;
1442 }
1443
1444 static int generic_add_lease(struct file *filp, long arg, struct file_lock **flp)
1445 {
1446         struct file_lock *fl, **before, **my_before = NULL, *lease;
1447         struct dentry *dentry = filp->f_path.dentry;
1448         struct inode *inode = dentry->d_inode;
1449         int error;
1450
1451         lease = *flp;
1452
1453         error = -EAGAIN;
1454         if ((arg == F_RDLCK) && (atomic_read(&inode->i_writecount) > 0))
1455                 goto out;
1456         if ((arg == F_WRLCK)
1457             && ((dentry->d_count > 1)
1458                 || (atomic_read(&inode->i_count) > 1)))
1459                 goto out;
1460
1461         /*
1462          * At this point, we know that if there is an exclusive
1463          * lease on this file, then we hold it on this filp
1464          * (otherwise our open of this file would have blocked).
1465          * And if we are trying to acquire an exclusive lease,
1466          * then the file is not open by anyone (including us)
1467          * except for this filp.
1468          */
1469         error = -EAGAIN;
1470         for (before = &inode->i_flock;
1471                         ((fl = *before) != NULL) && IS_LEASE(fl);
1472                         before = &fl->fl_next) {
1473                 if (fl->fl_file == filp) {
1474                         my_before = before;
1475                         continue;
1476                 }
1477                 /*
1478                  * No exclusive leases if someone else has a lease on
1479                  * this file:
1480                  */
1481                 if (arg == F_WRLCK)
1482                         goto out;
1483                 /*
1484                  * Modifying our existing lease is OK, but no getting a
1485                  * new lease if someone else is opening for write:
1486                  */
1487                 if (fl->fl_flags & FL_UNLOCK_PENDING)
1488                         goto out;
1489         }
1490
1491         if (my_before != NULL) {
1492                 error = lease->fl_lmops->lm_change(my_before, arg);
1493                 if (!error)
1494                         *flp = *my_before;
1495                 goto out;
1496         }
1497
1498         error = -EINVAL;
1499         if (!leases_enable)
1500                 goto out;
1501
1502         locks_insert_lock(before, lease);
1503         return 0;
1504
1505 out:
1506         return error;
1507 }
1508
1509 static int generic_delete_lease(struct file *filp, struct file_lock **flp)
1510 {
1511         struct file_lock *fl, **before;
1512         struct dentry *dentry = filp->f_path.dentry;
1513         struct inode *inode = dentry->d_inode;
1514
1515         for (before = &inode->i_flock;
1516                         ((fl = *before) != NULL) && IS_LEASE(fl);
1517                         before = &fl->fl_next) {
1518                 if (fl->fl_file != filp)
1519                         continue;
1520                 return (*flp)->fl_lmops->lm_change(before, F_UNLCK);
1521         }
1522         return -EAGAIN;
1523 }
1524
1525 /**
1526  *      generic_setlease        -       sets a lease on an open file
1527  *      @filp: file pointer
1528  *      @arg: type of lease to obtain
1529  *      @flp: input - file_lock to use, output - file_lock inserted
1530  *
1531  *      The (input) flp->fl_lmops->lm_break function is required
1532  *      by break_lease().
1533  *
1534  *      Called with inode->i_lock held.
1535  */
1536 int generic_setlease(struct file *filp, long arg, struct file_lock **flp)
1537 {
1538         struct dentry *dentry = filp->f_path.dentry;
1539         struct inode *inode = dentry->d_inode;
1540         int error;
1541
1542         if ((!uid_eq(current_fsuid(), inode->i_uid)) && !capable(CAP_LEASE))
1543                 return -EACCES;
1544         if (!S_ISREG(inode->i_mode))
1545                 return -EINVAL;
1546         error = security_file_lock(filp, arg);
1547         if (error)
1548                 return error;
1549
1550         time_out_leases(inode);
1551
1552         BUG_ON(!(*flp)->fl_lmops->lm_break);
1553
1554         switch (arg) {
1555         case F_UNLCK:
1556                 return generic_delete_lease(filp, flp);
1557         case F_RDLCK:
1558         case F_WRLCK:
1559                 return generic_add_lease(filp, arg, flp);
1560         default:
1561                 return -EINVAL;
1562         }
1563 }
1564 EXPORT_SYMBOL(generic_setlease);
1565
1566 static int __vfs_setlease(struct file *filp, long arg, struct file_lock **lease)
1567 {
1568         if (filp->f_op && filp->f_op->setlease)
1569                 return filp->f_op->setlease(filp, arg, lease);
1570         else
1571                 return generic_setlease(filp, arg, lease);
1572 }
1573
1574 /**
1575  *      vfs_setlease        -       sets a lease on an open file
1576  *      @filp: file pointer
1577  *      @arg: type of lease to obtain
1578  *      @lease: file_lock to use
1579  *
1580  *      Call this to establish a lease on the file.
1581  *      The (*lease)->fl_lmops->lm_break operation must be set; if not,
1582  *      break_lease will oops!
1583  *
1584  *      This will call the filesystem's setlease file method, if
1585  *      defined.  Note that there is no getlease method; instead, the
1586  *      filesystem setlease method should call back to setlease() to
1587  *      add a lease to the inode's lease list, where fcntl_getlease() can
1588  *      find it.  Since fcntl_getlease() only reports whether the current
1589  *      task holds a lease, a cluster filesystem need only do this for
1590  *      leases held by processes on this node.
1591  *
1592  *      There is also no break_lease method; filesystems that
1593  *      handle their own leases should break leases themselves from the
1594  *      filesystem's open, create, and (on truncate) setattr methods.
1595  *
1596  *      Warning: the only current setlease methods exist only to disable
1597  *      leases in certain cases.  More vfs changes may be required to
1598  *      allow a full filesystem lease implementation.
1599  */
1600
1601 int vfs_setlease(struct file *filp, long arg, struct file_lock **lease)
1602 {
1603         struct inode *inode = file_inode(filp);
1604         int error;
1605
1606         spin_lock(&inode->i_lock);
1607         error = __vfs_setlease(filp, arg, lease);
1608         spin_unlock(&inode->i_lock);
1609
1610         return error;
1611 }
1612 EXPORT_SYMBOL_GPL(vfs_setlease);
1613
1614 static int do_fcntl_delete_lease(struct file *filp)
1615 {
1616         struct file_lock fl, *flp = &fl;
1617
1618         lease_init(filp, F_UNLCK, flp);
1619
1620         return vfs_setlease(filp, F_UNLCK, &flp);
1621 }
1622
1623 static int do_fcntl_add_lease(unsigned int fd, struct file *filp, long arg)
1624 {
1625         struct file_lock *fl, *ret;
1626         struct inode *inode = file_inode(filp);
1627         struct fasync_struct *new;
1628         int error;
1629
1630         fl = lease_alloc(filp, arg);
1631         if (IS_ERR(fl))
1632                 return PTR_ERR(fl);
1633
1634         new = fasync_alloc();
1635         if (!new) {
1636                 locks_free_lock(fl);
1637                 return -ENOMEM;
1638         }
1639         ret = fl;
1640         spin_lock(&inode->i_lock);
1641         error = __vfs_setlease(filp, arg, &ret);
1642         if (error) {
1643                 spin_unlock(&inode->i_lock);
1644                 locks_free_lock(fl);
1645                 goto out_free_fasync;
1646         }
1647         if (ret != fl)
1648                 locks_free_lock(fl);
1649
1650         /*
1651          * fasync_insert_entry() returns the old entry if any.
1652          * If there was no old entry, then it used 'new' and
1653          * inserted it into the fasync list. Clear new so that
1654          * we don't release it here.
1655          */
1656         if (!fasync_insert_entry(fd, filp, &ret->fl_fasync, new))
1657                 new = NULL;
1658
1659         error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0);
1660         spin_unlock(&inode->i_lock);
1661
1662 out_free_fasync:
1663         if (new)
1664                 fasync_free(new);
1665         return error;
1666 }
1667
1668 /**
1669  *      fcntl_setlease  -       sets a lease on an open file
1670  *      @fd: open file descriptor
1671  *      @filp: file pointer
1672  *      @arg: type of lease to obtain
1673  *
1674  *      Call this fcntl to establish a lease on the file.
1675  *      Note that you also need to call %F_SETSIG to
1676  *      receive a signal when the lease is broken.
1677  */
1678 int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
1679 {
1680         if (arg == F_UNLCK)
1681                 return do_fcntl_delete_lease(filp);
1682         return do_fcntl_add_lease(fd, filp, arg);
1683 }
1684
1685 /**
1686  * flock_lock_file_wait - Apply a FLOCK-style lock to a file
1687  * @filp: The file to apply the lock to
1688  * @fl: The lock to be applied
1689  *
1690  * Add a FLOCK style lock to a file.
1691  */
1692 int flock_lock_file_wait(struct file *filp, struct file_lock *fl)
1693 {
1694         int error;
1695         might_sleep();
1696         for (;;) {
1697                 error = flock_lock_file(filp, fl);
1698                 if (error != FILE_LOCK_DEFERRED)
1699                         break;
1700                 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
1701                 if (!error)
1702                         continue;
1703
1704                 locks_delete_block(fl);
1705                 break;
1706         }
1707         return error;
1708 }
1709
1710 EXPORT_SYMBOL(flock_lock_file_wait);
1711
1712 /**
1713  *      sys_flock: - flock() system call.
1714  *      @fd: the file descriptor to lock.
1715  *      @cmd: the type of lock to apply.
1716  *
1717  *      Apply a %FL_FLOCK style lock to an open file descriptor.
1718  *      The @cmd can be one of
1719  *
1720  *      %LOCK_SH -- a shared lock.
1721  *
1722  *      %LOCK_EX -- an exclusive lock.
1723  *
1724  *      %LOCK_UN -- remove an existing lock.
1725  *
1726  *      %LOCK_MAND -- a `mandatory' flock.  This exists to emulate Windows Share Modes.
1727  *
1728  *      %LOCK_MAND can be combined with %LOCK_READ or %LOCK_WRITE to allow other
1729  *      processes read and write access respectively.
1730  */
1731 SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd)
1732 {
1733         struct fd f = fdget(fd);
1734         struct file_lock *lock;
1735         int can_sleep, unlock;
1736         int error;
1737
1738         error = -EBADF;
1739         if (!f.file)
1740                 goto out;
1741
1742         can_sleep = !(cmd & LOCK_NB);
1743         cmd &= ~LOCK_NB;
1744         unlock = (cmd == LOCK_UN);
1745
1746         if (!unlock && !(cmd & LOCK_MAND) &&
1747             !(f.file->f_mode & (FMODE_READ|FMODE_WRITE)))
1748                 goto out_putf;
1749
1750         error = flock_make_lock(f.file, &lock, cmd);
1751         if (error)
1752                 goto out_putf;
1753         if (can_sleep)
1754                 lock->fl_flags |= FL_SLEEP;
1755
1756         error = security_file_lock(f.file, lock->fl_type);
1757         if (error)
1758                 goto out_free;
1759
1760         if (f.file->f_op && f.file->f_op->flock)
1761                 error = f.file->f_op->flock(f.file,
1762                                           (can_sleep) ? F_SETLKW : F_SETLK,
1763                                           lock);
1764         else
1765                 error = flock_lock_file_wait(f.file, lock);
1766
1767  out_free:
1768         locks_free_lock(lock);
1769
1770  out_putf:
1771         fdput(f);
1772  out:
1773         return error;
1774 }
1775
1776 /**
1777  * vfs_test_lock - test file byte range lock
1778  * @filp: The file to test lock for
1779  * @fl: The lock to test; also used to hold result
1780  *
1781  * Returns -ERRNO on failure.  Indicates presence of conflicting lock by
1782  * setting conf->fl_type to something other than F_UNLCK.
1783  */
1784 int vfs_test_lock(struct file *filp, struct file_lock *fl)
1785 {
1786         if (filp->f_op && filp->f_op->lock)
1787                 return filp->f_op->lock(filp, F_GETLK, fl);
1788         posix_test_lock(filp, fl);
1789         return 0;
1790 }
1791 EXPORT_SYMBOL_GPL(vfs_test_lock);
1792
1793 static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl)
1794 {
1795         flock->l_pid = fl->fl_pid;
1796 #if BITS_PER_LONG == 32
1797         /*
1798          * Make sure we can represent the posix lock via
1799          * legacy 32bit flock.
1800          */
1801         if (fl->fl_start > OFFT_OFFSET_MAX)
1802                 return -EOVERFLOW;
1803         if (fl->fl_end != OFFSET_MAX && fl->fl_end > OFFT_OFFSET_MAX)
1804                 return -EOVERFLOW;
1805 #endif
1806         flock->l_start = fl->fl_start;
1807         flock->l_len = fl->fl_end == OFFSET_MAX ? 0 :
1808                 fl->fl_end - fl->fl_start + 1;
1809         flock->l_whence = 0;
1810         flock->l_type = fl->fl_type;
1811         return 0;
1812 }
1813
1814 #if BITS_PER_LONG == 32
1815 static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl)
1816 {
1817         flock->l_pid = fl->fl_pid;
1818         flock->l_start = fl->fl_start;
1819         flock->l_len = fl->fl_end == OFFSET_MAX ? 0 :
1820                 fl->fl_end - fl->fl_start + 1;
1821         flock->l_whence = 0;
1822         flock->l_type = fl->fl_type;
1823 }
1824 #endif
1825
1826 /* Report the first existing lock that would conflict with l.
1827  * This implements the F_GETLK command of fcntl().
1828  */
1829 int fcntl_getlk(struct file *filp, struct flock __user *l)
1830 {
1831         struct file_lock file_lock;
1832         struct flock flock;
1833         int error;
1834
1835         error = -EFAULT;
1836         if (copy_from_user(&flock, l, sizeof(flock)))
1837                 goto out;
1838         error = -EINVAL;
1839         if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK))
1840                 goto out;
1841
1842         error = flock_to_posix_lock(filp, &file_lock, &flock);
1843         if (error)
1844                 goto out;
1845
1846         error = vfs_test_lock(filp, &file_lock);
1847         if (error)
1848                 goto out;
1849  
1850         flock.l_type = file_lock.fl_type;
1851         if (file_lock.fl_type != F_UNLCK) {
1852                 error = posix_lock_to_flock(&flock, &file_lock);
1853                 if (error)
1854                         goto out;
1855         }
1856         error = -EFAULT;
1857         if (!copy_to_user(l, &flock, sizeof(flock)))
1858                 error = 0;
1859 out:
1860         return error;
1861 }
1862
1863 /**
1864  * vfs_lock_file - file byte range lock
1865  * @filp: The file to apply the lock to
1866  * @cmd: type of locking operation (F_SETLK, F_GETLK, etc.)
1867  * @fl: The lock to be applied
1868  * @conf: Place to return a copy of the conflicting lock, if found.
1869  *
1870  * A caller that doesn't care about the conflicting lock may pass NULL
1871  * as the final argument.
1872  *
1873  * If the filesystem defines a private ->lock() method, then @conf will
1874  * be left unchanged; so a caller that cares should initialize it to
1875  * some acceptable default.
1876  *
1877  * To avoid blocking kernel daemons, such as lockd, that need to acquire POSIX
1878  * locks, the ->lock() interface may return asynchronously, before the lock has
1879  * been granted or denied by the underlying filesystem, if (and only if)
1880  * lm_grant is set. Callers expecting ->lock() to return asynchronously
1881  * will only use F_SETLK, not F_SETLKW; they will set FL_SLEEP if (and only if)
1882  * the request is for a blocking lock. When ->lock() does return asynchronously,
1883  * it must return FILE_LOCK_DEFERRED, and call ->lm_grant() when the lock
1884  * request completes.
1885  * If the request is for non-blocking lock the file system should return
1886  * FILE_LOCK_DEFERRED then try to get the lock and call the callback routine
1887  * with the result. If the request timed out the callback routine will return a
1888  * nonzero return code and the file system should release the lock. The file
1889  * system is also responsible to keep a corresponding posix lock when it
1890  * grants a lock so the VFS can find out which locks are locally held and do
1891  * the correct lock cleanup when required.
1892  * The underlying filesystem must not drop the kernel lock or call
1893  * ->lm_grant() before returning to the caller with a FILE_LOCK_DEFERRED
1894  * return code.
1895  */
1896 int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf)
1897 {
1898         if (filp->f_op && filp->f_op->lock)
1899                 return filp->f_op->lock(filp, cmd, fl);
1900         else
1901                 return posix_lock_file(filp, fl, conf);
1902 }
1903 EXPORT_SYMBOL_GPL(vfs_lock_file);
1904
1905 static int do_lock_file_wait(struct file *filp, unsigned int cmd,
1906                              struct file_lock *fl)
1907 {
1908         int error;
1909
1910         error = security_file_lock(filp, fl->fl_type);
1911         if (error)
1912                 return error;
1913
1914         for (;;) {
1915                 error = vfs_lock_file(filp, cmd, fl, NULL);
1916                 if (error != FILE_LOCK_DEFERRED)
1917                         break;
1918                 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
1919                 if (!error)
1920                         continue;
1921
1922                 locks_delete_block(fl);
1923                 break;
1924         }
1925
1926         return error;
1927 }
1928
1929 /* Apply the lock described by l to an open file descriptor.
1930  * This implements both the F_SETLK and F_SETLKW commands of fcntl().
1931  */
1932 int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd,
1933                 struct flock __user *l)
1934 {
1935         struct file_lock *file_lock = locks_alloc_lock();
1936         struct flock flock;
1937         struct inode *inode;
1938         struct file *f;
1939         int error;
1940
1941         if (file_lock == NULL)
1942                 return -ENOLCK;
1943
1944         /*
1945          * This might block, so we do it before checking the inode.
1946          */
1947         error = -EFAULT;
1948         if (copy_from_user(&flock, l, sizeof(flock)))
1949                 goto out;
1950
1951         inode = file_inode(filp);
1952
1953         /* Don't allow mandatory locks on files that may be memory mapped
1954          * and shared.
1955          */
1956         if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) {
1957                 error = -EAGAIN;
1958                 goto out;
1959         }
1960
1961 again:
1962         error = flock_to_posix_lock(filp, file_lock, &flock);
1963         if (error)
1964                 goto out;
1965         if (cmd == F_SETLKW) {
1966                 file_lock->fl_flags |= FL_SLEEP;
1967         }
1968         
1969         error = -EBADF;
1970         switch (flock.l_type) {
1971         case F_RDLCK:
1972                 if (!(filp->f_mode & FMODE_READ))
1973                         goto out;
1974                 break;
1975         case F_WRLCK:
1976                 if (!(filp->f_mode & FMODE_WRITE))
1977                         goto out;
1978                 break;
1979         case F_UNLCK:
1980                 break;
1981         default:
1982                 error = -EINVAL;
1983                 goto out;
1984         }
1985
1986         error = do_lock_file_wait(filp, cmd, file_lock);
1987
1988         /*
1989          * Attempt to detect a close/fcntl race and recover by
1990          * releasing the lock that was just acquired.
1991          */
1992         /*
1993          * we need that spin_lock here - it prevents reordering between
1994          * update of inode->i_flock and check for it done in close().
1995          * rcu_read_lock() wouldn't do.
1996          */
1997         spin_lock(&current->files->file_lock);
1998         f = fcheck(fd);
1999         spin_unlock(&current->files->file_lock);
2000         if (!error && f != filp && flock.l_type != F_UNLCK) {
2001                 flock.l_type = F_UNLCK;
2002                 goto again;
2003         }
2004
2005 out:
2006         locks_free_lock(file_lock);
2007         return error;
2008 }
2009
2010 #if BITS_PER_LONG == 32
2011 /* Report the first existing lock that would conflict with l.
2012  * This implements the F_GETLK command of fcntl().
2013  */
2014 int fcntl_getlk64(struct file *filp, struct flock64 __user *l)
2015 {
2016         struct file_lock file_lock;
2017         struct flock64 flock;
2018         int error;
2019
2020         error = -EFAULT;
2021         if (copy_from_user(&flock, l, sizeof(flock)))
2022                 goto out;
2023         error = -EINVAL;
2024         if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK))
2025                 goto out;
2026
2027         error = flock64_to_posix_lock(filp, &file_lock, &flock);
2028         if (error)
2029                 goto out;
2030
2031         error = vfs_test_lock(filp, &file_lock);
2032         if (error)
2033                 goto out;
2034
2035         flock.l_type = file_lock.fl_type;
2036         if (file_lock.fl_type != F_UNLCK)
2037                 posix_lock_to_flock64(&flock, &file_lock);
2038
2039         error = -EFAULT;
2040         if (!copy_to_user(l, &flock, sizeof(flock)))
2041                 error = 0;
2042   
2043 out:
2044         return error;
2045 }
2046
2047 /* Apply the lock described by l to an open file descriptor.
2048  * This implements both the F_SETLK and F_SETLKW commands of fcntl().
2049  */
2050 int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd,
2051                 struct flock64 __user *l)
2052 {
2053         struct file_lock *file_lock = locks_alloc_lock();
2054         struct flock64 flock;
2055         struct inode *inode;
2056         struct file *f;
2057         int error;
2058
2059         if (file_lock == NULL)
2060                 return -ENOLCK;
2061
2062         /*
2063          * This might block, so we do it before checking the inode.
2064          */
2065         error = -EFAULT;
2066         if (copy_from_user(&flock, l, sizeof(flock)))
2067                 goto out;
2068
2069         inode = file_inode(filp);
2070
2071         /* Don't allow mandatory locks on files that may be memory mapped
2072          * and shared.
2073          */
2074         if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) {
2075                 error = -EAGAIN;
2076                 goto out;
2077         }
2078
2079 again:
2080         error = flock64_to_posix_lock(filp, file_lock, &flock);
2081         if (error)
2082                 goto out;
2083         if (cmd == F_SETLKW64) {
2084                 file_lock->fl_flags |= FL_SLEEP;
2085         }
2086         
2087         error = -EBADF;
2088         switch (flock.l_type) {
2089         case F_RDLCK:
2090                 if (!(filp->f_mode & FMODE_READ))
2091                         goto out;
2092                 break;
2093         case F_WRLCK:
2094                 if (!(filp->f_mode & FMODE_WRITE))
2095                         goto out;
2096                 break;
2097         case F_UNLCK:
2098                 break;
2099         default:
2100                 error = -EINVAL;
2101                 goto out;
2102         }
2103
2104         error = do_lock_file_wait(filp, cmd, file_lock);
2105
2106         /*
2107          * Attempt to detect a close/fcntl race and recover by
2108          * releasing the lock that was just acquired.
2109          */
2110         spin_lock(&current->files->file_lock);
2111         f = fcheck(fd);
2112         spin_unlock(&current->files->file_lock);
2113         if (!error && f != filp && flock.l_type != F_UNLCK) {
2114                 flock.l_type = F_UNLCK;
2115                 goto again;
2116         }
2117
2118 out:
2119         locks_free_lock(file_lock);
2120         return error;
2121 }
2122 #endif /* BITS_PER_LONG == 32 */
2123
2124 /*
2125  * This function is called when the file is being removed
2126  * from the task's fd array.  POSIX locks belonging to this task
2127  * are deleted at this time.
2128  */
2129 void locks_remove_posix(struct file *filp, fl_owner_t owner)
2130 {
2131         struct file_lock lock;
2132
2133         /*
2134          * If there are no locks held on this file, we don't need to call
2135          * posix_lock_file().  Another process could be setting a lock on this
2136          * file at the same time, but we wouldn't remove that lock anyway.
2137          */
2138         if (!file_inode(filp)->i_flock)
2139                 return;
2140
2141         lock.fl_type = F_UNLCK;
2142         lock.fl_flags = FL_POSIX | FL_CLOSE;
2143         lock.fl_start = 0;
2144         lock.fl_end = OFFSET_MAX;
2145         lock.fl_owner = owner;
2146         lock.fl_pid = current->tgid;
2147         lock.fl_file = filp;
2148         lock.fl_ops = NULL;
2149         lock.fl_lmops = NULL;
2150
2151         vfs_lock_file(filp, F_SETLK, &lock, NULL);
2152
2153         if (lock.fl_ops && lock.fl_ops->fl_release_private)
2154                 lock.fl_ops->fl_release_private(&lock);
2155 }
2156
2157 EXPORT_SYMBOL(locks_remove_posix);
2158
2159 /*
2160  * This function is called on the last close of an open file.
2161  */
2162 void locks_remove_flock(struct file *filp)
2163 {
2164         struct inode * inode = file_inode(filp);
2165         struct file_lock *fl;
2166         struct file_lock **before;
2167
2168         if (!inode->i_flock)
2169                 return;
2170
2171         if (filp->f_op && filp->f_op->flock) {
2172                 struct file_lock fl = {
2173                         .fl_pid = current->tgid,
2174                         .fl_file = filp,
2175                         .fl_flags = FL_FLOCK,
2176                         .fl_type = F_UNLCK,
2177                         .fl_end = OFFSET_MAX,
2178                 };
2179                 filp->f_op->flock(filp, F_SETLKW, &fl);
2180                 if (fl.fl_ops && fl.fl_ops->fl_release_private)
2181                         fl.fl_ops->fl_release_private(&fl);
2182         }
2183
2184         spin_lock(&inode->i_lock);
2185         before = &inode->i_flock;
2186
2187         while ((fl = *before) != NULL) {
2188                 if (fl->fl_file == filp) {
2189                         if (IS_FLOCK(fl)) {
2190                                 locks_delete_lock(before);
2191                                 continue;
2192                         }
2193                         if (IS_LEASE(fl)) {
2194                                 lease_modify(before, F_UNLCK);
2195                                 continue;
2196                         }
2197                         /* What? */
2198                         BUG();
2199                 }
2200                 before = &fl->fl_next;
2201         }
2202         spin_unlock(&inode->i_lock);
2203 }
2204
2205 /**
2206  *      posix_unblock_lock - stop waiting for a file lock
2207  *      @waiter: the lock which was waiting
2208  *
2209  *      lockd needs to block waiting for locks.
2210  */
2211 int
2212 posix_unblock_lock(struct file_lock *waiter)
2213 {
2214         int status = 0;
2215
2216         spin_lock(&blocked_lock_lock);
2217         if (waiter->fl_next)
2218                 __locks_delete_block(waiter);
2219         else
2220                 status = -ENOENT;
2221         spin_unlock(&blocked_lock_lock);
2222         return status;
2223 }
2224 EXPORT_SYMBOL(posix_unblock_lock);
2225
2226 /**
2227  * vfs_cancel_lock - file byte range unblock lock
2228  * @filp: The file to apply the unblock to
2229  * @fl: The lock to be unblocked
2230  *
2231  * Used by lock managers to cancel blocked requests
2232  */
2233 int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
2234 {
2235         if (filp->f_op && filp->f_op->lock)
2236                 return filp->f_op->lock(filp, F_CANCELLK, fl);
2237         return 0;
2238 }
2239
2240 EXPORT_SYMBOL_GPL(vfs_cancel_lock);
2241
2242 #ifdef CONFIG_PROC_FS
2243 #include <linux/proc_fs.h>
2244 #include <linux/seq_file.h>
2245
2246 static void lock_get_status(struct seq_file *f, struct file_lock *fl,
2247                             loff_t id, char *pfx)
2248 {
2249         struct inode *inode = NULL;
2250         unsigned int fl_pid;
2251
2252         if (fl->fl_nspid)
2253                 fl_pid = pid_vnr(fl->fl_nspid);
2254         else
2255                 fl_pid = fl->fl_pid;
2256
2257         if (fl->fl_file != NULL)
2258                 inode = file_inode(fl->fl_file);
2259
2260         seq_printf(f, "%lld:%s ", id, pfx);
2261         if (IS_POSIX(fl)) {
2262                 seq_printf(f, "%6s %s ",
2263                              (fl->fl_flags & FL_ACCESS) ? "ACCESS" : "POSIX ",
2264                              (inode == NULL) ? "*NOINODE*" :
2265                              mandatory_lock(inode) ? "MANDATORY" : "ADVISORY ");
2266         } else if (IS_FLOCK(fl)) {
2267                 if (fl->fl_type & LOCK_MAND) {
2268                         seq_printf(f, "FLOCK  MSNFS     ");
2269                 } else {
2270                         seq_printf(f, "FLOCK  ADVISORY  ");
2271                 }
2272         } else if (IS_LEASE(fl)) {
2273                 seq_printf(f, "LEASE  ");
2274                 if (lease_breaking(fl))
2275                         seq_printf(f, "BREAKING  ");
2276                 else if (fl->fl_file)
2277                         seq_printf(f, "ACTIVE    ");
2278                 else
2279                         seq_printf(f, "BREAKER   ");
2280         } else {
2281                 seq_printf(f, "UNKNOWN UNKNOWN  ");
2282         }
2283         if (fl->fl_type & LOCK_MAND) {
2284                 seq_printf(f, "%s ",
2285                                (fl->fl_type & LOCK_READ)
2286                                ? (fl->fl_type & LOCK_WRITE) ? "RW   " : "READ "
2287                                : (fl->fl_type & LOCK_WRITE) ? "WRITE" : "NONE ");
2288         } else {
2289                 seq_printf(f, "%s ",
2290                                (lease_breaking(fl))
2291                                ? (fl->fl_type == F_UNLCK) ? "UNLCK" : "READ "
2292                                : (fl->fl_type == F_WRLCK) ? "WRITE" : "READ ");
2293         }
2294         if (inode) {
2295 #ifdef WE_CAN_BREAK_LSLK_NOW
2296                 seq_printf(f, "%d %s:%ld ", fl_pid,
2297                                 inode->i_sb->s_id, inode->i_ino);
2298 #else
2299                 /* userspace relies on this representation of dev_t ;-( */
2300                 seq_printf(f, "%d %02x:%02x:%ld ", fl_pid,
2301                                 MAJOR(inode->i_sb->s_dev),
2302                                 MINOR(inode->i_sb->s_dev), inode->i_ino);
2303 #endif
2304         } else {
2305                 seq_printf(f, "%d <none>:0 ", fl_pid);
2306         }
2307         if (IS_POSIX(fl)) {
2308                 if (fl->fl_end == OFFSET_MAX)
2309                         seq_printf(f, "%Ld EOF\n", fl->fl_start);
2310                 else
2311                         seq_printf(f, "%Ld %Ld\n", fl->fl_start, fl->fl_end);
2312         } else {
2313                 seq_printf(f, "0 EOF\n");
2314         }
2315 }
2316
2317 static int locks_show(struct seq_file *f, void *v)
2318 {
2319         struct file_lock *fl, *bfl;
2320
2321         fl = hlist_entry(v, struct file_lock, fl_link);
2322
2323         lock_get_status(f, fl, *((loff_t *)f->private), "");
2324
2325         list_for_each_entry(bfl, &fl->fl_block, fl_block)
2326                 lock_get_status(f, bfl, *((loff_t *)f->private), " ->");
2327
2328         return 0;
2329 }
2330
2331 static void *locks_start(struct seq_file *f, loff_t *pos)
2332 {
2333         loff_t *p = f->private;
2334
2335         spin_lock(&file_lock_lock);
2336         spin_lock(&blocked_lock_lock);
2337         *p = (*pos + 1);
2338         return seq_hlist_start(&file_lock_list, *pos);
2339 }
2340
2341 static void *locks_next(struct seq_file *f, void *v, loff_t *pos)
2342 {
2343         loff_t *p = f->private;
2344         ++*p;
2345         return seq_hlist_next(v, &file_lock_list, pos);
2346 }
2347
2348 static void locks_stop(struct seq_file *f, void *v)
2349 {
2350         spin_unlock(&blocked_lock_lock);
2351         spin_unlock(&file_lock_lock);
2352 }
2353
2354 static const struct seq_operations locks_seq_operations = {
2355         .start  = locks_start,
2356         .next   = locks_next,
2357         .stop   = locks_stop,
2358         .show   = locks_show,
2359 };
2360
2361 static int locks_open(struct inode *inode, struct file *filp)
2362 {
2363         return seq_open_private(filp, &locks_seq_operations, sizeof(loff_t));
2364 }
2365
2366 static const struct file_operations proc_locks_operations = {
2367         .open           = locks_open,
2368         .read           = seq_read,
2369         .llseek         = seq_lseek,
2370         .release        = seq_release_private,
2371 };
2372
2373 static int __init proc_locks_init(void)
2374 {
2375         proc_create("locks", 0, NULL, &proc_locks_operations);
2376         return 0;
2377 }
2378 module_init(proc_locks_init);
2379 #endif
2380
2381 /**
2382  *      lock_may_read - checks that the region is free of locks
2383  *      @inode: the inode that is being read
2384  *      @start: the first byte to read
2385  *      @len: the number of bytes to read
2386  *
2387  *      Emulates Windows locking requirements.  Whole-file
2388  *      mandatory locks (share modes) can prohibit a read and
2389  *      byte-range POSIX locks can prohibit a read if they overlap.
2390  *
2391  *      N.B. this function is only ever called
2392  *      from knfsd and ownership of locks is never checked.
2393  */
2394 int lock_may_read(struct inode *inode, loff_t start, unsigned long len)
2395 {
2396         struct file_lock *fl;
2397         int result = 1;
2398
2399         spin_lock(&inode->i_lock);
2400         for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
2401                 if (IS_POSIX(fl)) {
2402                         if (fl->fl_type == F_RDLCK)
2403                                 continue;
2404                         if ((fl->fl_end < start) || (fl->fl_start > (start + len)))
2405                                 continue;
2406                 } else if (IS_FLOCK(fl)) {
2407                         if (!(fl->fl_type & LOCK_MAND))
2408                                 continue;
2409                         if (fl->fl_type & LOCK_READ)
2410                                 continue;
2411                 } else
2412                         continue;
2413                 result = 0;
2414                 break;
2415         }
2416         spin_unlock(&inode->i_lock);
2417         return result;
2418 }
2419
2420 EXPORT_SYMBOL(lock_may_read);
2421
2422 /**
2423  *      lock_may_write - checks that the region is free of locks
2424  *      @inode: the inode that is being written
2425  *      @start: the first byte to write
2426  *      @len: the number of bytes to write
2427  *
2428  *      Emulates Windows locking requirements.  Whole-file
2429  *      mandatory locks (share modes) can prohibit a write and
2430  *      byte-range POSIX locks can prohibit a write if they overlap.
2431  *
2432  *      N.B. this function is only ever called
2433  *      from knfsd and ownership of locks is never checked.
2434  */
2435 int lock_may_write(struct inode *inode, loff_t start, unsigned long len)
2436 {
2437         struct file_lock *fl;
2438         int result = 1;
2439
2440         spin_lock(&inode->i_lock);
2441         for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
2442                 if (IS_POSIX(fl)) {
2443                         if ((fl->fl_end < start) || (fl->fl_start > (start + len)))
2444                                 continue;
2445                 } else if (IS_FLOCK(fl)) {
2446                         if (!(fl->fl_type & LOCK_MAND))
2447                                 continue;
2448                         if (fl->fl_type & LOCK_WRITE)
2449                                 continue;
2450                 } else
2451                         continue;
2452                 result = 0;
2453                 break;
2454         }
2455         spin_unlock(&inode->i_lock);
2456         return result;
2457 }
2458
2459 EXPORT_SYMBOL(lock_may_write);
2460
2461 static int __init filelock_init(void)
2462 {
2463         filelock_cache = kmem_cache_create("file_lock_cache",
2464                         sizeof(struct file_lock), 0, SLAB_PANIC, NULL);
2465
2466         return 0;
2467 }
2468
2469 core_initcall(filelock_init);