~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/locks.c

Version: ~ [ linux-5.1-rc1 ] ~ [ linux-5.0.3 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.30 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.107 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.164 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.176 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.136 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp