Merge branch 'locking-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6-microblaze.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/security.h>
123 #include <linux/slab.h>
124 #include <linux/syscalls.h>
125 #include <linux/time.h>
126 #include <linux/rcupdate.h>
127 #include <linux/pid_namespace.h>
128 #include <linux/hashtable.h>
129 #include <linux/percpu.h>
130
131 #define CREATE_TRACE_POINTS
132 #include <trace/events/filelock.h>
133
134 #include <linux/uaccess.h>
135
136 #define IS_POSIX(fl)    (fl->fl_flags & FL_POSIX)
137 #define IS_FLOCK(fl)    (fl->fl_flags & FL_FLOCK)
138 #define IS_LEASE(fl)    (fl->fl_flags & (FL_LEASE|FL_DELEG|FL_LAYOUT))
139 #define IS_OFDLCK(fl)   (fl->fl_flags & FL_OFDLCK)
140 #define IS_REMOTELCK(fl)        (fl->fl_pid <= 0)
141
142 static bool lease_breaking(struct file_lock *fl)
143 {
144         return fl->fl_flags & (FL_UNLOCK_PENDING | FL_DOWNGRADE_PENDING);
145 }
146
147 static int target_leasetype(struct file_lock *fl)
148 {
149         if (fl->fl_flags & FL_UNLOCK_PENDING)
150                 return F_UNLCK;
151         if (fl->fl_flags & FL_DOWNGRADE_PENDING)
152                 return F_RDLCK;
153         return fl->fl_type;
154 }
155
156 int leases_enable = 1;
157 int lease_break_time = 45;
158
159 /*
160  * The global file_lock_list is only used for displaying /proc/locks, so we
161  * keep a list on each CPU, with each list protected by its own spinlock.
162  * Global serialization is done using file_rwsem.
163  *
164  * Note that alterations to the list also require that the relevant flc_lock is
165  * held.
166  */
167 struct file_lock_list_struct {
168         spinlock_t              lock;
169         struct hlist_head       hlist;
170 };
171 static DEFINE_PER_CPU(struct file_lock_list_struct, file_lock_list);
172 DEFINE_STATIC_PERCPU_RWSEM(file_rwsem);
173
174 /*
175  * The blocked_hash is used to find POSIX lock loops for deadlock detection.
176  * It is protected by blocked_lock_lock.
177  *
178  * We hash locks by lockowner in order to optimize searching for the lock a
179  * particular lockowner is waiting on.
180  *
181  * FIXME: make this value scale via some heuristic? We generally will want more
182  * buckets when we have more lockowners holding locks, but that's a little
183  * difficult to determine without knowing what the workload will look like.
184  */
185 #define BLOCKED_HASH_BITS       7
186 static DEFINE_HASHTABLE(blocked_hash, BLOCKED_HASH_BITS);
187
188 /*
189  * This lock protects the blocked_hash. Generally, if you're accessing it, you
190  * want to be holding this lock.
191  *
192  * In addition, it also protects the fl->fl_block list, and the fl->fl_next
193  * pointer for file_lock structures that are acting as lock requests (in
194  * contrast to those that are acting as records of acquired locks).
195  *
196  * Note that when we acquire this lock in order to change the above fields,
197  * we often hold the flc_lock as well. In certain cases, when reading the fields
198  * protected by this lock, we can skip acquiring it iff we already hold the
199  * flc_lock.
200  */
201 static DEFINE_SPINLOCK(blocked_lock_lock);
202
203 static struct kmem_cache *flctx_cache __read_mostly;
204 static struct kmem_cache *filelock_cache __read_mostly;
205
206 static struct file_lock_context *
207 locks_get_lock_context(struct inode *inode, int type)
208 {
209         struct file_lock_context *ctx;
210
211         /* paired with cmpxchg() below */
212         ctx = smp_load_acquire(&inode->i_flctx);
213         if (likely(ctx) || type == F_UNLCK)
214                 goto out;
215
216         ctx = kmem_cache_alloc(flctx_cache, GFP_KERNEL);
217         if (!ctx)
218                 goto out;
219
220         spin_lock_init(&ctx->flc_lock);
221         INIT_LIST_HEAD(&ctx->flc_flock);
222         INIT_LIST_HEAD(&ctx->flc_posix);
223         INIT_LIST_HEAD(&ctx->flc_lease);
224
225         /*
226          * Assign the pointer if it's not already assigned. If it is, then
227          * free the context we just allocated.
228          */
229         if (cmpxchg(&inode->i_flctx, NULL, ctx)) {
230                 kmem_cache_free(flctx_cache, ctx);
231                 ctx = smp_load_acquire(&inode->i_flctx);
232         }
233 out:
234         trace_locks_get_lock_context(inode, type, ctx);
235         return ctx;
236 }
237
238 static void
239 locks_dump_ctx_list(struct list_head *list, char *list_type)
240 {
241         struct file_lock *fl;
242
243         list_for_each_entry(fl, list, fl_list) {
244                 pr_warn("%s: fl_owner=%p fl_flags=0x%x fl_type=0x%x fl_pid=%u\n", list_type, fl->fl_owner, fl->fl_flags, fl->fl_type, fl->fl_pid);
245         }
246 }
247
248 static void
249 locks_check_ctx_lists(struct inode *inode)
250 {
251         struct file_lock_context *ctx = inode->i_flctx;
252
253         if (unlikely(!list_empty(&ctx->flc_flock) ||
254                      !list_empty(&ctx->flc_posix) ||
255                      !list_empty(&ctx->flc_lease))) {
256                 pr_warn("Leaked locks on dev=0x%x:0x%x ino=0x%lx:\n",
257                         MAJOR(inode->i_sb->s_dev), MINOR(inode->i_sb->s_dev),
258                         inode->i_ino);
259                 locks_dump_ctx_list(&ctx->flc_flock, "FLOCK");
260                 locks_dump_ctx_list(&ctx->flc_posix, "POSIX");
261                 locks_dump_ctx_list(&ctx->flc_lease, "LEASE");
262         }
263 }
264
265 static void
266 locks_check_ctx_file_list(struct file *filp, struct list_head *list,
267                                 char *list_type)
268 {
269         struct file_lock *fl;
270         struct inode *inode = locks_inode(filp);
271
272         list_for_each_entry(fl, list, fl_list)
273                 if (fl->fl_file == filp)
274                         pr_warn("Leaked %s lock on dev=0x%x:0x%x ino=0x%lx "
275                                 " fl_owner=%p fl_flags=0x%x fl_type=0x%x fl_pid=%u\n",
276                                 list_type, MAJOR(inode->i_sb->s_dev),
277                                 MINOR(inode->i_sb->s_dev), inode->i_ino,
278                                 fl->fl_owner, fl->fl_flags, fl->fl_type, fl->fl_pid);
279 }
280
281 void
282 locks_free_lock_context(struct inode *inode)
283 {
284         struct file_lock_context *ctx = inode->i_flctx;
285
286         if (unlikely(ctx)) {
287                 locks_check_ctx_lists(inode);
288                 kmem_cache_free(flctx_cache, ctx);
289         }
290 }
291
292 static void locks_init_lock_heads(struct file_lock *fl)
293 {
294         INIT_HLIST_NODE(&fl->fl_link);
295         INIT_LIST_HEAD(&fl->fl_list);
296         INIT_LIST_HEAD(&fl->fl_block);
297         init_waitqueue_head(&fl->fl_wait);
298 }
299
300 /* Allocate an empty lock structure. */
301 struct file_lock *locks_alloc_lock(void)
302 {
303         struct file_lock *fl = kmem_cache_zalloc(filelock_cache, GFP_KERNEL);
304
305         if (fl)
306                 locks_init_lock_heads(fl);
307
308         return fl;
309 }
310 EXPORT_SYMBOL_GPL(locks_alloc_lock);
311
312 void locks_release_private(struct file_lock *fl)
313 {
314         if (fl->fl_ops) {
315                 if (fl->fl_ops->fl_release_private)
316                         fl->fl_ops->fl_release_private(fl);
317                 fl->fl_ops = NULL;
318         }
319
320         if (fl->fl_lmops) {
321                 if (fl->fl_lmops->lm_put_owner) {
322                         fl->fl_lmops->lm_put_owner(fl->fl_owner);
323                         fl->fl_owner = NULL;
324                 }
325                 fl->fl_lmops = NULL;
326         }
327 }
328 EXPORT_SYMBOL_GPL(locks_release_private);
329
330 /* Free a lock which is not in use. */
331 void locks_free_lock(struct file_lock *fl)
332 {
333         BUG_ON(waitqueue_active(&fl->fl_wait));
334         BUG_ON(!list_empty(&fl->fl_list));
335         BUG_ON(!list_empty(&fl->fl_block));
336         BUG_ON(!hlist_unhashed(&fl->fl_link));
337
338         locks_release_private(fl);
339         kmem_cache_free(filelock_cache, fl);
340 }
341 EXPORT_SYMBOL(locks_free_lock);
342
343 static void
344 locks_dispose_list(struct list_head *dispose)
345 {
346         struct file_lock *fl;
347
348         while (!list_empty(dispose)) {
349                 fl = list_first_entry(dispose, struct file_lock, fl_list);
350                 list_del_init(&fl->fl_list);
351                 locks_free_lock(fl);
352         }
353 }
354
355 void locks_init_lock(struct file_lock *fl)
356 {
357         memset(fl, 0, sizeof(struct file_lock));
358         locks_init_lock_heads(fl);
359 }
360
361 EXPORT_SYMBOL(locks_init_lock);
362
363 /*
364  * Initialize a new lock from an existing file_lock structure.
365  */
366 void locks_copy_conflock(struct file_lock *new, struct file_lock *fl)
367 {
368         new->fl_owner = fl->fl_owner;
369         new->fl_pid = fl->fl_pid;
370         new->fl_file = NULL;
371         new->fl_flags = fl->fl_flags;
372         new->fl_type = fl->fl_type;
373         new->fl_start = fl->fl_start;
374         new->fl_end = fl->fl_end;
375         new->fl_lmops = fl->fl_lmops;
376         new->fl_ops = NULL;
377
378         if (fl->fl_lmops) {
379                 if (fl->fl_lmops->lm_get_owner)
380                         fl->fl_lmops->lm_get_owner(fl->fl_owner);
381         }
382 }
383 EXPORT_SYMBOL(locks_copy_conflock);
384
385 void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
386 {
387         /* "new" must be a freshly-initialized lock */
388         WARN_ON_ONCE(new->fl_ops);
389
390         locks_copy_conflock(new, fl);
391
392         new->fl_file = fl->fl_file;
393         new->fl_ops = fl->fl_ops;
394
395         if (fl->fl_ops) {
396                 if (fl->fl_ops->fl_copy_lock)
397                         fl->fl_ops->fl_copy_lock(new, fl);
398         }
399 }
400
401 EXPORT_SYMBOL(locks_copy_lock);
402
403 static inline int flock_translate_cmd(int cmd) {
404         if (cmd & LOCK_MAND)
405                 return cmd & (LOCK_MAND | LOCK_RW);
406         switch (cmd) {
407         case LOCK_SH:
408                 return F_RDLCK;
409         case LOCK_EX:
410                 return F_WRLCK;
411         case LOCK_UN:
412                 return F_UNLCK;
413         }
414         return -EINVAL;
415 }
416
417 /* Fill in a file_lock structure with an appropriate FLOCK lock. */
418 static struct file_lock *
419 flock_make_lock(struct file *filp, unsigned int cmd)
420 {
421         struct file_lock *fl;
422         int type = flock_translate_cmd(cmd);
423
424         if (type < 0)
425                 return ERR_PTR(type);
426         
427         fl = locks_alloc_lock();
428         if (fl == NULL)
429                 return ERR_PTR(-ENOMEM);
430
431         fl->fl_file = filp;
432         fl->fl_owner = filp;
433         fl->fl_pid = current->tgid;
434         fl->fl_flags = FL_FLOCK;
435         fl->fl_type = type;
436         fl->fl_end = OFFSET_MAX;
437         
438         return fl;
439 }
440
441 static int assign_type(struct file_lock *fl, long type)
442 {
443         switch (type) {
444         case F_RDLCK:
445         case F_WRLCK:
446         case F_UNLCK:
447                 fl->fl_type = type;
448                 break;
449         default:
450                 return -EINVAL;
451         }
452         return 0;
453 }
454
455 static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl,
456                                  struct flock64 *l)
457 {
458         switch (l->l_whence) {
459         case SEEK_SET:
460                 fl->fl_start = 0;
461                 break;
462         case SEEK_CUR:
463                 fl->fl_start = filp->f_pos;
464                 break;
465         case SEEK_END:
466                 fl->fl_start = i_size_read(file_inode(filp));
467                 break;
468         default:
469                 return -EINVAL;
470         }
471         if (l->l_start > OFFSET_MAX - fl->fl_start)
472                 return -EOVERFLOW;
473         fl->fl_start += l->l_start;
474         if (fl->fl_start < 0)
475                 return -EINVAL;
476
477         /* POSIX-1996 leaves the case l->l_len < 0 undefined;
478            POSIX-2001 defines it. */
479         if (l->l_len > 0) {
480                 if (l->l_len - 1 > OFFSET_MAX - fl->fl_start)
481                         return -EOVERFLOW;
482                 fl->fl_end = fl->fl_start + l->l_len - 1;
483
484         } else if (l->l_len < 0) {
485                 if (fl->fl_start + l->l_len < 0)
486                         return -EINVAL;
487                 fl->fl_end = fl->fl_start - 1;
488                 fl->fl_start += l->l_len;
489         } else
490                 fl->fl_end = OFFSET_MAX;
491
492         fl->fl_owner = current->files;
493         fl->fl_pid = current->tgid;
494         fl->fl_file = filp;
495         fl->fl_flags = FL_POSIX;
496         fl->fl_ops = NULL;
497         fl->fl_lmops = NULL;
498
499         return assign_type(fl, l->l_type);
500 }
501
502 /* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX
503  * style lock.
504  */
505 static int flock_to_posix_lock(struct file *filp, struct file_lock *fl,
506                                struct flock *l)
507 {
508         struct flock64 ll = {
509                 .l_type = l->l_type,
510                 .l_whence = l->l_whence,
511                 .l_start = l->l_start,
512                 .l_len = l->l_len,
513         };
514
515         return flock64_to_posix_lock(filp, fl, &ll);
516 }
517
518 /* default lease lock manager operations */
519 static bool
520 lease_break_callback(struct file_lock *fl)
521 {
522         kill_fasync(&fl->fl_fasync, SIGIO, POLL_MSG);
523         return false;
524 }
525
526 static void
527 lease_setup(struct file_lock *fl, void **priv)
528 {
529         struct file *filp = fl->fl_file;
530         struct fasync_struct *fa = *priv;
531
532         /*
533          * fasync_insert_entry() returns the old entry if any. If there was no
534          * old entry, then it used "priv" and inserted it into the fasync list.
535          * Clear the pointer to indicate that it shouldn't be freed.
536          */
537         if (!fasync_insert_entry(fa->fa_fd, filp, &fl->fl_fasync, fa))
538                 *priv = NULL;
539
540         __f_setown(filp, task_pid(current), PIDTYPE_TGID, 0);
541 }
542
543 static const struct lock_manager_operations lease_manager_ops = {
544         .lm_break = lease_break_callback,
545         .lm_change = lease_modify,
546         .lm_setup = lease_setup,
547 };
548
549 /*
550  * Initialize a lease, use the default lock manager operations
551  */
552 static int lease_init(struct file *filp, long type, struct file_lock *fl)
553 {
554         if (assign_type(fl, type) != 0)
555                 return -EINVAL;
556
557         fl->fl_owner = filp;
558         fl->fl_pid = current->tgid;
559
560         fl->fl_file = filp;
561         fl->fl_flags = FL_LEASE;
562         fl->fl_start = 0;
563         fl->fl_end = OFFSET_MAX;
564         fl->fl_ops = NULL;
565         fl->fl_lmops = &lease_manager_ops;
566         return 0;
567 }
568
569 /* Allocate a file_lock initialised to this type of lease */
570 static struct file_lock *lease_alloc(struct file *filp, long type)
571 {
572         struct file_lock *fl = locks_alloc_lock();
573         int error = -ENOMEM;
574
575         if (fl == NULL)
576                 return ERR_PTR(error);
577
578         error = lease_init(filp, type, fl);
579         if (error) {
580                 locks_free_lock(fl);
581                 return ERR_PTR(error);
582         }
583         return fl;
584 }
585
586 /* Check if two locks overlap each other.
587  */
588 static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2)
589 {
590         return ((fl1->fl_end >= fl2->fl_start) &&
591                 (fl2->fl_end >= fl1->fl_start));
592 }
593
594 /*
595  * Check whether two locks have the same owner.
596  */
597 static int posix_same_owner(struct file_lock *fl1, struct file_lock *fl2)
598 {
599         if (fl1->fl_lmops && fl1->fl_lmops->lm_compare_owner)
600                 return fl2->fl_lmops == fl1->fl_lmops &&
601                         fl1->fl_lmops->lm_compare_owner(fl1, fl2);
602         return fl1->fl_owner == fl2->fl_owner;
603 }
604
605 /* Must be called with the flc_lock held! */
606 static void locks_insert_global_locks(struct file_lock *fl)
607 {
608         struct file_lock_list_struct *fll = this_cpu_ptr(&file_lock_list);
609
610         percpu_rwsem_assert_held(&file_rwsem);
611
612         spin_lock(&fll->lock);
613         fl->fl_link_cpu = smp_processor_id();
614         hlist_add_head(&fl->fl_link, &fll->hlist);
615         spin_unlock(&fll->lock);
616 }
617
618 /* Must be called with the flc_lock held! */
619 static void locks_delete_global_locks(struct file_lock *fl)
620 {
621         struct file_lock_list_struct *fll;
622
623         percpu_rwsem_assert_held(&file_rwsem);
624
625         /*
626          * Avoid taking lock if already unhashed. This is safe since this check
627          * is done while holding the flc_lock, and new insertions into the list
628          * also require that it be held.
629          */
630         if (hlist_unhashed(&fl->fl_link))
631                 return;
632
633         fll = per_cpu_ptr(&file_lock_list, fl->fl_link_cpu);
634         spin_lock(&fll->lock);
635         hlist_del_init(&fl->fl_link);
636         spin_unlock(&fll->lock);
637 }
638
639 static unsigned long
640 posix_owner_key(struct file_lock *fl)
641 {
642         if (fl->fl_lmops && fl->fl_lmops->lm_owner_key)
643                 return fl->fl_lmops->lm_owner_key(fl);
644         return (unsigned long)fl->fl_owner;
645 }
646
647 static void locks_insert_global_blocked(struct file_lock *waiter)
648 {
649         lockdep_assert_held(&blocked_lock_lock);
650
651         hash_add(blocked_hash, &waiter->fl_link, posix_owner_key(waiter));
652 }
653
654 static void locks_delete_global_blocked(struct file_lock *waiter)
655 {
656         lockdep_assert_held(&blocked_lock_lock);
657
658         hash_del(&waiter->fl_link);
659 }
660
661 /* Remove waiter from blocker's block list.
662  * When blocker ends up pointing to itself then the list is empty.
663  *
664  * Must be called with blocked_lock_lock held.
665  */
666 static void __locks_delete_block(struct file_lock *waiter)
667 {
668         locks_delete_global_blocked(waiter);
669         list_del_init(&waiter->fl_block);
670         waiter->fl_next = NULL;
671 }
672
673 static void locks_delete_block(struct file_lock *waiter)
674 {
675         spin_lock(&blocked_lock_lock);
676         __locks_delete_block(waiter);
677         spin_unlock(&blocked_lock_lock);
678 }
679
680 /* Insert waiter into blocker's block list.
681  * We use a circular list so that processes can be easily woken up in
682  * the order they blocked. The documentation doesn't require this but
683  * it seems like the reasonable thing to do.
684  *
685  * Must be called with both the flc_lock and blocked_lock_lock held. The
686  * fl_block list itself is protected by the blocked_lock_lock, but by ensuring
687  * that the flc_lock is also held on insertions we can avoid taking the
688  * blocked_lock_lock in some cases when we see that the fl_block list is empty.
689  */
690 static void __locks_insert_block(struct file_lock *blocker,
691                                         struct file_lock *waiter)
692 {
693         BUG_ON(!list_empty(&waiter->fl_block));
694         waiter->fl_next = blocker;
695         list_add_tail(&waiter->fl_block, &blocker->fl_block);
696         if (IS_POSIX(blocker) && !IS_OFDLCK(blocker))
697                 locks_insert_global_blocked(waiter);
698 }
699
700 /* Must be called with flc_lock held. */
701 static void locks_insert_block(struct file_lock *blocker,
702                                         struct file_lock *waiter)
703 {
704         spin_lock(&blocked_lock_lock);
705         __locks_insert_block(blocker, waiter);
706         spin_unlock(&blocked_lock_lock);
707 }
708
709 /*
710  * Wake up processes blocked waiting for blocker.
711  *
712  * Must be called with the inode->flc_lock held!
713  */
714 static void locks_wake_up_blocks(struct file_lock *blocker)
715 {
716         /*
717          * Avoid taking global lock if list is empty. This is safe since new
718          * blocked requests are only added to the list under the flc_lock, and
719          * the flc_lock is always held here. Note that removal from the fl_block
720          * list does not require the flc_lock, so we must recheck list_empty()
721          * after acquiring the blocked_lock_lock.
722          */
723         if (list_empty(&blocker->fl_block))
724                 return;
725
726         spin_lock(&blocked_lock_lock);
727         while (!list_empty(&blocker->fl_block)) {
728                 struct file_lock *waiter;
729
730                 waiter = list_first_entry(&blocker->fl_block,
731                                 struct file_lock, fl_block);
732                 __locks_delete_block(waiter);
733                 if (waiter->fl_lmops && waiter->fl_lmops->lm_notify)
734                         waiter->fl_lmops->lm_notify(waiter);
735                 else
736                         wake_up(&waiter->fl_wait);
737         }
738         spin_unlock(&blocked_lock_lock);
739 }
740
741 static void
742 locks_insert_lock_ctx(struct file_lock *fl, struct list_head *before)
743 {
744         list_add_tail(&fl->fl_list, before);
745         locks_insert_global_locks(fl);
746 }
747
748 static void
749 locks_unlink_lock_ctx(struct file_lock *fl)
750 {
751         locks_delete_global_locks(fl);
752         list_del_init(&fl->fl_list);
753         locks_wake_up_blocks(fl);
754 }
755
756 static void
757 locks_delete_lock_ctx(struct file_lock *fl, struct list_head *dispose)
758 {
759         locks_unlink_lock_ctx(fl);
760         if (dispose)
761                 list_add(&fl->fl_list, dispose);
762         else
763                 locks_free_lock(fl);
764 }
765
766 /* Determine if lock sys_fl blocks lock caller_fl. Common functionality
767  * checks for shared/exclusive status of overlapping locks.
768  */
769 static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
770 {
771         if (sys_fl->fl_type == F_WRLCK)
772                 return 1;
773         if (caller_fl->fl_type == F_WRLCK)
774                 return 1;
775         return 0;
776 }
777
778 /* Determine if lock sys_fl blocks lock caller_fl. POSIX specific
779  * checking before calling the locks_conflict().
780  */
781 static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
782 {
783         /* POSIX locks owned by the same process do not conflict with
784          * each other.
785          */
786         if (posix_same_owner(caller_fl, sys_fl))
787                 return (0);
788
789         /* Check whether they overlap */
790         if (!locks_overlap(caller_fl, sys_fl))
791                 return 0;
792
793         return (locks_conflict(caller_fl, sys_fl));
794 }
795
796 /* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific
797  * checking before calling the locks_conflict().
798  */
799 static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
800 {
801         /* FLOCK locks referring to the same filp do not conflict with
802          * each other.
803          */
804         if (caller_fl->fl_file == sys_fl->fl_file)
805                 return (0);
806         if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND))
807                 return 0;
808
809         return (locks_conflict(caller_fl, sys_fl));
810 }
811
812 void
813 posix_test_lock(struct file *filp, struct file_lock *fl)
814 {
815         struct file_lock *cfl;
816         struct file_lock_context *ctx;
817         struct inode *inode = locks_inode(filp);
818
819         ctx = smp_load_acquire(&inode->i_flctx);
820         if (!ctx || list_empty_careful(&ctx->flc_posix)) {
821                 fl->fl_type = F_UNLCK;
822                 return;
823         }
824
825         spin_lock(&ctx->flc_lock);
826         list_for_each_entry(cfl, &ctx->flc_posix, fl_list) {
827                 if (posix_locks_conflict(fl, cfl)) {
828                         locks_copy_conflock(fl, cfl);
829                         goto out;
830                 }
831         }
832         fl->fl_type = F_UNLCK;
833 out:
834         spin_unlock(&ctx->flc_lock);
835         return;
836 }
837 EXPORT_SYMBOL(posix_test_lock);
838
839 /*
840  * Deadlock detection:
841  *
842  * We attempt to detect deadlocks that are due purely to posix file
843  * locks.
844  *
845  * We assume that a task can be waiting for at most one lock at a time.
846  * So for any acquired lock, the process holding that lock may be
847  * waiting on at most one other lock.  That lock in turns may be held by
848  * someone waiting for at most one other lock.  Given a requested lock
849  * caller_fl which is about to wait for a conflicting lock block_fl, we
850  * follow this chain of waiters to ensure we are not about to create a
851  * cycle.
852  *
853  * Since we do this before we ever put a process to sleep on a lock, we
854  * are ensured that there is never a cycle; that is what guarantees that
855  * the while() loop in posix_locks_deadlock() eventually completes.
856  *
857  * Note: the above assumption may not be true when handling lock
858  * requests from a broken NFS client. It may also fail in the presence
859  * of tasks (such as posix threads) sharing the same open file table.
860  * To handle those cases, we just bail out after a few iterations.
861  *
862  * For FL_OFDLCK locks, the owner is the filp, not the files_struct.
863  * Because the owner is not even nominally tied to a thread of
864  * execution, the deadlock detection below can't reasonably work well. Just
865  * skip it for those.
866  *
867  * In principle, we could do a more limited deadlock detection on FL_OFDLCK
868  * locks that just checks for the case where two tasks are attempting to
869  * upgrade from read to write locks on the same inode.
870  */
871
872 #define MAX_DEADLK_ITERATIONS 10
873
874 /* Find a lock that the owner of the given block_fl is blocking on. */
875 static struct file_lock *what_owner_is_waiting_for(struct file_lock *block_fl)
876 {
877         struct file_lock *fl;
878
879         hash_for_each_possible(blocked_hash, fl, fl_link, posix_owner_key(block_fl)) {
880                 if (posix_same_owner(fl, block_fl))
881                         return fl->fl_next;
882         }
883         return NULL;
884 }
885
886 /* Must be called with the blocked_lock_lock held! */
887 static int posix_locks_deadlock(struct file_lock *caller_fl,
888                                 struct file_lock *block_fl)
889 {
890         int i = 0;
891
892         lockdep_assert_held(&blocked_lock_lock);
893
894         /*
895          * This deadlock detector can't reasonably detect deadlocks with
896          * FL_OFDLCK locks, since they aren't owned by a process, per-se.
897          */
898         if (IS_OFDLCK(caller_fl))
899                 return 0;
900
901         while ((block_fl = what_owner_is_waiting_for(block_fl))) {
902                 if (i++ > MAX_DEADLK_ITERATIONS)
903                         return 0;
904                 if (posix_same_owner(caller_fl, block_fl))
905                         return 1;
906         }
907         return 0;
908 }
909
910 /* Try to create a FLOCK lock on filp. We always insert new FLOCK locks
911  * after any leases, but before any posix locks.
912  *
913  * Note that if called with an FL_EXISTS argument, the caller may determine
914  * whether or not a lock was successfully freed by testing the return
915  * value for -ENOENT.
916  */
917 static int flock_lock_inode(struct inode *inode, struct file_lock *request)
918 {
919         struct file_lock *new_fl = NULL;
920         struct file_lock *fl;
921         struct file_lock_context *ctx;
922         int error = 0;
923         bool found = false;
924         LIST_HEAD(dispose);
925
926         ctx = locks_get_lock_context(inode, request->fl_type);
927         if (!ctx) {
928                 if (request->fl_type != F_UNLCK)
929                         return -ENOMEM;
930                 return (request->fl_flags & FL_EXISTS) ? -ENOENT : 0;
931         }
932
933         if (!(request->fl_flags & FL_ACCESS) && (request->fl_type != F_UNLCK)) {
934                 new_fl = locks_alloc_lock();
935                 if (!new_fl)
936                         return -ENOMEM;
937         }
938
939         percpu_down_read_preempt_disable(&file_rwsem);
940         spin_lock(&ctx->flc_lock);
941         if (request->fl_flags & FL_ACCESS)
942                 goto find_conflict;
943
944         list_for_each_entry(fl, &ctx->flc_flock, fl_list) {
945                 if (request->fl_file != fl->fl_file)
946                         continue;
947                 if (request->fl_type == fl->fl_type)
948                         goto out;
949                 found = true;
950                 locks_delete_lock_ctx(fl, &dispose);
951                 break;
952         }
953
954         if (request->fl_type == F_UNLCK) {
955                 if ((request->fl_flags & FL_EXISTS) && !found)
956                         error = -ENOENT;
957                 goto out;
958         }
959
960 find_conflict:
961         list_for_each_entry(fl, &ctx->flc_flock, fl_list) {
962                 if (!flock_locks_conflict(request, fl))
963                         continue;
964                 error = -EAGAIN;
965                 if (!(request->fl_flags & FL_SLEEP))
966                         goto out;
967                 error = FILE_LOCK_DEFERRED;
968                 locks_insert_block(fl, request);
969                 goto out;
970         }
971         if (request->fl_flags & FL_ACCESS)
972                 goto out;
973         locks_copy_lock(new_fl, request);
974         locks_insert_lock_ctx(new_fl, &ctx->flc_flock);
975         new_fl = NULL;
976         error = 0;
977
978 out:
979         spin_unlock(&ctx->flc_lock);
980         percpu_up_read_preempt_enable(&file_rwsem);
981         if (new_fl)
982                 locks_free_lock(new_fl);
983         locks_dispose_list(&dispose);
984         trace_flock_lock_inode(inode, request, error);
985         return error;
986 }
987
988 static int posix_lock_inode(struct inode *inode, struct file_lock *request,
989                             struct file_lock *conflock)
990 {
991         struct file_lock *fl, *tmp;
992         struct file_lock *new_fl = NULL;
993         struct file_lock *new_fl2 = NULL;
994         struct file_lock *left = NULL;
995         struct file_lock *right = NULL;
996         struct file_lock_context *ctx;
997         int error;
998         bool added = false;
999         LIST_HEAD(dispose);
1000
1001         ctx = locks_get_lock_context(inode, request->fl_type);
1002         if (!ctx)
1003                 return (request->fl_type == F_UNLCK) ? 0 : -ENOMEM;
1004
1005         /*
1006          * We may need two file_lock structures for this operation,
1007          * so we get them in advance to avoid races.
1008          *
1009          * In some cases we can be sure, that no new locks will be needed
1010          */
1011         if (!(request->fl_flags & FL_ACCESS) &&
1012             (request->fl_type != F_UNLCK ||
1013              request->fl_start != 0 || request->fl_end != OFFSET_MAX)) {
1014                 new_fl = locks_alloc_lock();
1015                 new_fl2 = locks_alloc_lock();
1016         }
1017
1018         percpu_down_read_preempt_disable(&file_rwsem);
1019         spin_lock(&ctx->flc_lock);
1020         /*
1021          * New lock request. Walk all POSIX locks and look for conflicts. If
1022          * there are any, either return error or put the request on the
1023          * blocker's list of waiters and the global blocked_hash.
1024          */
1025         if (request->fl_type != F_UNLCK) {
1026                 list_for_each_entry(fl, &ctx->flc_posix, fl_list) {
1027                         if (!posix_locks_conflict(request, fl))
1028                                 continue;
1029                         if (conflock)
1030                                 locks_copy_conflock(conflock, fl);
1031                         error = -EAGAIN;
1032                         if (!(request->fl_flags & FL_SLEEP))
1033                                 goto out;
1034                         /*
1035                          * Deadlock detection and insertion into the blocked
1036                          * locks list must be done while holding the same lock!
1037                          */
1038                         error = -EDEADLK;
1039                         spin_lock(&blocked_lock_lock);
1040                         if (likely(!posix_locks_deadlock(request, fl))) {
1041                                 error = FILE_LOCK_DEFERRED;
1042                                 __locks_insert_block(fl, request);
1043                         }
1044                         spin_unlock(&blocked_lock_lock);
1045                         goto out;
1046                 }
1047         }
1048
1049         /* If we're just looking for a conflict, we're done. */
1050         error = 0;
1051         if (request->fl_flags & FL_ACCESS)
1052                 goto out;
1053
1054         /* Find the first old lock with the same owner as the new lock */
1055         list_for_each_entry(fl, &ctx->flc_posix, fl_list) {
1056                 if (posix_same_owner(request, fl))
1057                         break;
1058         }
1059
1060         /* Process locks with this owner. */
1061         list_for_each_entry_safe_from(fl, tmp, &ctx->flc_posix, fl_list) {
1062                 if (!posix_same_owner(request, fl))
1063                         break;
1064
1065                 /* Detect adjacent or overlapping regions (if same lock type) */
1066                 if (request->fl_type == fl->fl_type) {
1067                         /* In all comparisons of start vs end, use
1068                          * "start - 1" rather than "end + 1". If end
1069                          * is OFFSET_MAX, end + 1 will become negative.
1070                          */
1071                         if (fl->fl_end < request->fl_start - 1)
1072                                 continue;
1073                         /* If the next lock in the list has entirely bigger
1074                          * addresses than the new one, insert the lock here.
1075                          */
1076                         if (fl->fl_start - 1 > request->fl_end)
1077                                 break;
1078
1079                         /* If we come here, the new and old lock are of the
1080                          * same type and adjacent or overlapping. Make one
1081                          * lock yielding from the lower start address of both
1082                          * locks to the higher end address.
1083                          */
1084                         if (fl->fl_start > request->fl_start)
1085                                 fl->fl_start = request->fl_start;
1086                         else
1087                                 request->fl_start = fl->fl_start;
1088                         if (fl->fl_end < request->fl_end)
1089                                 fl->fl_end = request->fl_end;
1090                         else
1091                                 request->fl_end = fl->fl_end;
1092                         if (added) {
1093                                 locks_delete_lock_ctx(fl, &dispose);
1094                                 continue;
1095                         }
1096                         request = fl;
1097                         added = true;
1098                 } else {
1099                         /* Processing for different lock types is a bit
1100                          * more complex.
1101                          */
1102                         if (fl->fl_end < request->fl_start)
1103                                 continue;
1104                         if (fl->fl_start > request->fl_end)
1105                                 break;
1106                         if (request->fl_type == F_UNLCK)
1107                                 added = true;
1108                         if (fl->fl_start < request->fl_start)
1109                                 left = fl;
1110                         /* If the next lock in the list has a higher end
1111                          * address than the new one, insert the new one here.
1112                          */
1113                         if (fl->fl_end > request->fl_end) {
1114                                 right = fl;
1115                                 break;
1116                         }
1117                         if (fl->fl_start >= request->fl_start) {
1118                                 /* The new lock completely replaces an old
1119                                  * one (This may happen several times).
1120                                  */
1121                                 if (added) {
1122                                         locks_delete_lock_ctx(fl, &dispose);
1123                                         continue;
1124                                 }
1125                                 /*
1126                                  * Replace the old lock with new_fl, and
1127                                  * remove the old one. It's safe to do the
1128                                  * insert here since we know that we won't be
1129                                  * using new_fl later, and that the lock is
1130                                  * just replacing an existing lock.
1131                                  */
1132                                 error = -ENOLCK;
1133                                 if (!new_fl)
1134                                         goto out;
1135                                 locks_copy_lock(new_fl, request);
1136                                 request = new_fl;
1137                                 new_fl = NULL;
1138                                 locks_insert_lock_ctx(request, &fl->fl_list);
1139                                 locks_delete_lock_ctx(fl, &dispose);
1140                                 added = true;
1141                         }
1142                 }
1143         }
1144
1145         /*
1146          * The above code only modifies existing locks in case of merging or
1147          * replacing. If new lock(s) need to be inserted all modifications are
1148          * done below this, so it's safe yet to bail out.
1149          */
1150         error = -ENOLCK; /* "no luck" */
1151         if (right && left == right && !new_fl2)
1152                 goto out;
1153
1154         error = 0;
1155         if (!added) {
1156                 if (request->fl_type == F_UNLCK) {
1157                         if (request->fl_flags & FL_EXISTS)
1158                                 error = -ENOENT;
1159                         goto out;
1160                 }
1161
1162                 if (!new_fl) {
1163                         error = -ENOLCK;
1164                         goto out;
1165                 }
1166                 locks_copy_lock(new_fl, request);
1167                 locks_insert_lock_ctx(new_fl, &fl->fl_list);
1168                 fl = new_fl;
1169                 new_fl = NULL;
1170         }
1171         if (right) {
1172                 if (left == right) {
1173                         /* The new lock breaks the old one in two pieces,
1174                          * so we have to use the second new lock.
1175                          */
1176                         left = new_fl2;
1177                         new_fl2 = NULL;
1178                         locks_copy_lock(left, right);
1179                         locks_insert_lock_ctx(left, &fl->fl_list);
1180                 }
1181                 right->fl_start = request->fl_end + 1;
1182                 locks_wake_up_blocks(right);
1183         }
1184         if (left) {
1185                 left->fl_end = request->fl_start - 1;
1186                 locks_wake_up_blocks(left);
1187         }
1188  out:
1189         spin_unlock(&ctx->flc_lock);
1190         percpu_up_read_preempt_enable(&file_rwsem);
1191         /*
1192          * Free any unused locks.
1193          */
1194         if (new_fl)
1195                 locks_free_lock(new_fl);
1196         if (new_fl2)
1197                 locks_free_lock(new_fl2);
1198         locks_dispose_list(&dispose);
1199         trace_posix_lock_inode(inode, request, error);
1200
1201         return error;
1202 }
1203
1204 /**
1205  * posix_lock_file - Apply a POSIX-style lock to a file
1206  * @filp: The file to apply the lock to
1207  * @fl: The lock to be applied
1208  * @conflock: Place to return a copy of the conflicting lock, if found.
1209  *
1210  * Add a POSIX style lock to a file.
1211  * We merge adjacent & overlapping locks whenever possible.
1212  * POSIX locks are sorted by owner task, then by starting address
1213  *
1214  * Note that if called with an FL_EXISTS argument, the caller may determine
1215  * whether or not a lock was successfully freed by testing the return
1216  * value for -ENOENT.
1217  */
1218 int posix_lock_file(struct file *filp, struct file_lock *fl,
1219                         struct file_lock *conflock)
1220 {
1221         return posix_lock_inode(locks_inode(filp), fl, conflock);
1222 }
1223 EXPORT_SYMBOL(posix_lock_file);
1224
1225 /**
1226  * posix_lock_inode_wait - Apply a POSIX-style lock to a file
1227  * @inode: inode of file to which lock request should be applied
1228  * @fl: The lock to be applied
1229  *
1230  * Apply a POSIX style lock request to an inode.
1231  */
1232 static int posix_lock_inode_wait(struct inode *inode, struct file_lock *fl)
1233 {
1234         int error;
1235         might_sleep ();
1236         for (;;) {
1237                 error = posix_lock_inode(inode, fl, NULL);
1238                 if (error != FILE_LOCK_DEFERRED)
1239                         break;
1240                 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
1241                 if (!error)
1242                         continue;
1243
1244                 locks_delete_block(fl);
1245                 break;
1246         }
1247         return error;
1248 }
1249
1250 #ifdef CONFIG_MANDATORY_FILE_LOCKING
1251 /**
1252  * locks_mandatory_locked - Check for an active lock
1253  * @file: the file to check
1254  *
1255  * Searches the inode's list of locks to find any POSIX locks which conflict.
1256  * This function is called from locks_verify_locked() only.
1257  */
1258 int locks_mandatory_locked(struct file *file)
1259 {
1260         int ret;
1261         struct inode *inode = locks_inode(file);
1262         struct file_lock_context *ctx;
1263         struct file_lock *fl;
1264
1265         ctx = smp_load_acquire(&inode->i_flctx);
1266         if (!ctx || list_empty_careful(&ctx->flc_posix))
1267                 return 0;
1268
1269         /*
1270          * Search the lock list for this inode for any POSIX locks.
1271          */
1272         spin_lock(&ctx->flc_lock);
1273         ret = 0;
1274         list_for_each_entry(fl, &ctx->flc_posix, fl_list) {
1275                 if (fl->fl_owner != current->files &&
1276                     fl->fl_owner != file) {
1277                         ret = -EAGAIN;
1278                         break;
1279                 }
1280         }
1281         spin_unlock(&ctx->flc_lock);
1282         return ret;
1283 }
1284
1285 /**
1286  * locks_mandatory_area - Check for a conflicting lock
1287  * @inode:      the file to check
1288  * @filp:       how the file was opened (if it was)
1289  * @start:      first byte in the file to check
1290  * @end:        lastbyte in the file to check
1291  * @type:       %F_WRLCK for a write lock, else %F_RDLCK
1292  *
1293  * Searches the inode's list of locks to find any POSIX locks which conflict.
1294  */
1295 int locks_mandatory_area(struct inode *inode, struct file *filp, loff_t start,
1296                          loff_t end, unsigned char type)
1297 {
1298         struct file_lock fl;
1299         int error;
1300         bool sleep = false;
1301
1302         locks_init_lock(&fl);
1303         fl.fl_pid = current->tgid;
1304         fl.fl_file = filp;
1305         fl.fl_flags = FL_POSIX | FL_ACCESS;
1306         if (filp && !(filp->f_flags & O_NONBLOCK))
1307                 sleep = true;
1308         fl.fl_type = type;
1309         fl.fl_start = start;
1310         fl.fl_end = end;
1311
1312         for (;;) {
1313                 if (filp) {
1314                         fl.fl_owner = filp;
1315                         fl.fl_flags &= ~FL_SLEEP;
1316                         error = posix_lock_inode(inode, &fl, NULL);
1317                         if (!error)
1318                                 break;
1319                 }
1320
1321                 if (sleep)
1322                         fl.fl_flags |= FL_SLEEP;
1323                 fl.fl_owner = current->files;
1324                 error = posix_lock_inode(inode, &fl, NULL);
1325                 if (error != FILE_LOCK_DEFERRED)
1326                         break;
1327                 error = wait_event_interruptible(fl.fl_wait, !fl.fl_next);
1328                 if (!error) {
1329                         /*
1330                          * If we've been sleeping someone might have
1331                          * changed the permissions behind our back.
1332                          */
1333                         if (__mandatory_lock(inode))
1334                                 continue;
1335                 }
1336
1337                 locks_delete_block(&fl);
1338                 break;
1339         }
1340
1341         return error;
1342 }
1343
1344 EXPORT_SYMBOL(locks_mandatory_area);
1345 #endif /* CONFIG_MANDATORY_FILE_LOCKING */
1346
1347 static void lease_clear_pending(struct file_lock *fl, int arg)
1348 {
1349         switch (arg) {
1350         case F_UNLCK:
1351                 fl->fl_flags &= ~FL_UNLOCK_PENDING;
1352                 /* fall through: */
1353         case F_RDLCK:
1354                 fl->fl_flags &= ~FL_DOWNGRADE_PENDING;
1355         }
1356 }
1357
1358 /* We already had a lease on this file; just change its type */
1359 int lease_modify(struct file_lock *fl, int arg, struct list_head *dispose)
1360 {
1361         int error = assign_type(fl, arg);
1362
1363         if (error)
1364                 return error;
1365         lease_clear_pending(fl, arg);
1366         locks_wake_up_blocks(fl);
1367         if (arg == F_UNLCK) {
1368                 struct file *filp = fl->fl_file;
1369
1370                 f_delown(filp);
1371                 filp->f_owner.signum = 0;
1372                 fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync);
1373                 if (fl->fl_fasync != NULL) {
1374                         printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync);
1375                         fl->fl_fasync = NULL;
1376                 }
1377                 locks_delete_lock_ctx(fl, dispose);
1378         }
1379         return 0;
1380 }
1381 EXPORT_SYMBOL(lease_modify);
1382
1383 static bool past_time(unsigned long then)
1384 {
1385         if (!then)
1386                 /* 0 is a special value meaning "this never expires": */
1387                 return false;
1388         return time_after(jiffies, then);
1389 }
1390
1391 static void time_out_leases(struct inode *inode, struct list_head *dispose)
1392 {
1393         struct file_lock_context *ctx = inode->i_flctx;
1394         struct file_lock *fl, *tmp;
1395
1396         lockdep_assert_held(&ctx->flc_lock);
1397
1398         list_for_each_entry_safe(fl, tmp, &ctx->flc_lease, fl_list) {
1399                 trace_time_out_leases(inode, fl);
1400                 if (past_time(fl->fl_downgrade_time))
1401                         lease_modify(fl, F_RDLCK, dispose);
1402                 if (past_time(fl->fl_break_time))
1403                         lease_modify(fl, F_UNLCK, dispose);
1404         }
1405 }
1406
1407 static bool leases_conflict(struct file_lock *lease, struct file_lock *breaker)
1408 {
1409         if ((breaker->fl_flags & FL_LAYOUT) != (lease->fl_flags & FL_LAYOUT))
1410                 return false;
1411         if ((breaker->fl_flags & FL_DELEG) && (lease->fl_flags & FL_LEASE))
1412                 return false;
1413         return locks_conflict(breaker, lease);
1414 }
1415
1416 static bool
1417 any_leases_conflict(struct inode *inode, struct file_lock *breaker)
1418 {
1419         struct file_lock_context *ctx = inode->i_flctx;
1420         struct file_lock *fl;
1421
1422         lockdep_assert_held(&ctx->flc_lock);
1423
1424         list_for_each_entry(fl, &ctx->flc_lease, fl_list) {
1425                 if (leases_conflict(fl, breaker))
1426                         return true;
1427         }
1428         return false;
1429 }
1430
1431 /**
1432  *      __break_lease   -       revoke all outstanding leases on file
1433  *      @inode: the inode of the file to return
1434  *      @mode: O_RDONLY: break only write leases; O_WRONLY or O_RDWR:
1435  *          break all leases
1436  *      @type: FL_LEASE: break leases and delegations; FL_DELEG: break
1437  *          only delegations
1438  *
1439  *      break_lease (inlined for speed) has checked there already is at least
1440  *      some kind of lock (maybe a lease) on this file.  Leases are broken on
1441  *      a call to open() or truncate().  This function can sleep unless you
1442  *      specified %O_NONBLOCK to your open().
1443  */
1444 int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
1445 {
1446         int error = 0;
1447         struct file_lock_context *ctx;
1448         struct file_lock *new_fl, *fl, *tmp;
1449         unsigned long break_time;
1450         int want_write = (mode & O_ACCMODE) != O_RDONLY;
1451         LIST_HEAD(dispose);
1452
1453         new_fl = lease_alloc(NULL, want_write ? F_WRLCK : F_RDLCK);
1454         if (IS_ERR(new_fl))
1455                 return PTR_ERR(new_fl);
1456         new_fl->fl_flags = type;
1457
1458         /* typically we will check that ctx is non-NULL before calling */
1459         ctx = smp_load_acquire(&inode->i_flctx);
1460         if (!ctx) {
1461                 WARN_ON_ONCE(1);
1462                 return error;
1463         }
1464
1465         percpu_down_read_preempt_disable(&file_rwsem);
1466         spin_lock(&ctx->flc_lock);
1467
1468         time_out_leases(inode, &dispose);
1469
1470         if (!any_leases_conflict(inode, new_fl))
1471                 goto out;
1472
1473         break_time = 0;
1474         if (lease_break_time > 0) {
1475                 break_time = jiffies + lease_break_time * HZ;
1476                 if (break_time == 0)
1477                         break_time++;   /* so that 0 means no break time */
1478         }
1479
1480         list_for_each_entry_safe(fl, tmp, &ctx->flc_lease, fl_list) {
1481                 if (!leases_conflict(fl, new_fl))
1482                         continue;
1483                 if (want_write) {
1484                         if (fl->fl_flags & FL_UNLOCK_PENDING)
1485                                 continue;
1486                         fl->fl_flags |= FL_UNLOCK_PENDING;
1487                         fl->fl_break_time = break_time;
1488                 } else {
1489                         if (lease_breaking(fl))
1490                                 continue;
1491                         fl->fl_flags |= FL_DOWNGRADE_PENDING;
1492                         fl->fl_downgrade_time = break_time;
1493                 }
1494                 if (fl->fl_lmops->lm_break(fl))
1495                         locks_delete_lock_ctx(fl, &dispose);
1496         }
1497
1498         if (list_empty(&ctx->flc_lease))
1499                 goto out;
1500
1501         if (mode & O_NONBLOCK) {
1502                 trace_break_lease_noblock(inode, new_fl);
1503                 error = -EWOULDBLOCK;
1504                 goto out;
1505         }
1506
1507 restart:
1508         fl = list_first_entry(&ctx->flc_lease, struct file_lock, fl_list);
1509         break_time = fl->fl_break_time;
1510         if (break_time != 0)
1511                 break_time -= jiffies;
1512         if (break_time == 0)
1513                 break_time++;
1514         locks_insert_block(fl, new_fl);
1515         trace_break_lease_block(inode, new_fl);
1516         spin_unlock(&ctx->flc_lock);
1517         percpu_up_read_preempt_enable(&file_rwsem);
1518
1519         locks_dispose_list(&dispose);
1520         error = wait_event_interruptible_timeout(new_fl->fl_wait,
1521                                                 !new_fl->fl_next, break_time);
1522
1523         percpu_down_read_preempt_disable(&file_rwsem);
1524         spin_lock(&ctx->flc_lock);
1525         trace_break_lease_unblock(inode, new_fl);
1526         locks_delete_block(new_fl);
1527         if (error >= 0) {
1528                 /*
1529                  * Wait for the next conflicting lease that has not been
1530                  * broken yet
1531                  */
1532                 if (error == 0)
1533                         time_out_leases(inode, &dispose);
1534                 if (any_leases_conflict(inode, new_fl))
1535                         goto restart;
1536                 error = 0;
1537         }
1538 out:
1539         spin_unlock(&ctx->flc_lock);
1540         percpu_up_read_preempt_enable(&file_rwsem);
1541         locks_dispose_list(&dispose);
1542         locks_free_lock(new_fl);
1543         return error;
1544 }
1545
1546 EXPORT_SYMBOL(__break_lease);
1547
1548 /**
1549  *      lease_get_mtime - update modified time of an inode with exclusive lease
1550  *      @inode: the inode
1551  *      @time:  pointer to a timespec which contains the last modified time
1552  *
1553  * This is to force NFS clients to flush their caches for files with
1554  * exclusive leases.  The justification is that if someone has an
1555  * exclusive lease, then they could be modifying it.
1556  */
1557 void lease_get_mtime(struct inode *inode, struct timespec64 *time)
1558 {
1559         bool has_lease = false;
1560         struct file_lock_context *ctx;
1561         struct file_lock *fl;
1562
1563         ctx = smp_load_acquire(&inode->i_flctx);
1564         if (ctx && !list_empty_careful(&ctx->flc_lease)) {
1565                 spin_lock(&ctx->flc_lock);
1566                 fl = list_first_entry_or_null(&ctx->flc_lease,
1567                                               struct file_lock, fl_list);
1568                 if (fl && (fl->fl_type == F_WRLCK))
1569                         has_lease = true;
1570                 spin_unlock(&ctx->flc_lock);
1571         }
1572
1573         if (has_lease)
1574                 *time = current_time(inode);
1575 }
1576
1577 EXPORT_SYMBOL(lease_get_mtime);
1578
1579 /**
1580  *      fcntl_getlease - Enquire what lease is currently active
1581  *      @filp: the file
1582  *
1583  *      The value returned by this function will be one of
1584  *      (if no lease break is pending):
1585  *
1586  *      %F_RDLCK to indicate a shared lease is held.
1587  *
1588  *      %F_WRLCK to indicate an exclusive lease is held.
1589  *
1590  *      %F_UNLCK to indicate no lease is held.
1591  *
1592  *      (if a lease break is pending):
1593  *
1594  *      %F_RDLCK to indicate an exclusive lease needs to be
1595  *              changed to a shared lease (or removed).
1596  *
1597  *      %F_UNLCK to indicate the lease needs to be removed.
1598  *
1599  *      XXX: sfr & willy disagree over whether F_INPROGRESS
1600  *      should be returned to userspace.
1601  */
1602 int fcntl_getlease(struct file *filp)
1603 {
1604         struct file_lock *fl;
1605         struct inode *inode = locks_inode(filp);
1606         struct file_lock_context *ctx;
1607         int type = F_UNLCK;
1608         LIST_HEAD(dispose);
1609
1610         ctx = smp_load_acquire(&inode->i_flctx);
1611         if (ctx && !list_empty_careful(&ctx->flc_lease)) {
1612                 percpu_down_read_preempt_disable(&file_rwsem);
1613                 spin_lock(&ctx->flc_lock);
1614                 time_out_leases(inode, &dispose);
1615                 list_for_each_entry(fl, &ctx->flc_lease, fl_list) {
1616                         if (fl->fl_file != filp)
1617                                 continue;
1618                         type = target_leasetype(fl);
1619                         break;
1620                 }
1621                 spin_unlock(&ctx->flc_lock);
1622                 percpu_up_read_preempt_enable(&file_rwsem);
1623
1624                 locks_dispose_list(&dispose);
1625         }
1626         return type;
1627 }
1628
1629 /**
1630  * check_conflicting_open - see if the given dentry points to a file that has
1631  *                          an existing open that would conflict with the
1632  *                          desired lease.
1633  * @dentry:     dentry to check
1634  * @arg:        type of lease that we're trying to acquire
1635  * @flags:      current lock flags
1636  *
1637  * Check to see if there's an existing open fd on this file that would
1638  * conflict with the lease we're trying to set.
1639  */
1640 static int
1641 check_conflicting_open(const struct dentry *dentry, const long arg, int flags)
1642 {
1643         int ret = 0;
1644         struct inode *inode = dentry->d_inode;
1645
1646         if (flags & FL_LAYOUT)
1647                 return 0;
1648
1649         if ((arg == F_RDLCK) && (atomic_read(&inode->i_writecount) > 0))
1650                 return -EAGAIN;
1651
1652         if ((arg == F_WRLCK) && ((d_count(dentry) > 1) ||
1653             (atomic_read(&inode->i_count) > 1)))
1654                 ret = -EAGAIN;
1655
1656         return ret;
1657 }
1658
1659 static int
1660 generic_add_lease(struct file *filp, long arg, struct file_lock **flp, void **priv)
1661 {
1662         struct file_lock *fl, *my_fl = NULL, *lease;
1663         struct dentry *dentry = filp->f_path.dentry;
1664         struct inode *inode = dentry->d_inode;
1665         struct file_lock_context *ctx;
1666         bool is_deleg = (*flp)->fl_flags & FL_DELEG;
1667         int error;
1668         LIST_HEAD(dispose);
1669
1670         lease = *flp;
1671         trace_generic_add_lease(inode, lease);
1672
1673         /* Note that arg is never F_UNLCK here */
1674         ctx = locks_get_lock_context(inode, arg);
1675         if (!ctx)
1676                 return -ENOMEM;
1677
1678         /*
1679          * In the delegation case we need mutual exclusion with
1680          * a number of operations that take the i_mutex.  We trylock
1681          * because delegations are an optional optimization, and if
1682          * there's some chance of a conflict--we'd rather not
1683          * bother, maybe that's a sign this just isn't a good file to
1684          * hand out a delegation on.
1685          */
1686         if (is_deleg && !inode_trylock(inode))
1687                 return -EAGAIN;
1688
1689         if (is_deleg && arg == F_WRLCK) {
1690                 /* Write delegations are not currently supported: */
1691                 inode_unlock(inode);
1692                 WARN_ON_ONCE(1);
1693                 return -EINVAL;
1694         }
1695
1696         percpu_down_read_preempt_disable(&file_rwsem);
1697         spin_lock(&ctx->flc_lock);
1698         time_out_leases(inode, &dispose);
1699         error = check_conflicting_open(dentry, arg, lease->fl_flags);
1700         if (error)
1701                 goto out;
1702
1703         /*
1704          * At this point, we know that if there is an exclusive
1705          * lease on this file, then we hold it on this filp
1706          * (otherwise our open of this file would have blocked).
1707          * And if we are trying to acquire an exclusive lease,
1708          * then the file is not open by anyone (including us)
1709          * except for this filp.
1710          */
1711         error = -EAGAIN;
1712         list_for_each_entry(fl, &ctx->flc_lease, fl_list) {
1713                 if (fl->fl_file == filp &&
1714                     fl->fl_owner == lease->fl_owner) {
1715                         my_fl = fl;
1716                         continue;
1717                 }
1718
1719                 /*
1720                  * No exclusive leases if someone else has a lease on
1721                  * this file:
1722                  */
1723                 if (arg == F_WRLCK)
1724                         goto out;
1725                 /*
1726                  * Modifying our existing lease is OK, but no getting a
1727                  * new lease if someone else is opening for write:
1728                  */
1729                 if (fl->fl_flags & FL_UNLOCK_PENDING)
1730                         goto out;
1731         }
1732
1733         if (my_fl != NULL) {
1734                 lease = my_fl;
1735                 error = lease->fl_lmops->lm_change(lease, arg, &dispose);
1736                 if (error)
1737                         goto out;
1738                 goto out_setup;
1739         }
1740
1741         error = -EINVAL;
1742         if (!leases_enable)
1743                 goto out;
1744
1745         locks_insert_lock_ctx(lease, &ctx->flc_lease);
1746         /*
1747          * The check in break_lease() is lockless. It's possible for another
1748          * open to race in after we did the earlier check for a conflicting
1749          * open but before the lease was inserted. Check again for a
1750          * conflicting open and cancel the lease if there is one.
1751          *
1752          * We also add a barrier here to ensure that the insertion of the lock
1753          * precedes these checks.
1754          */
1755         smp_mb();
1756         error = check_conflicting_open(dentry, arg, lease->fl_flags);
1757         if (error) {
1758                 locks_unlink_lock_ctx(lease);
1759                 goto out;
1760         }
1761
1762 out_setup:
1763         if (lease->fl_lmops->lm_setup)
1764                 lease->fl_lmops->lm_setup(lease, priv);
1765 out:
1766         spin_unlock(&ctx->flc_lock);
1767         percpu_up_read_preempt_enable(&file_rwsem);
1768         locks_dispose_list(&dispose);
1769         if (is_deleg)
1770                 inode_unlock(inode);
1771         if (!error && !my_fl)
1772                 *flp = NULL;
1773         return error;
1774 }
1775
1776 static int generic_delete_lease(struct file *filp, void *owner)
1777 {
1778         int error = -EAGAIN;
1779         struct file_lock *fl, *victim = NULL;
1780         struct inode *inode = locks_inode(filp);
1781         struct file_lock_context *ctx;
1782         LIST_HEAD(dispose);
1783
1784         ctx = smp_load_acquire(&inode->i_flctx);
1785         if (!ctx) {
1786                 trace_generic_delete_lease(inode, NULL);
1787                 return error;
1788         }
1789
1790         percpu_down_read_preempt_disable(&file_rwsem);
1791         spin_lock(&ctx->flc_lock);
1792         list_for_each_entry(fl, &ctx->flc_lease, fl_list) {
1793                 if (fl->fl_file == filp &&
1794                     fl->fl_owner == owner) {
1795                         victim = fl;
1796                         break;
1797                 }
1798         }
1799         trace_generic_delete_lease(inode, victim);
1800         if (victim)
1801                 error = fl->fl_lmops->lm_change(victim, F_UNLCK, &dispose);
1802         spin_unlock(&ctx->flc_lock);
1803         percpu_up_read_preempt_enable(&file_rwsem);
1804         locks_dispose_list(&dispose);
1805         return error;
1806 }
1807
1808 /**
1809  *      generic_setlease        -       sets a lease on an open file
1810  *      @filp:  file pointer
1811  *      @arg:   type of lease to obtain
1812  *      @flp:   input - file_lock to use, output - file_lock inserted
1813  *      @priv:  private data for lm_setup (may be NULL if lm_setup
1814  *              doesn't require it)
1815  *
1816  *      The (input) flp->fl_lmops->lm_break function is required
1817  *      by break_lease().
1818  */
1819 int generic_setlease(struct file *filp, long arg, struct file_lock **flp,
1820                         void **priv)
1821 {
1822         struct inode *inode = locks_inode(filp);
1823         int error;
1824
1825         if ((!uid_eq(current_fsuid(), inode->i_uid)) && !capable(CAP_LEASE))
1826                 return -EACCES;
1827         if (!S_ISREG(inode->i_mode))
1828                 return -EINVAL;
1829         error = security_file_lock(filp, arg);
1830         if (error)
1831                 return error;
1832
1833         switch (arg) {
1834         case F_UNLCK:
1835                 return generic_delete_lease(filp, *priv);
1836         case F_RDLCK:
1837         case F_WRLCK:
1838                 if (!(*flp)->fl_lmops->lm_break) {
1839                         WARN_ON_ONCE(1);
1840                         return -ENOLCK;
1841                 }
1842
1843                 return generic_add_lease(filp, arg, flp, priv);
1844         default:
1845                 return -EINVAL;
1846         }
1847 }
1848 EXPORT_SYMBOL(generic_setlease);
1849
1850 /**
1851  * vfs_setlease        -       sets a lease on an open file
1852  * @filp:       file pointer
1853  * @arg:        type of lease to obtain
1854  * @lease:      file_lock to use when adding a lease
1855  * @priv:       private info for lm_setup when adding a lease (may be
1856  *              NULL if lm_setup doesn't require it)
1857  *
1858  * Call this to establish a lease on the file. The "lease" argument is not
1859  * used for F_UNLCK requests and may be NULL. For commands that set or alter
1860  * an existing lease, the ``(*lease)->fl_lmops->lm_break`` operation must be
1861  * set; if not, this function will return -ENOLCK (and generate a scary-looking
1862  * stack trace).
1863  *
1864  * The "priv" pointer is passed directly to the lm_setup function as-is. It
1865  * may be NULL if the lm_setup operation doesn't require it.
1866  */
1867 int
1868 vfs_setlease(struct file *filp, long arg, struct file_lock **lease, void **priv)
1869 {
1870         if (filp->f_op->setlease)
1871                 return filp->f_op->setlease(filp, arg, lease, priv);
1872         else
1873                 return generic_setlease(filp, arg, lease, priv);
1874 }
1875 EXPORT_SYMBOL_GPL(vfs_setlease);
1876
1877 static int do_fcntl_add_lease(unsigned int fd, struct file *filp, long arg)
1878 {
1879         struct file_lock *fl;
1880         struct fasync_struct *new;
1881         int error;
1882
1883         fl = lease_alloc(filp, arg);
1884         if (IS_ERR(fl))
1885                 return PTR_ERR(fl);
1886
1887         new = fasync_alloc();
1888         if (!new) {
1889                 locks_free_lock(fl);
1890                 return -ENOMEM;
1891         }
1892         new->fa_fd = fd;
1893
1894         error = vfs_setlease(filp, arg, &fl, (void **)&new);
1895         if (fl)
1896                 locks_free_lock(fl);
1897         if (new)
1898                 fasync_free(new);
1899         return error;
1900 }
1901
1902 /**
1903  *      fcntl_setlease  -       sets a lease on an open file
1904  *      @fd: open file descriptor
1905  *      @filp: file pointer
1906  *      @arg: type of lease to obtain
1907  *
1908  *      Call this fcntl to establish a lease on the file.
1909  *      Note that you also need to call %F_SETSIG to
1910  *      receive a signal when the lease is broken.
1911  */
1912 int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
1913 {
1914         if (arg == F_UNLCK)
1915                 return vfs_setlease(filp, F_UNLCK, NULL, (void **)&filp);
1916         return do_fcntl_add_lease(fd, filp, arg);
1917 }
1918
1919 /**
1920  * flock_lock_inode_wait - Apply a FLOCK-style lock to a file
1921  * @inode: inode of the file to apply to
1922  * @fl: The lock to be applied
1923  *
1924  * Apply a FLOCK style lock request to an inode.
1925  */
1926 static int flock_lock_inode_wait(struct inode *inode, struct file_lock *fl)
1927 {
1928         int error;
1929         might_sleep();
1930         for (;;) {
1931                 error = flock_lock_inode(inode, fl);
1932                 if (error != FILE_LOCK_DEFERRED)
1933                         break;
1934                 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
1935                 if (!error)
1936                         continue;
1937
1938                 locks_delete_block(fl);
1939                 break;
1940         }
1941         return error;
1942 }
1943
1944 /**
1945  * locks_lock_inode_wait - Apply a lock to an inode
1946  * @inode: inode of the file to apply to
1947  * @fl: The lock to be applied
1948  *
1949  * Apply a POSIX or FLOCK style lock request to an inode.
1950  */
1951 int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl)
1952 {
1953         int res = 0;
1954         switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
1955                 case FL_POSIX:
1956                         res = posix_lock_inode_wait(inode, fl);
1957                         break;
1958                 case FL_FLOCK:
1959                         res = flock_lock_inode_wait(inode, fl);
1960                         break;
1961                 default:
1962                         BUG();
1963         }
1964         return res;
1965 }
1966 EXPORT_SYMBOL(locks_lock_inode_wait);
1967
1968 /**
1969  *      sys_flock: - flock() system call.
1970  *      @fd: the file descriptor to lock.
1971  *      @cmd: the type of lock to apply.
1972  *
1973  *      Apply a %FL_FLOCK style lock to an open file descriptor.
1974  *      The @cmd can be one of:
1975  *
1976  *      - %LOCK_SH -- a shared lock.
1977  *      - %LOCK_EX -- an exclusive lock.
1978  *      - %LOCK_UN -- remove an existing lock.
1979  *      - %LOCK_MAND -- a 'mandatory' flock.
1980  *        This exists to emulate Windows Share Modes.
1981  *
1982  *      %LOCK_MAND can be combined with %LOCK_READ or %LOCK_WRITE to allow other
1983  *      processes read and write access respectively.
1984  */
1985 SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd)
1986 {
1987         struct fd f = fdget(fd);
1988         struct file_lock *lock;
1989         int can_sleep, unlock;
1990         int error;
1991
1992         error = -EBADF;
1993         if (!f.file)
1994                 goto out;
1995
1996         can_sleep = !(cmd & LOCK_NB);
1997         cmd &= ~LOCK_NB;
1998         unlock = (cmd == LOCK_UN);
1999
2000         if (!unlock && !(cmd & LOCK_MAND) &&
2001             !(f.file->f_mode & (FMODE_READ|FMODE_WRITE)))
2002                 goto out_putf;
2003
2004         lock = flock_make_lock(f.file, cmd);
2005         if (IS_ERR(lock)) {
2006                 error = PTR_ERR(lock);
2007                 goto out_putf;
2008         }
2009
2010         if (can_sleep)
2011                 lock->fl_flags |= FL_SLEEP;
2012
2013         error = security_file_lock(f.file, lock->fl_type);
2014         if (error)
2015                 goto out_free;
2016
2017         if (f.file->f_op->flock)
2018                 error = f.file->f_op->flock(f.file,
2019                                           (can_sleep) ? F_SETLKW : F_SETLK,
2020                                           lock);
2021         else
2022                 error = locks_lock_file_wait(f.file, lock);
2023
2024  out_free:
2025         locks_free_lock(lock);
2026
2027  out_putf:
2028         fdput(f);
2029  out:
2030         return error;
2031 }
2032
2033 /**
2034  * vfs_test_lock - test file byte range lock
2035  * @filp: The file to test lock for
2036  * @fl: The lock to test; also used to hold result
2037  *
2038  * Returns -ERRNO on failure.  Indicates presence of conflicting lock by
2039  * setting conf->fl_type to something other than F_UNLCK.
2040  */
2041 int vfs_test_lock(struct file *filp, struct file_lock *fl)
2042 {
2043         if (filp->f_op->lock)
2044                 return filp->f_op->lock(filp, F_GETLK, fl);
2045         posix_test_lock(filp, fl);
2046         return 0;
2047 }
2048 EXPORT_SYMBOL_GPL(vfs_test_lock);
2049
2050 /**
2051  * locks_translate_pid - translate a file_lock's fl_pid number into a namespace
2052  * @fl: The file_lock who's fl_pid should be translated
2053  * @ns: The namespace into which the pid should be translated
2054  *
2055  * Used to tranlate a fl_pid into a namespace virtual pid number
2056  */
2057 static pid_t locks_translate_pid(struct file_lock *fl, struct pid_namespace *ns)
2058 {
2059         pid_t vnr;
2060         struct pid *pid;
2061
2062         if (IS_OFDLCK(fl))
2063                 return -1;
2064         if (IS_REMOTELCK(fl))
2065                 return fl->fl_pid;
2066         /*
2067          * If the flock owner process is dead and its pid has been already
2068          * freed, the translation below won't work, but we still want to show
2069          * flock owner pid number in init pidns.
2070          */
2071         if (ns == &init_pid_ns)
2072                 return (pid_t)fl->fl_pid;
2073
2074         rcu_read_lock();
2075         pid = find_pid_ns(fl->fl_pid, &init_pid_ns);
2076         vnr = pid_nr_ns(pid, ns);
2077         rcu_read_unlock();
2078         return vnr;
2079 }
2080
2081 static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl)
2082 {
2083         flock->l_pid = locks_translate_pid(fl, task_active_pid_ns(current));
2084 #if BITS_PER_LONG == 32
2085         /*
2086          * Make sure we can represent the posix lock via
2087          * legacy 32bit flock.
2088          */
2089         if (fl->fl_start > OFFT_OFFSET_MAX)
2090                 return -EOVERFLOW;
2091         if (fl->fl_end != OFFSET_MAX && fl->fl_end > OFFT_OFFSET_MAX)
2092                 return -EOVERFLOW;
2093 #endif
2094         flock->l_start = fl->fl_start;
2095         flock->l_len = fl->fl_end == OFFSET_MAX ? 0 :
2096                 fl->fl_end - fl->fl_start + 1;
2097         flock->l_whence = 0;
2098         flock->l_type = fl->fl_type;
2099         return 0;
2100 }
2101
2102 #if BITS_PER_LONG == 32
2103 static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl)
2104 {
2105         flock->l_pid = locks_translate_pid(fl, task_active_pid_ns(current));
2106         flock->l_start = fl->fl_start;
2107         flock->l_len = fl->fl_end == OFFSET_MAX ? 0 :
2108                 fl->fl_end - fl->fl_start + 1;
2109         flock->l_whence = 0;
2110         flock->l_type = fl->fl_type;
2111 }
2112 #endif
2113
2114 /* Report the first existing lock that would conflict with l.
2115  * This implements the F_GETLK command of fcntl().
2116  */
2117 int fcntl_getlk(struct file *filp, unsigned int cmd, struct flock *flock)
2118 {
2119         struct file_lock *fl;
2120         int error;
2121
2122         fl = locks_alloc_lock();
2123         if (fl == NULL)
2124                 return -ENOMEM;
2125         error = -EINVAL;
2126         if (flock->l_type != F_RDLCK && flock->l_type != F_WRLCK)
2127                 goto out;
2128
2129         error = flock_to_posix_lock(filp, fl, flock);
2130         if (error)
2131                 goto out;
2132
2133         if (cmd == F_OFD_GETLK) {
2134                 error = -EINVAL;
2135                 if (flock->l_pid != 0)
2136                         goto out;
2137
2138                 cmd = F_GETLK;
2139                 fl->fl_flags |= FL_OFDLCK;
2140                 fl->fl_owner = filp;
2141         }
2142
2143         error = vfs_test_lock(filp, fl);
2144         if (error)
2145                 goto out;
2146  
2147         flock->l_type = fl->fl_type;
2148         if (fl->fl_type != F_UNLCK) {
2149                 error = posix_lock_to_flock(flock, fl);
2150                 if (error)
2151                         goto out;
2152         }
2153 out:
2154         locks_free_lock(fl);
2155         return error;
2156 }
2157
2158 /**
2159  * vfs_lock_file - file byte range lock
2160  * @filp: The file to apply the lock to
2161  * @cmd: type of locking operation (F_SETLK, F_GETLK, etc.)
2162  * @fl: The lock to be applied
2163  * @conf: Place to return a copy of the conflicting lock, if found.
2164  *
2165  * A caller that doesn't care about the conflicting lock may pass NULL
2166  * as the final argument.
2167  *
2168  * If the filesystem defines a private ->lock() method, then @conf will
2169  * be left unchanged; so a caller that cares should initialize it to
2170  * some acceptable default.
2171  *
2172  * To avoid blocking kernel daemons, such as lockd, that need to acquire POSIX
2173  * locks, the ->lock() interface may return asynchronously, before the lock has
2174  * been granted or denied by the underlying filesystem, if (and only if)
2175  * lm_grant is set. Callers expecting ->lock() to return asynchronously
2176  * will only use F_SETLK, not F_SETLKW; they will set FL_SLEEP if (and only if)
2177  * the request is for a blocking lock. When ->lock() does return asynchronously,
2178  * it must return FILE_LOCK_DEFERRED, and call ->lm_grant() when the lock
2179  * request completes.
2180  * If the request is for non-blocking lock the file system should return
2181  * FILE_LOCK_DEFERRED then try to get the lock and call the callback routine
2182  * with the result. If the request timed out the callback routine will return a
2183  * nonzero return code and the file system should release the lock. The file
2184  * system is also responsible to keep a corresponding posix lock when it
2185  * grants a lock so the VFS can find out which locks are locally held and do
2186  * the correct lock cleanup when required.
2187  * The underlying filesystem must not drop the kernel lock or call
2188  * ->lm_grant() before returning to the caller with a FILE_LOCK_DEFERRED
2189  * return code.
2190  */
2191 int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf)
2192 {
2193         if (filp->f_op->lock)
2194                 return filp->f_op->lock(filp, cmd, fl);
2195         else
2196                 return posix_lock_file(filp, fl, conf);
2197 }
2198 EXPORT_SYMBOL_GPL(vfs_lock_file);
2199
2200 static int do_lock_file_wait(struct file *filp, unsigned int cmd,
2201                              struct file_lock *fl)
2202 {
2203         int error;
2204
2205         error = security_file_lock(filp, fl->fl_type);
2206         if (error)
2207                 return error;
2208
2209         for (;;) {
2210                 error = vfs_lock_file(filp, cmd, fl, NULL);
2211                 if (error != FILE_LOCK_DEFERRED)
2212                         break;
2213                 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
2214                 if (!error)
2215                         continue;
2216
2217                 locks_delete_block(fl);
2218                 break;
2219         }
2220
2221         return error;
2222 }
2223
2224 /* Ensure that fl->fl_file has compatible f_mode for F_SETLK calls */
2225 static int
2226 check_fmode_for_setlk(struct file_lock *fl)
2227 {
2228         switch (fl->fl_type) {
2229         case F_RDLCK:
2230                 if (!(fl->fl_file->f_mode & FMODE_READ))
2231                         return -EBADF;
2232                 break;
2233         case F_WRLCK:
2234                 if (!(fl->fl_file->f_mode & FMODE_WRITE))
2235                         return -EBADF;
2236         }
2237         return 0;
2238 }
2239
2240 /* Apply the lock described by l to an open file descriptor.
2241  * This implements both the F_SETLK and F_SETLKW commands of fcntl().
2242  */
2243 int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd,
2244                 struct flock *flock)
2245 {
2246         struct file_lock *file_lock = locks_alloc_lock();
2247         struct inode *inode = locks_inode(filp);
2248         struct file *f;
2249         int error;
2250
2251         if (file_lock == NULL)
2252                 return -ENOLCK;
2253
2254         /* Don't allow mandatory locks on files that may be memory mapped
2255          * and shared.
2256          */
2257         if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) {
2258                 error = -EAGAIN;
2259                 goto out;
2260         }
2261
2262         error = flock_to_posix_lock(filp, file_lock, flock);
2263         if (error)
2264                 goto out;
2265
2266         error = check_fmode_for_setlk(file_lock);
2267         if (error)
2268                 goto out;
2269
2270         /*
2271          * If the cmd is requesting file-private locks, then set the
2272          * FL_OFDLCK flag and override the owner.
2273          */
2274         switch (cmd) {
2275         case F_OFD_SETLK:
2276                 error = -EINVAL;
2277                 if (flock->l_pid != 0)
2278                         goto out;
2279
2280                 cmd = F_SETLK;
2281                 file_lock->fl_flags |= FL_OFDLCK;
2282                 file_lock->fl_owner = filp;
2283                 break;
2284         case F_OFD_SETLKW:
2285                 error = -EINVAL;
2286                 if (flock->l_pid != 0)
2287                         goto out;
2288
2289                 cmd = F_SETLKW;
2290                 file_lock->fl_flags |= FL_OFDLCK;
2291                 file_lock->fl_owner = filp;
2292                 /* Fallthrough */
2293         case F_SETLKW:
2294                 file_lock->fl_flags |= FL_SLEEP;
2295         }
2296
2297         error = do_lock_file_wait(filp, cmd, file_lock);
2298
2299         /*
2300          * Attempt to detect a close/fcntl race and recover by releasing the
2301          * lock that was just acquired. There is no need to do that when we're
2302          * unlocking though, or for OFD locks.
2303          */
2304         if (!error && file_lock->fl_type != F_UNLCK &&
2305             !(file_lock->fl_flags & FL_OFDLCK)) {
2306                 /*
2307                  * We need that spin_lock here - it prevents reordering between
2308                  * update of i_flctx->flc_posix and check for it done in
2309                  * close(). rcu_read_lock() wouldn't do.
2310                  */
2311                 spin_lock(&current->files->file_lock);
2312                 f = fcheck(fd);
2313                 spin_unlock(&current->files->file_lock);
2314                 if (f != filp) {
2315                         file_lock->fl_type = F_UNLCK;
2316                         error = do_lock_file_wait(filp, cmd, file_lock);
2317                         WARN_ON_ONCE(error);
2318                         error = -EBADF;
2319                 }
2320         }
2321 out:
2322         trace_fcntl_setlk(inode, file_lock, error);
2323         locks_free_lock(file_lock);
2324         return error;
2325 }
2326
2327 #if BITS_PER_LONG == 32
2328 /* Report the first existing lock that would conflict with l.
2329  * This implements the F_GETLK command of fcntl().
2330  */
2331 int fcntl_getlk64(struct file *filp, unsigned int cmd, struct flock64 *flock)
2332 {
2333         struct file_lock *fl;
2334         int error;
2335
2336         fl = locks_alloc_lock();
2337         if (fl == NULL)
2338                 return -ENOMEM;
2339
2340         error = -EINVAL;
2341         if (flock->l_type != F_RDLCK && flock->l_type != F_WRLCK)
2342                 goto out;
2343
2344         error = flock64_to_posix_lock(filp, fl, flock);
2345         if (error)
2346                 goto out;
2347
2348         if (cmd == F_OFD_GETLK) {
2349                 error = -EINVAL;
2350                 if (flock->l_pid != 0)
2351                         goto out;
2352
2353                 cmd = F_GETLK64;
2354                 fl->fl_flags |= FL_OFDLCK;
2355                 fl->fl_owner = filp;
2356         }
2357
2358         error = vfs_test_lock(filp, fl);
2359         if (error)
2360                 goto out;
2361
2362         flock->l_type = fl->fl_type;
2363         if (fl->fl_type != F_UNLCK)
2364                 posix_lock_to_flock64(flock, fl);
2365
2366 out:
2367         locks_free_lock(fl);
2368         return error;
2369 }
2370
2371 /* Apply the lock described by l to an open file descriptor.
2372  * This implements both the F_SETLK and F_SETLKW commands of fcntl().
2373  */
2374 int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd,
2375                 struct flock64 *flock)
2376 {
2377         struct file_lock *file_lock = locks_alloc_lock();
2378         struct inode *inode = locks_inode(filp);
2379         struct file *f;
2380         int error;
2381
2382         if (file_lock == NULL)
2383                 return -ENOLCK;
2384
2385         /* Don't allow mandatory locks on files that may be memory mapped
2386          * and shared.
2387          */
2388         if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) {
2389                 error = -EAGAIN;
2390                 goto out;
2391         }
2392
2393         error = flock64_to_posix_lock(filp, file_lock, flock);
2394         if (error)
2395                 goto out;
2396
2397         error = check_fmode_for_setlk(file_lock);
2398         if (error)
2399                 goto out;
2400
2401         /*
2402          * If the cmd is requesting file-private locks, then set the
2403          * FL_OFDLCK flag and override the owner.
2404          */
2405         switch (cmd) {
2406         case F_OFD_SETLK:
2407                 error = -EINVAL;
2408                 if (flock->l_pid != 0)
2409                         goto out;
2410
2411                 cmd = F_SETLK64;
2412                 file_lock->fl_flags |= FL_OFDLCK;
2413                 file_lock->fl_owner = filp;
2414                 break;
2415         case F_OFD_SETLKW:
2416                 error = -EINVAL;
2417                 if (flock->l_pid != 0)
2418                         goto out;
2419
2420                 cmd = F_SETLKW64;
2421                 file_lock->fl_flags |= FL_OFDLCK;
2422                 file_lock->fl_owner = filp;
2423                 /* Fallthrough */
2424         case F_SETLKW64:
2425                 file_lock->fl_flags |= FL_SLEEP;
2426         }
2427
2428         error = do_lock_file_wait(filp, cmd, file_lock);
2429
2430         /*
2431          * Attempt to detect a close/fcntl race and recover by releasing the
2432          * lock that was just acquired. There is no need to do that when we're
2433          * unlocking though, or for OFD locks.
2434          */
2435         if (!error && file_lock->fl_type != F_UNLCK &&
2436             !(file_lock->fl_flags & FL_OFDLCK)) {
2437                 /*
2438                  * We need that spin_lock here - it prevents reordering between
2439                  * update of i_flctx->flc_posix and check for it done in
2440                  * close(). rcu_read_lock() wouldn't do.
2441                  */
2442                 spin_lock(&current->files->file_lock);
2443                 f = fcheck(fd);
2444                 spin_unlock(&current->files->file_lock);
2445                 if (f != filp) {
2446                         file_lock->fl_type = F_UNLCK;
2447                         error = do_lock_file_wait(filp, cmd, file_lock);
2448                         WARN_ON_ONCE(error);
2449                         error = -EBADF;
2450                 }
2451         }
2452 out:
2453         locks_free_lock(file_lock);
2454         return error;
2455 }
2456 #endif /* BITS_PER_LONG == 32 */
2457
2458 /*
2459  * This function is called when the file is being removed
2460  * from the task's fd array.  POSIX locks belonging to this task
2461  * are deleted at this time.
2462  */
2463 void locks_remove_posix(struct file *filp, fl_owner_t owner)
2464 {
2465         int error;
2466         struct inode *inode = locks_inode(filp);
2467         struct file_lock lock;
2468         struct file_lock_context *ctx;
2469
2470         /*
2471          * If there are no locks held on this file, we don't need to call
2472          * posix_lock_file().  Another process could be setting a lock on this
2473          * file at the same time, but we wouldn't remove that lock anyway.
2474          */
2475         ctx =  smp_load_acquire(&inode->i_flctx);
2476         if (!ctx || list_empty(&ctx->flc_posix))
2477                 return;
2478
2479         lock.fl_type = F_UNLCK;
2480         lock.fl_flags = FL_POSIX | FL_CLOSE;
2481         lock.fl_start = 0;
2482         lock.fl_end = OFFSET_MAX;
2483         lock.fl_owner = owner;
2484         lock.fl_pid = current->tgid;
2485         lock.fl_file = filp;
2486         lock.fl_ops = NULL;
2487         lock.fl_lmops = NULL;
2488
2489         error = vfs_lock_file(filp, F_SETLK, &lock, NULL);
2490
2491         if (lock.fl_ops && lock.fl_ops->fl_release_private)
2492                 lock.fl_ops->fl_release_private(&lock);
2493         trace_locks_remove_posix(inode, &lock, error);
2494 }
2495
2496 EXPORT_SYMBOL(locks_remove_posix);
2497
2498 /* The i_flctx must be valid when calling into here */
2499 static void
2500 locks_remove_flock(struct file *filp, struct file_lock_context *flctx)
2501 {
2502         struct file_lock fl = {
2503                 .fl_owner = filp,
2504                 .fl_pid = current->tgid,
2505                 .fl_file = filp,
2506                 .fl_flags = FL_FLOCK | FL_CLOSE,
2507                 .fl_type = F_UNLCK,
2508                 .fl_end = OFFSET_MAX,
2509         };
2510         struct inode *inode = locks_inode(filp);
2511
2512         if (list_empty(&flctx->flc_flock))
2513                 return;
2514
2515         if (filp->f_op->flock)
2516                 filp->f_op->flock(filp, F_SETLKW, &fl);
2517         else
2518                 flock_lock_inode(inode, &fl);
2519
2520         if (fl.fl_ops && fl.fl_ops->fl_release_private)
2521                 fl.fl_ops->fl_release_private(&fl);
2522 }
2523
2524 /* The i_flctx must be valid when calling into here */
2525 static void
2526 locks_remove_lease(struct file *filp, struct file_lock_context *ctx)
2527 {
2528         struct file_lock *fl, *tmp;
2529         LIST_HEAD(dispose);
2530
2531         if (list_empty(&ctx->flc_lease))
2532                 return;
2533
2534         percpu_down_read_preempt_disable(&file_rwsem);
2535         spin_lock(&ctx->flc_lock);
2536         list_for_each_entry_safe(fl, tmp, &ctx->flc_lease, fl_list)
2537                 if (filp == fl->fl_file)
2538                         lease_modify(fl, F_UNLCK, &dispose);
2539         spin_unlock(&ctx->flc_lock);
2540         percpu_up_read_preempt_enable(&file_rwsem);
2541
2542         locks_dispose_list(&dispose);
2543 }
2544
2545 /*
2546  * This function is called on the last close of an open file.
2547  */
2548 void locks_remove_file(struct file *filp)
2549 {
2550         struct file_lock_context *ctx;
2551
2552         ctx = smp_load_acquire(&locks_inode(filp)->i_flctx);
2553         if (!ctx)
2554                 return;
2555
2556         /* remove any OFD locks */
2557         locks_remove_posix(filp, filp);
2558
2559         /* remove flock locks */
2560         locks_remove_flock(filp, ctx);
2561
2562         /* remove any leases */
2563         locks_remove_lease(filp, ctx);
2564
2565         spin_lock(&ctx->flc_lock);
2566         locks_check_ctx_file_list(filp, &ctx->flc_posix, "POSIX");
2567         locks_check_ctx_file_list(filp, &ctx->flc_flock, "FLOCK");
2568         locks_check_ctx_file_list(filp, &ctx->flc_lease, "LEASE");
2569         spin_unlock(&ctx->flc_lock);
2570 }
2571
2572 /**
2573  *      posix_unblock_lock - stop waiting for a file lock
2574  *      @waiter: the lock which was waiting
2575  *
2576  *      lockd needs to block waiting for locks.
2577  */
2578 int
2579 posix_unblock_lock(struct file_lock *waiter)
2580 {
2581         int status = 0;
2582
2583         spin_lock(&blocked_lock_lock);
2584         if (waiter->fl_next)
2585                 __locks_delete_block(waiter);
2586         else
2587                 status = -ENOENT;
2588         spin_unlock(&blocked_lock_lock);
2589         return status;
2590 }
2591 EXPORT_SYMBOL(posix_unblock_lock);
2592
2593 /**
2594  * vfs_cancel_lock - file byte range unblock lock
2595  * @filp: The file to apply the unblock to
2596  * @fl: The lock to be unblocked
2597  *
2598  * Used by lock managers to cancel blocked requests
2599  */
2600 int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
2601 {
2602         if (filp->f_op->lock)
2603                 return filp->f_op->lock(filp, F_CANCELLK, fl);
2604         return 0;
2605 }
2606
2607 EXPORT_SYMBOL_GPL(vfs_cancel_lock);
2608
2609 #ifdef CONFIG_PROC_FS
2610 #include <linux/proc_fs.h>
2611 #include <linux/seq_file.h>
2612
2613 struct locks_iterator {
2614         int     li_cpu;
2615         loff_t  li_pos;
2616 };
2617
2618 static void lock_get_status(struct seq_file *f, struct file_lock *fl,
2619                             loff_t id, char *pfx)
2620 {
2621         struct inode *inode = NULL;
2622         unsigned int fl_pid;
2623         struct pid_namespace *proc_pidns = file_inode(f->file)->i_sb->s_fs_info;
2624
2625         fl_pid = locks_translate_pid(fl, proc_pidns);
2626         /*
2627          * If lock owner is dead (and pid is freed) or not visible in current
2628          * pidns, zero is shown as a pid value. Check lock info from
2629          * init_pid_ns to get saved lock pid value.
2630          */
2631
2632         if (fl->fl_file != NULL)
2633                 inode = locks_inode(fl->fl_file);
2634
2635         seq_printf(f, "%lld:%s ", id, pfx);
2636         if (IS_POSIX(fl)) {
2637                 if (fl->fl_flags & FL_ACCESS)
2638                         seq_puts(f, "ACCESS");
2639                 else if (IS_OFDLCK(fl))
2640                         seq_puts(f, "OFDLCK");
2641                 else
2642                         seq_puts(f, "POSIX ");
2643
2644                 seq_printf(f, " %s ",
2645                              (inode == NULL) ? "*NOINODE*" :
2646                              mandatory_lock(inode) ? "MANDATORY" : "ADVISORY ");
2647         } else if (IS_FLOCK(fl)) {
2648                 if (fl->fl_type & LOCK_MAND) {
2649                         seq_puts(f, "FLOCK  MSNFS     ");
2650                 } else {
2651                         seq_puts(f, "FLOCK  ADVISORY  ");
2652                 }
2653         } else if (IS_LEASE(fl)) {
2654                 if (fl->fl_flags & FL_DELEG)
2655                         seq_puts(f, "DELEG  ");
2656                 else
2657                         seq_puts(f, "LEASE  ");
2658
2659                 if (lease_breaking(fl))
2660                         seq_puts(f, "BREAKING  ");
2661                 else if (fl->fl_file)
2662                         seq_puts(f, "ACTIVE    ");
2663                 else
2664                         seq_puts(f, "BREAKER   ");
2665         } else {
2666                 seq_puts(f, "UNKNOWN UNKNOWN  ");
2667         }
2668         if (fl->fl_type & LOCK_MAND) {
2669                 seq_printf(f, "%s ",
2670                                (fl->fl_type & LOCK_READ)
2671                                ? (fl->fl_type & LOCK_WRITE) ? "RW   " : "READ "
2672                                : (fl->fl_type & LOCK_WRITE) ? "WRITE" : "NONE ");
2673         } else {
2674                 seq_printf(f, "%s ",
2675                                (lease_breaking(fl))
2676                                ? (fl->fl_type == F_UNLCK) ? "UNLCK" : "READ "
2677                                : (fl->fl_type == F_WRLCK) ? "WRITE" : "READ ");
2678         }
2679         if (inode) {
2680                 /* userspace relies on this representation of dev_t */
2681                 seq_printf(f, "%d %02x:%02x:%ld ", fl_pid,
2682                                 MAJOR(inode->i_sb->s_dev),
2683                                 MINOR(inode->i_sb->s_dev), inode->i_ino);
2684         } else {
2685                 seq_printf(f, "%d <none>:0 ", fl_pid);
2686         }
2687         if (IS_POSIX(fl)) {
2688                 if (fl->fl_end == OFFSET_MAX)
2689                         seq_printf(f, "%Ld EOF\n", fl->fl_start);
2690                 else
2691                         seq_printf(f, "%Ld %Ld\n", fl->fl_start, fl->fl_end);
2692         } else {
2693                 seq_puts(f, "0 EOF\n");
2694         }
2695 }
2696
2697 static int locks_show(struct seq_file *f, void *v)
2698 {
2699         struct locks_iterator *iter = f->private;
2700         struct file_lock *fl, *bfl;
2701         struct pid_namespace *proc_pidns = file_inode(f->file)->i_sb->s_fs_info;
2702
2703         fl = hlist_entry(v, struct file_lock, fl_link);
2704
2705         if (locks_translate_pid(fl, proc_pidns) == 0)
2706                 return 0;
2707
2708         lock_get_status(f, fl, iter->li_pos, "");
2709
2710         list_for_each_entry(bfl, &fl->fl_block, fl_block)
2711                 lock_get_status(f, bfl, iter->li_pos, " ->");
2712
2713         return 0;
2714 }
2715
2716 static void __show_fd_locks(struct seq_file *f,
2717                         struct list_head *head, int *id,
2718                         struct file *filp, struct files_struct *files)
2719 {
2720         struct file_lock *fl;
2721
2722         list_for_each_entry(fl, head, fl_list) {
2723
2724                 if (filp != fl->fl_file)
2725                         continue;
2726                 if (fl->fl_owner != files &&
2727                     fl->fl_owner != filp)
2728                         continue;
2729
2730                 (*id)++;
2731                 seq_puts(f, "lock:\t");
2732                 lock_get_status(f, fl, *id, "");
2733         }
2734 }
2735
2736 void show_fd_locks(struct seq_file *f,
2737                   struct file *filp, struct files_struct *files)
2738 {
2739         struct inode *inode = locks_inode(filp);
2740         struct file_lock_context *ctx;
2741         int id = 0;
2742
2743         ctx = smp_load_acquire(&inode->i_flctx);
2744         if (!ctx)
2745                 return;
2746
2747         spin_lock(&ctx->flc_lock);
2748         __show_fd_locks(f, &ctx->flc_flock, &id, filp, files);
2749         __show_fd_locks(f, &ctx->flc_posix, &id, filp, files);
2750         __show_fd_locks(f, &ctx->flc_lease, &id, filp, files);
2751         spin_unlock(&ctx->flc_lock);
2752 }
2753
2754 static void *locks_start(struct seq_file *f, loff_t *pos)
2755         __acquires(&blocked_lock_lock)
2756 {
2757         struct locks_iterator *iter = f->private;
2758
2759         iter->li_pos = *pos + 1;
2760         percpu_down_write(&file_rwsem);
2761         spin_lock(&blocked_lock_lock);
2762         return seq_hlist_start_percpu(&file_lock_list.hlist, &iter->li_cpu, *pos);
2763 }
2764
2765 static void *locks_next(struct seq_file *f, void *v, loff_t *pos)
2766 {
2767         struct locks_iterator *iter = f->private;
2768
2769         ++iter->li_pos;
2770         return seq_hlist_next_percpu(v, &file_lock_list.hlist, &iter->li_cpu, pos);
2771 }
2772
2773 static void locks_stop(struct seq_file *f, void *v)
2774         __releases(&blocked_lock_lock)
2775 {
2776         spin_unlock(&blocked_lock_lock);
2777         percpu_up_write(&file_rwsem);
2778 }
2779
2780 static const struct seq_operations locks_seq_operations = {
2781         .start  = locks_start,
2782         .next   = locks_next,
2783         .stop   = locks_stop,
2784         .show   = locks_show,
2785 };
2786
2787 static int __init proc_locks_init(void)
2788 {
2789         proc_create_seq_private("locks", 0, NULL, &locks_seq_operations,
2790                         sizeof(struct locks_iterator), NULL);
2791         return 0;
2792 }
2793 fs_initcall(proc_locks_init);
2794 #endif
2795
2796 static int __init filelock_init(void)
2797 {
2798         int i;
2799
2800         flctx_cache = kmem_cache_create("file_lock_ctx",
2801                         sizeof(struct file_lock_context), 0, SLAB_PANIC, NULL);
2802
2803         filelock_cache = kmem_cache_create("file_lock_cache",
2804                         sizeof(struct file_lock), 0, SLAB_PANIC, NULL);
2805
2806
2807         for_each_possible_cpu(i) {
2808                 struct file_lock_list_struct *fll = per_cpu_ptr(&file_lock_list, i);
2809
2810                 spin_lock_init(&fll->lock);
2811                 INIT_HLIST_HEAD(&fll->hlist);
2812         }
2813
2814         return 0;
2815 }
2816
2817 core_initcall(filelock_init);