blob: 84e269fc4c6936bc8c4a5ae66d6e8df5dbd9c141 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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.
Paul Bolle395cf962011-08-15 02:02:26 +020063 * See 'Documentation/filesystems/mandatory-locking.txt' for details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 * Andy Walker (andy@lysaker.kvaerner.no), April 06, 1996.
65 *
66 * Don't allow mandatory locks on mmap()'ed files. Added simple functions to
67 * check if a file has mandatory locks, used by mmap(), open() and creat() to
68 * see if system call should be rejected. Ref. HP-UX/SunOS/Solaris Reference
69 * Manual, Section 2.
70 * Andy Walker (andy@lysaker.kvaerner.no), April 09, 1996.
71 *
72 * Tidied up block list handling. Added '/proc/locks' interface.
73 * Andy Walker (andy@lysaker.kvaerner.no), April 24, 1996.
74 *
75 * Fixed deadlock condition for pathological code that mixes calls to
76 * flock() and fcntl().
77 * Andy Walker (andy@lysaker.kvaerner.no), April 29, 1996.
78 *
79 * Allow only one type of locking scheme (FL_POSIX or FL_FLOCK) to be in use
80 * for a given file at a time. Changed the CONFIG_LOCK_MANDATORY scheme to
81 * guarantee sensible behaviour in the case where file system modules might
82 * be compiled with different options than the kernel itself.
83 * Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996.
84 *
85 * Added a couple of missing wake_up() calls. Thanks to Thomas Meckel
86 * (Thomas.Meckel@mni.fh-giessen.de) for spotting this.
87 * Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996.
88 *
89 * Changed FL_POSIX locks to use the block list in the same way as FL_FLOCK
90 * locks. Changed process synchronisation to avoid dereferencing locks that
91 * have already been freed.
92 * Andy Walker (andy@lysaker.kvaerner.no), Sep 21, 1996.
93 *
94 * Made the block list a circular list to minimise searching in the list.
95 * Andy Walker (andy@lysaker.kvaerner.no), Sep 25, 1996.
96 *
97 * Made mandatory locking a mount option. Default is not to allow mandatory
98 * locking.
99 * Andy Walker (andy@lysaker.kvaerner.no), Oct 04, 1996.
100 *
101 * Some adaptations for NFS support.
102 * Olaf Kirch (okir@monad.swb.de), Dec 1996,
103 *
104 * Fixed /proc/locks interface so that we can't overrun the buffer we are handed.
105 * Andy Walker (andy@lysaker.kvaerner.no), May 12, 1997.
106 *
107 * Use slab allocator instead of kmalloc/kfree.
108 * Use generic list implementation from <linux/list.h>.
109 * Sped up posix_locks_deadlock by only considering blocked locks.
110 * Matthew Wilcox <willy@debian.org>, March, 2000.
111 *
112 * Leases and LOCK_MAND
113 * Matthew Wilcox <willy@debian.org>, June, 2000.
114 * Stephen Rothwell <sfr@canb.auug.org.au>, June, 2000.
115 */
116
117#include <linux/capability.h>
118#include <linux/file.h>
Al Viro9f3acc32008-04-24 07:44:08 -0400119#include <linux/fdtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120#include <linux/fs.h>
121#include <linux/init.h>
122#include <linux/module.h>
123#include <linux/security.h>
124#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125#include <linux/syscalls.h>
126#include <linux/time.h>
Dipankar Sarma4fb3a532005-09-16 19:28:13 -0700127#include <linux/rcupdate.h>
Vitaliy Gusevab1f1612008-01-17 00:07:08 +0000128#include <linux/pid_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130#include <asm/uaccess.h>
131
132#define IS_POSIX(fl) (fl->fl_flags & FL_POSIX)
133#define IS_FLOCK(fl) (fl->fl_flags & FL_FLOCK)
134#define IS_LEASE(fl) (fl->fl_flags & FL_LEASE)
135
J. Bruce Fieldsab83fa42011-07-26 20:10:51 -0400136static bool lease_breaking(struct file_lock *fl)
137{
J. Bruce Fields778fc542011-07-26 18:25:49 -0400138 return fl->fl_flags & (FL_UNLOCK_PENDING | FL_DOWNGRADE_PENDING);
139}
140
141static int target_leasetype(struct file_lock *fl)
142{
143 if (fl->fl_flags & FL_UNLOCK_PENDING)
144 return F_UNLCK;
145 if (fl->fl_flags & FL_DOWNGRADE_PENDING)
146 return F_RDLCK;
147 return fl->fl_type;
J. Bruce Fieldsab83fa42011-07-26 20:10:51 -0400148}
149
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150int leases_enable = 1;
151int lease_break_time = 45;
152
153#define for_each_lock(inode, lockp) \
154 for (lockp = &inode->i_flock; *lockp != NULL; lockp = &(*lockp)->fl_next)
155
Jeff Layton1c8c6012013-06-21 08:58:15 -0400156/*
157 * The global file_lock_list is only used for displaying /proc/locks. Protected
158 * by the file_lock_lock.
159 */
Christoph Hellwig26bcbf92006-03-20 13:44:40 -0500160static LIST_HEAD(file_lock_list);
Jeff Layton88974692013-06-21 08:58:14 -0400161
Jeff Layton1c8c6012013-06-21 08:58:15 -0400162/*
163 * The blocked_list is used to find POSIX lock loops for deadlock detection.
164 * Protected by file_lock_lock.
165 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166static LIST_HEAD(blocked_list);
Jeff Layton88974692013-06-21 08:58:14 -0400167
Jeff Layton1c8c6012013-06-21 08:58:15 -0400168/*
169 * This lock protects the blocked_list, and the file_lock_list. Generally, if
170 * you're accessing one of those lists, you want to be holding this lock.
171 *
172 * In addition, it also protects the fl->fl_block list, and the fl->fl_next
173 * pointer for file_lock structures that are acting as lock requests (in
174 * contrast to those that are acting as records of acquired locks).
175 *
176 * Note that when we acquire this lock in order to change the above fields,
177 * we often hold the i_lock as well. In certain cases, when reading the fields
178 * protected by this lock, we can skip acquiring it iff we already hold the
179 * i_lock.
180 *
181 * In particular, adding an entry to the fl_block list requires that you hold
182 * both the i_lock and the blocked_lock_lock (acquired in that order). Deleting
183 * an entry from the list however only requires the file_lock_lock.
184 */
Arnd Bergmann72f98e72010-10-27 21:39:58 +0200185static DEFINE_SPINLOCK(file_lock_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
Christoph Lametere18b8902006-12-06 20:33:20 -0800187static struct kmem_cache *filelock_cache __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
Miklos Szerediee19cc42011-07-07 13:06:09 +0200189static void locks_init_lock_heads(struct file_lock *fl)
Miklos Szeredia51cb912011-07-06 12:33:55 +0200190{
Miklos Szerediee19cc42011-07-07 13:06:09 +0200191 INIT_LIST_HEAD(&fl->fl_link);
192 INIT_LIST_HEAD(&fl->fl_block);
193 init_waitqueue_head(&fl->fl_wait);
Miklos Szeredia51cb912011-07-06 12:33:55 +0200194}
195
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196/* Allocate an empty lock structure. */
Arnd Bergmannc5b1f0d2010-10-27 15:46:08 +0200197struct file_lock *locks_alloc_lock(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198{
Miklos Szerediee19cc42011-07-07 13:06:09 +0200199 struct file_lock *fl = kmem_cache_zalloc(filelock_cache, GFP_KERNEL);
Miklos Szeredia51cb912011-07-06 12:33:55 +0200200
201 if (fl)
Miklos Szerediee19cc42011-07-07 13:06:09 +0200202 locks_init_lock_heads(fl);
Miklos Szeredia51cb912011-07-06 12:33:55 +0200203
204 return fl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205}
Arnd Bergmannc5b1f0d2010-10-27 15:46:08 +0200206EXPORT_SYMBOL_GPL(locks_alloc_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
Felix Blyakhera9e61e22009-03-31 15:12:56 -0500208void locks_release_private(struct file_lock *fl)
Trond Myklebust47831f32006-03-20 13:44:05 -0500209{
210 if (fl->fl_ops) {
211 if (fl->fl_ops->fl_release_private)
212 fl->fl_ops->fl_release_private(fl);
213 fl->fl_ops = NULL;
214 }
J. Bruce Fields068535f2012-08-01 07:56:16 -0400215 fl->fl_lmops = NULL;
Trond Myklebust47831f32006-03-20 13:44:05 -0500216
217}
Felix Blyakhera9e61e22009-03-31 15:12:56 -0500218EXPORT_SYMBOL_GPL(locks_release_private);
Trond Myklebust47831f32006-03-20 13:44:05 -0500219
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220/* Free a lock which is not in use. */
J. Bruce Fields05fa3132010-10-30 17:31:15 -0400221void locks_free_lock(struct file_lock *fl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222{
Miklos Szeredi5ce29642006-03-31 02:30:29 -0800223 BUG_ON(waitqueue_active(&fl->fl_wait));
224 BUG_ON(!list_empty(&fl->fl_block));
225 BUG_ON(!list_empty(&fl->fl_link));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
Trond Myklebust47831f32006-03-20 13:44:05 -0500227 locks_release_private(fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 kmem_cache_free(filelock_cache, fl);
229}
J. Bruce Fields05fa3132010-10-30 17:31:15 -0400230EXPORT_SYMBOL(locks_free_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
232void locks_init_lock(struct file_lock *fl)
233{
Miklos Szerediee19cc42011-07-07 13:06:09 +0200234 memset(fl, 0, sizeof(struct file_lock));
235 locks_init_lock_heads(fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236}
237
238EXPORT_SYMBOL(locks_init_lock);
239
Trond Myklebust47831f32006-03-20 13:44:05 -0500240static void locks_copy_private(struct file_lock *new, struct file_lock *fl)
241{
242 if (fl->fl_ops) {
243 if (fl->fl_ops->fl_copy_lock)
244 fl->fl_ops->fl_copy_lock(new, fl);
245 new->fl_ops = fl->fl_ops;
246 }
Christoph Hellwigbb8430a2010-10-31 08:35:31 -0400247 if (fl->fl_lmops)
Trond Myklebust47831f32006-03-20 13:44:05 -0500248 new->fl_lmops = fl->fl_lmops;
Trond Myklebust47831f32006-03-20 13:44:05 -0500249}
250
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251/*
252 * Initialize a new lock from an existing file_lock structure.
253 */
J. Bruce Fields1a747ee2008-04-24 10:08:22 -0400254void __locks_copy_lock(struct file_lock *new, const struct file_lock *fl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255{
256 new->fl_owner = fl->fl_owner;
257 new->fl_pid = fl->fl_pid;
Trond Myklebust09969052006-03-20 13:44:38 -0500258 new->fl_file = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 new->fl_flags = fl->fl_flags;
260 new->fl_type = fl->fl_type;
261 new->fl_start = fl->fl_start;
262 new->fl_end = fl->fl_end;
Trond Myklebust09969052006-03-20 13:44:38 -0500263 new->fl_ops = NULL;
264 new->fl_lmops = NULL;
265}
Roland Dreier3dd7b712008-04-25 15:32:51 -0700266EXPORT_SYMBOL(__locks_copy_lock);
Trond Myklebust09969052006-03-20 13:44:38 -0500267
268void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
269{
270 locks_release_private(new);
271
272 __locks_copy_lock(new, fl);
273 new->fl_file = fl->fl_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 new->fl_ops = fl->fl_ops;
275 new->fl_lmops = fl->fl_lmops;
Trond Myklebust47831f32006-03-20 13:44:05 -0500276
277 locks_copy_private(new, fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278}
279
280EXPORT_SYMBOL(locks_copy_lock);
281
282static inline int flock_translate_cmd(int cmd) {
283 if (cmd & LOCK_MAND)
284 return cmd & (LOCK_MAND | LOCK_RW);
285 switch (cmd) {
286 case LOCK_SH:
287 return F_RDLCK;
288 case LOCK_EX:
289 return F_WRLCK;
290 case LOCK_UN:
291 return F_UNLCK;
292 }
293 return -EINVAL;
294}
295
296/* Fill in a file_lock structure with an appropriate FLOCK lock. */
297static int flock_make_lock(struct file *filp, struct file_lock **lock,
298 unsigned int cmd)
299{
300 struct file_lock *fl;
301 int type = flock_translate_cmd(cmd);
302 if (type < 0)
303 return type;
304
305 fl = locks_alloc_lock();
306 if (fl == NULL)
307 return -ENOMEM;
308
309 fl->fl_file = filp;
310 fl->fl_pid = current->tgid;
311 fl->fl_flags = FL_FLOCK;
312 fl->fl_type = type;
313 fl->fl_end = OFFSET_MAX;
314
315 *lock = fl;
316 return 0;
317}
318
J. Bruce Fields0ec4f432012-07-23 15:17:17 -0400319static int assign_type(struct file_lock *fl, long type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320{
321 switch (type) {
322 case F_RDLCK:
323 case F_WRLCK:
324 case F_UNLCK:
325 fl->fl_type = type;
326 break;
327 default:
328 return -EINVAL;
329 }
330 return 0;
331}
332
333/* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX
334 * style lock.
335 */
336static int flock_to_posix_lock(struct file *filp, struct file_lock *fl,
337 struct flock *l)
338{
339 off_t start, end;
340
341 switch (l->l_whence) {
Josef 'Jeff' Sipekf5579f82006-09-30 23:27:35 -0700342 case SEEK_SET:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 start = 0;
344 break;
Josef 'Jeff' Sipekf5579f82006-09-30 23:27:35 -0700345 case SEEK_CUR:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 start = filp->f_pos;
347 break;
Josef 'Jeff' Sipekf5579f82006-09-30 23:27:35 -0700348 case SEEK_END:
Al Viro496ad9a2013-01-23 17:07:38 -0500349 start = i_size_read(file_inode(filp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 break;
351 default:
352 return -EINVAL;
353 }
354
355 /* POSIX-1996 leaves the case l->l_len < 0 undefined;
356 POSIX-2001 defines it. */
357 start += l->l_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 if (start < 0)
359 return -EINVAL;
Trond Myklebust4c780a42005-10-18 14:20:21 -0700360 fl->fl_end = OFFSET_MAX;
361 if (l->l_len > 0) {
362 end = start + l->l_len - 1;
363 fl->fl_end = end;
364 } else if (l->l_len < 0) {
365 end = start - 1;
366 fl->fl_end = end;
367 start += l->l_len;
368 if (start < 0)
369 return -EINVAL;
370 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 fl->fl_start = start; /* we record the absolute position */
Trond Myklebust4c780a42005-10-18 14:20:21 -0700372 if (fl->fl_end < fl->fl_start)
373 return -EOVERFLOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374
375 fl->fl_owner = current->files;
376 fl->fl_pid = current->tgid;
377 fl->fl_file = filp;
378 fl->fl_flags = FL_POSIX;
379 fl->fl_ops = NULL;
380 fl->fl_lmops = NULL;
381
382 return assign_type(fl, l->l_type);
383}
384
385#if BITS_PER_LONG == 32
386static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl,
387 struct flock64 *l)
388{
389 loff_t start;
390
391 switch (l->l_whence) {
Josef 'Jeff' Sipekf5579f82006-09-30 23:27:35 -0700392 case SEEK_SET:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 start = 0;
394 break;
Josef 'Jeff' Sipekf5579f82006-09-30 23:27:35 -0700395 case SEEK_CUR:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 start = filp->f_pos;
397 break;
Josef 'Jeff' Sipekf5579f82006-09-30 23:27:35 -0700398 case SEEK_END:
Al Viro496ad9a2013-01-23 17:07:38 -0500399 start = i_size_read(file_inode(filp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 break;
401 default:
402 return -EINVAL;
403 }
404
Trond Myklebust4c780a42005-10-18 14:20:21 -0700405 start += l->l_start;
406 if (start < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 return -EINVAL;
Trond Myklebust4c780a42005-10-18 14:20:21 -0700408 fl->fl_end = OFFSET_MAX;
409 if (l->l_len > 0) {
410 fl->fl_end = start + l->l_len - 1;
411 } else if (l->l_len < 0) {
412 fl->fl_end = start - 1;
413 start += l->l_len;
414 if (start < 0)
415 return -EINVAL;
416 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 fl->fl_start = start; /* we record the absolute position */
Trond Myklebust4c780a42005-10-18 14:20:21 -0700418 if (fl->fl_end < fl->fl_start)
419 return -EOVERFLOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
421 fl->fl_owner = current->files;
422 fl->fl_pid = current->tgid;
423 fl->fl_file = filp;
424 fl->fl_flags = FL_POSIX;
425 fl->fl_ops = NULL;
426 fl->fl_lmops = NULL;
427
Namhyung Kimf32cb532011-01-17 15:45:59 +0900428 return assign_type(fl, l->l_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429}
430#endif
431
432/* default lease lock manager operations */
433static void lease_break_callback(struct file_lock *fl)
434{
435 kill_fasync(&fl->fl_fasync, SIGIO, POLL_MSG);
436}
437
Alexey Dobriyan7b021962009-09-21 17:01:12 -0700438static const struct lock_manager_operations lease_manager_ops = {
J. Bruce Fields8fb47a42011-07-20 20:21:59 -0400439 .lm_break = lease_break_callback,
J. Bruce Fields8fb47a42011-07-20 20:21:59 -0400440 .lm_change = lease_modify,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441};
442
443/*
444 * Initialize a lease, use the default lock manager operations
445 */
J. Bruce Fields0ec4f432012-07-23 15:17:17 -0400446static int lease_init(struct file *filp, long type, struct file_lock *fl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 {
Trond Myklebust75dff552006-05-07 23:02:42 -0400448 if (assign_type(fl, type) != 0)
449 return -EINVAL;
450
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 fl->fl_owner = current->files;
452 fl->fl_pid = current->tgid;
453
454 fl->fl_file = filp;
455 fl->fl_flags = FL_LEASE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 fl->fl_start = 0;
457 fl->fl_end = OFFSET_MAX;
458 fl->fl_ops = NULL;
459 fl->fl_lmops = &lease_manager_ops;
460 return 0;
461}
462
463/* Allocate a file_lock initialised to this type of lease */
J. Bruce Fields0ec4f432012-07-23 15:17:17 -0400464static struct file_lock *lease_alloc(struct file *filp, long type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465{
466 struct file_lock *fl = locks_alloc_lock();
Trond Myklebust75dff552006-05-07 23:02:42 -0400467 int error = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
469 if (fl == NULL)
J. Bruce Fieldse32b8ee2007-03-01 14:34:35 -0500470 return ERR_PTR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
472 error = lease_init(filp, type, fl);
Trond Myklebust75dff552006-05-07 23:02:42 -0400473 if (error) {
474 locks_free_lock(fl);
J. Bruce Fieldse32b8ee2007-03-01 14:34:35 -0500475 return ERR_PTR(error);
Trond Myklebust75dff552006-05-07 23:02:42 -0400476 }
J. Bruce Fieldse32b8ee2007-03-01 14:34:35 -0500477 return fl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478}
479
480/* Check if two locks overlap each other.
481 */
482static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2)
483{
484 return ((fl1->fl_end >= fl2->fl_start) &&
485 (fl2->fl_end >= fl1->fl_start));
486}
487
488/*
489 * Check whether two locks have the same owner.
490 */
Matt Mackall33443c42006-01-08 01:05:22 -0800491static int posix_same_owner(struct file_lock *fl1, struct file_lock *fl2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492{
J. Bruce Fields8fb47a42011-07-20 20:21:59 -0400493 if (fl1->fl_lmops && fl1->fl_lmops->lm_compare_owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 return fl2->fl_lmops == fl1->fl_lmops &&
J. Bruce Fields8fb47a42011-07-20 20:21:59 -0400495 fl1->fl_lmops->lm_compare_owner(fl1, fl2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 return fl1->fl_owner == fl2->fl_owner;
497}
498
Jeff Layton88974692013-06-21 08:58:14 -0400499static inline void
500locks_insert_global_locks(struct file_lock *fl)
501{
Jeff Layton1c8c6012013-06-21 08:58:15 -0400502 spin_lock(&file_lock_lock);
Jeff Layton88974692013-06-21 08:58:14 -0400503 list_add_tail(&fl->fl_link, &file_lock_list);
Jeff Layton1c8c6012013-06-21 08:58:15 -0400504 spin_unlock(&file_lock_lock);
Jeff Layton88974692013-06-21 08:58:14 -0400505}
506
507static inline void
508locks_delete_global_locks(struct file_lock *fl)
509{
Jeff Layton1c8c6012013-06-21 08:58:15 -0400510 spin_lock(&file_lock_lock);
Jeff Layton88974692013-06-21 08:58:14 -0400511 list_del_init(&fl->fl_link);
Jeff Layton1c8c6012013-06-21 08:58:15 -0400512 spin_unlock(&file_lock_lock);
Jeff Layton88974692013-06-21 08:58:14 -0400513}
514
515static inline void
516locks_insert_global_blocked(struct file_lock *waiter)
517{
518 list_add(&waiter->fl_link, &blocked_list);
519}
520
521static inline void
522locks_delete_global_blocked(struct file_lock *waiter)
523{
524 list_del_init(&waiter->fl_link);
525}
526
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527/* Remove waiter from blocker's block list.
528 * When blocker ends up pointing to itself then the list is empty.
Jeff Layton1c8c6012013-06-21 08:58:15 -0400529 *
530 * Must be called with file_lock_lock held.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 */
Matt Mackall33443c42006-01-08 01:05:22 -0800532static void __locks_delete_block(struct file_lock *waiter)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533{
Jeff Layton88974692013-06-21 08:58:14 -0400534 locks_delete_global_blocked(waiter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 list_del_init(&waiter->fl_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 waiter->fl_next = NULL;
537}
538
Jeff Layton1a9e64a2013-06-21 08:58:10 -0400539static void locks_delete_block(struct file_lock *waiter)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540{
Jeff Layton1c8c6012013-06-21 08:58:15 -0400541 spin_lock(&file_lock_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 __locks_delete_block(waiter);
Jeff Layton1c8c6012013-06-21 08:58:15 -0400543 spin_unlock(&file_lock_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544}
545
546/* Insert waiter into blocker's block list.
547 * We use a circular list so that processes can be easily woken up in
548 * the order they blocked. The documentation doesn't require this but
549 * it seems like the reasonable thing to do.
Jeff Layton1c8c6012013-06-21 08:58:15 -0400550 *
Jeff Layton4e8c7652013-06-21 08:58:16 -0400551 * Must be called with both the i_lock and file_lock_lock held. The fl_block
552 * list itself is protected by the file_lock_list, but by ensuring that the
553 * i_lock is also held on insertions we can avoid taking the file_lock_lock
554 * in some cases when we see that the fl_block list is empty.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 */
Jeff Layton1c8c6012013-06-21 08:58:15 -0400556static void __locks_insert_block(struct file_lock *blocker,
557 struct file_lock *waiter)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558{
J. Bruce Fields6dc0fe82006-03-26 01:37:24 -0800559 BUG_ON(!list_empty(&waiter->fl_block));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 waiter->fl_next = blocker;
Jeff Layton88974692013-06-21 08:58:14 -0400561 list_add_tail(&waiter->fl_block, &blocker->fl_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 if (IS_POSIX(blocker))
Jeff Layton1c8c6012013-06-21 08:58:15 -0400563 locks_insert_global_blocked(waiter);
564}
565
566/* Must be called with i_lock held. */
567static void locks_insert_block(struct file_lock *blocker,
568 struct file_lock *waiter)
569{
570 spin_lock(&file_lock_lock);
571 __locks_insert_block(blocker, waiter);
572 spin_unlock(&file_lock_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573}
574
Jeff Layton1cb36012013-06-21 08:58:12 -0400575/*
576 * Wake up processes blocked waiting for blocker.
577 *
Jeff Layton1c8c6012013-06-21 08:58:15 -0400578 * Must be called with the inode->i_lock held!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 */
580static void locks_wake_up_blocks(struct file_lock *blocker)
581{
Jeff Layton4e8c7652013-06-21 08:58:16 -0400582 /*
583 * Avoid taking global lock if list is empty. This is safe since new
584 * blocked requests are only added to the list under the i_lock, and
585 * the i_lock is always held here. Note that removal from the fl_block
586 * list does not require the i_lock, so we must recheck list_empty()
587 * after acquiring the file_lock_lock.
588 */
589 if (list_empty(&blocker->fl_block))
590 return;
591
Jeff Layton1c8c6012013-06-21 08:58:15 -0400592 spin_lock(&file_lock_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 while (!list_empty(&blocker->fl_block)) {
Pavel Emelyanovf0c1cd02007-09-19 16:44:07 +0400594 struct file_lock *waiter;
595
596 waiter = list_first_entry(&blocker->fl_block,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 struct file_lock, fl_block);
598 __locks_delete_block(waiter);
J. Bruce Fields8fb47a42011-07-20 20:21:59 -0400599 if (waiter->fl_lmops && waiter->fl_lmops->lm_notify)
600 waiter->fl_lmops->lm_notify(waiter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 else
602 wake_up(&waiter->fl_wait);
603 }
Jeff Layton1c8c6012013-06-21 08:58:15 -0400604 spin_unlock(&file_lock_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605}
606
607/* Insert file lock fl into an inode's lock list at the position indicated
608 * by pos. At the same time add the lock to the global file lock list.
Jeff Layton1c8c6012013-06-21 08:58:15 -0400609 *
610 * Must be called with the i_lock held!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 */
612static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl)
613{
Vitaliy Gusevab1f1612008-01-17 00:07:08 +0000614 fl->fl_nspid = get_pid(task_tgid(current));
615
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 /* insert into file's list */
617 fl->fl_next = *pos;
618 *pos = fl;
Jeff Layton88974692013-06-21 08:58:14 -0400619
620 locks_insert_global_locks(fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621}
622
623/*
624 * Delete a lock and then free it.
625 * Wake up processes that are blocked waiting for this lock,
626 * notify the FS that the lock has been cleared and
627 * finally free the lock.
Jeff Layton1c8c6012013-06-21 08:58:15 -0400628 *
629 * Must be called with the i_lock held!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 */
631static void locks_delete_lock(struct file_lock **thisfl_p)
632{
633 struct file_lock *fl = *thisfl_p;
634
Jeff Layton88974692013-06-21 08:58:14 -0400635 locks_delete_global_locks(fl);
636
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 *thisfl_p = fl->fl_next;
638 fl->fl_next = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639
Vitaliy Gusevab1f1612008-01-17 00:07:08 +0000640 if (fl->fl_nspid) {
641 put_pid(fl->fl_nspid);
642 fl->fl_nspid = NULL;
643 }
644
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 locks_wake_up_blocks(fl);
646 locks_free_lock(fl);
647}
648
649/* Determine if lock sys_fl blocks lock caller_fl. Common functionality
650 * checks for shared/exclusive status of overlapping locks.
651 */
652static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
653{
654 if (sys_fl->fl_type == F_WRLCK)
655 return 1;
656 if (caller_fl->fl_type == F_WRLCK)
657 return 1;
658 return 0;
659}
660
661/* Determine if lock sys_fl blocks lock caller_fl. POSIX specific
662 * checking before calling the locks_conflict().
663 */
664static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
665{
666 /* POSIX locks owned by the same process do not conflict with
667 * each other.
668 */
669 if (!IS_POSIX(sys_fl) || posix_same_owner(caller_fl, sys_fl))
670 return (0);
671
672 /* Check whether they overlap */
673 if (!locks_overlap(caller_fl, sys_fl))
674 return 0;
675
676 return (locks_conflict(caller_fl, sys_fl));
677}
678
679/* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific
680 * checking before calling the locks_conflict().
681 */
682static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
683{
684 /* FLOCK locks referring to the same filp do not conflict with
685 * each other.
686 */
687 if (!IS_FLOCK(sys_fl) || (caller_fl->fl_file == sys_fl->fl_file))
688 return (0);
689 if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND))
690 return 0;
691
692 return (locks_conflict(caller_fl, sys_fl));
693}
694
J. Bruce Fields6d34ac12007-05-11 16:09:32 -0400695void
Marc Eshel9d6a8c52007-02-21 00:55:18 -0500696posix_test_lock(struct file *filp, struct file_lock *fl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697{
698 struct file_lock *cfl;
Jeff Layton1c8c6012013-06-21 08:58:15 -0400699 struct inode *inode = file_inode(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700
Jeff Layton1c8c6012013-06-21 08:58:15 -0400701 spin_lock(&inode->i_lock);
Al Viro496ad9a2013-01-23 17:07:38 -0500702 for (cfl = file_inode(filp)->i_flock; cfl; cfl = cfl->fl_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 if (!IS_POSIX(cfl))
704 continue;
J. Bruce Fieldsb842e242007-05-10 19:02:07 -0400705 if (posix_locks_conflict(fl, cfl))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 break;
707 }
Vitaliy Gusevab1f1612008-01-17 00:07:08 +0000708 if (cfl) {
Marc Eshel9d6a8c52007-02-21 00:55:18 -0500709 __locks_copy_lock(fl, cfl);
Vitaliy Gusevab1f1612008-01-17 00:07:08 +0000710 if (cfl->fl_nspid)
Pavel Emelyanov6c5f3e72008-02-08 04:19:20 -0800711 fl->fl_pid = pid_vnr(cfl->fl_nspid);
Vitaliy Gusevab1f1612008-01-17 00:07:08 +0000712 } else
J. Bruce Fields129a84d2007-05-10 18:38:43 -0400713 fl->fl_type = F_UNLCK;
Jeff Layton1c8c6012013-06-21 08:58:15 -0400714 spin_unlock(&inode->i_lock);
J. Bruce Fields6d34ac12007-05-11 16:09:32 -0400715 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717EXPORT_SYMBOL(posix_test_lock);
718
J. Bruce Fieldsb5331842007-10-26 18:05:40 -0400719/*
720 * Deadlock detection:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 *
J. Bruce Fieldsb5331842007-10-26 18:05:40 -0400722 * We attempt to detect deadlocks that are due purely to posix file
723 * locks.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 *
J. Bruce Fieldsb5331842007-10-26 18:05:40 -0400725 * We assume that a task can be waiting for at most one lock at a time.
726 * So for any acquired lock, the process holding that lock may be
727 * waiting on at most one other lock. That lock in turns may be held by
728 * someone waiting for at most one other lock. Given a requested lock
729 * caller_fl which is about to wait for a conflicting lock block_fl, we
730 * follow this chain of waiters to ensure we are not about to create a
731 * cycle.
J. Bruce Fields97855b42007-10-30 11:20:02 -0400732 *
J. Bruce Fieldsb5331842007-10-26 18:05:40 -0400733 * Since we do this before we ever put a process to sleep on a lock, we
734 * are ensured that there is never a cycle; that is what guarantees that
735 * the while() loop in posix_locks_deadlock() eventually completes.
736 *
737 * Note: the above assumption may not be true when handling lock
738 * requests from a broken NFS client. It may also fail in the presence
739 * of tasks (such as posix threads) sharing the same open file table.
740 *
741 * To handle those cases, we just bail out after a few iterations.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 */
J. Bruce Fields97855b42007-10-30 11:20:02 -0400743
744#define MAX_DEADLK_ITERATIONS 10
745
J. Bruce Fieldsb5331842007-10-26 18:05:40 -0400746/* Find a lock that the owner of the given block_fl is blocking on. */
747static struct file_lock *what_owner_is_waiting_for(struct file_lock *block_fl)
748{
749 struct file_lock *fl;
750
751 list_for_each_entry(fl, &blocked_list, fl_link) {
752 if (posix_same_owner(fl, block_fl))
753 return fl->fl_next;
754 }
755 return NULL;
756}
757
Jeff Layton1c8c6012013-06-21 08:58:15 -0400758/* Must be called with the file_lock_lock held! */
Adrian Bunkb0904e12006-06-23 02:05:13 -0700759static int posix_locks_deadlock(struct file_lock *caller_fl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 struct file_lock *block_fl)
761{
J. Bruce Fields97855b42007-10-30 11:20:02 -0400762 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
J. Bruce Fieldsb5331842007-10-26 18:05:40 -0400764 while ((block_fl = what_owner_is_waiting_for(block_fl))) {
765 if (i++ > MAX_DEADLK_ITERATIONS)
766 return 0;
767 if (posix_same_owner(caller_fl, block_fl))
768 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 }
770 return 0;
771}
772
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773/* Try to create a FLOCK lock on filp. We always insert new FLOCK locks
J. Bruce Fields02888f42007-09-12 15:45:07 -0400774 * after any leases, but before any posix locks.
Trond Myklebustf475ae92006-06-29 16:38:32 -0400775 *
776 * Note that if called with an FL_EXISTS argument, the caller may determine
777 * whether or not a lock was successfully freed by testing the return
778 * value for -ENOENT.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 */
Trond Myklebust993dfa82006-03-31 02:30:55 -0800780static int flock_lock_file(struct file *filp, struct file_lock *request)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781{
Trond Myklebust993dfa82006-03-31 02:30:55 -0800782 struct file_lock *new_fl = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 struct file_lock **before;
Al Viro496ad9a2013-01-23 17:07:38 -0500784 struct inode * inode = file_inode(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 int error = 0;
786 int found = 0;
787
Arnd Bergmannb89f4322010-09-18 15:09:31 +0200788 if (!(request->fl_flags & FL_ACCESS) && (request->fl_type != F_UNLCK)) {
789 new_fl = locks_alloc_lock();
790 if (!new_fl)
791 return -ENOMEM;
792 }
793
Jeff Layton1c8c6012013-06-21 08:58:15 -0400794 spin_lock(&inode->i_lock);
Trond Myklebustf07f18d2006-06-29 16:38:37 -0400795 if (request->fl_flags & FL_ACCESS)
796 goto find_conflict;
Pavel Emelyanov84d535a2007-09-11 16:38:13 +0400797
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 for_each_lock(inode, before) {
799 struct file_lock *fl = *before;
800 if (IS_POSIX(fl))
801 break;
802 if (IS_LEASE(fl))
803 continue;
804 if (filp != fl->fl_file)
805 continue;
Trond Myklebust993dfa82006-03-31 02:30:55 -0800806 if (request->fl_type == fl->fl_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 goto out;
808 found = 1;
809 locks_delete_lock(before);
810 break;
811 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812
Trond Myklebustf475ae92006-06-29 16:38:32 -0400813 if (request->fl_type == F_UNLCK) {
814 if ((request->fl_flags & FL_EXISTS) && !found)
815 error = -ENOENT;
Trond Myklebust993dfa82006-03-31 02:30:55 -0800816 goto out;
Trond Myklebustf475ae92006-06-29 16:38:32 -0400817 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818
819 /*
820 * If a higher-priority process was blocked on the old file lock,
821 * give it the opportunity to lock the file.
822 */
Arnd Bergmannb89f4322010-09-18 15:09:31 +0200823 if (found) {
Jeff Layton1c8c6012013-06-21 08:58:15 -0400824 spin_unlock(&inode->i_lock);
Frederic Weisbeckerdef01bc2009-07-16 15:44:29 +0200825 cond_resched();
Jeff Layton1c8c6012013-06-21 08:58:15 -0400826 spin_lock(&inode->i_lock);
Arnd Bergmannb89f4322010-09-18 15:09:31 +0200827 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828
Trond Myklebustf07f18d2006-06-29 16:38:37 -0400829find_conflict:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 for_each_lock(inode, before) {
831 struct file_lock *fl = *before;
832 if (IS_POSIX(fl))
833 break;
834 if (IS_LEASE(fl))
835 continue;
Trond Myklebust993dfa82006-03-31 02:30:55 -0800836 if (!flock_locks_conflict(request, fl))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 continue;
838 error = -EAGAIN;
Miklos Szeredibde74e42008-07-25 01:48:57 -0700839 if (!(request->fl_flags & FL_SLEEP))
840 goto out;
841 error = FILE_LOCK_DEFERRED;
842 locks_insert_block(fl, request);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 goto out;
844 }
Trond Myklebustf07f18d2006-06-29 16:38:37 -0400845 if (request->fl_flags & FL_ACCESS)
846 goto out;
Trond Myklebust993dfa82006-03-31 02:30:55 -0800847 locks_copy_lock(new_fl, request);
Pavel Emelyanov0e2f6db2007-09-11 15:24:01 -0700848 locks_insert_lock(before, new_fl);
Trond Myklebust993dfa82006-03-31 02:30:55 -0800849 new_fl = NULL;
Kirill Korotaev9cedc192006-06-14 17:59:35 +0400850 error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851
852out:
Jeff Layton1c8c6012013-06-21 08:58:15 -0400853 spin_unlock(&inode->i_lock);
Trond Myklebust993dfa82006-03-31 02:30:55 -0800854 if (new_fl)
855 locks_free_lock(new_fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 return error;
857}
858
Marc Eshel150b3932007-01-18 16:15:35 -0500859static int __posix_lock_file(struct inode *inode, struct file_lock *request, struct file_lock *conflock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860{
861 struct file_lock *fl;
Miklos Szeredi39005d02006-06-23 02:05:10 -0700862 struct file_lock *new_fl = NULL;
863 struct file_lock *new_fl2 = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 struct file_lock *left = NULL;
865 struct file_lock *right = NULL;
866 struct file_lock **before;
Jeff Laytonb9746ef2013-06-21 08:58:13 -0400867 int error;
868 bool added = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869
870 /*
871 * We may need two file_lock structures for this operation,
872 * so we get them in advance to avoid races.
Miklos Szeredi39005d02006-06-23 02:05:10 -0700873 *
874 * In some cases we can be sure, that no new locks will be needed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 */
Miklos Szeredi39005d02006-06-23 02:05:10 -0700876 if (!(request->fl_flags & FL_ACCESS) &&
877 (request->fl_type != F_UNLCK ||
878 request->fl_start != 0 || request->fl_end != OFFSET_MAX)) {
879 new_fl = locks_alloc_lock();
880 new_fl2 = locks_alloc_lock();
881 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882
Jeff Layton1c8c6012013-06-21 08:58:15 -0400883 spin_lock(&inode->i_lock);
Jeff Layton1cb36012013-06-21 08:58:12 -0400884 /*
885 * New lock request. Walk all POSIX locks and look for conflicts. If
886 * there are any, either return error or put the request on the
887 * blocker's list of waiters and the global blocked_list.
888 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 if (request->fl_type != F_UNLCK) {
890 for_each_lock(inode, before) {
J. Bruce Fields526985b2006-11-14 16:54:36 -0500891 fl = *before;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 if (!IS_POSIX(fl))
893 continue;
894 if (!posix_locks_conflict(request, fl))
895 continue;
Andy Adamson5842add2006-03-26 01:37:26 -0800896 if (conflock)
J. Bruce Fields1a747ee2008-04-24 10:08:22 -0400897 __locks_copy_lock(conflock, fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 error = -EAGAIN;
899 if (!(request->fl_flags & FL_SLEEP))
900 goto out;
Jeff Layton1c8c6012013-06-21 08:58:15 -0400901 /*
902 * Deadlock detection and insertion into the blocked
903 * locks list must be done while holding the same lock!
904 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 error = -EDEADLK;
Jeff Layton1c8c6012013-06-21 08:58:15 -0400906 spin_lock(&file_lock_lock);
907 if (likely(!posix_locks_deadlock(request, fl))) {
908 error = FILE_LOCK_DEFERRED;
909 __locks_insert_block(fl, request);
910 }
911 spin_unlock(&file_lock_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 goto out;
913 }
914 }
915
916 /* If we're just looking for a conflict, we're done. */
917 error = 0;
918 if (request->fl_flags & FL_ACCESS)
919 goto out;
920
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 * Find the first old lock with the same owner as the new lock.
923 */
924
925 before = &inode->i_flock;
926
927 /* First skip locks owned by other processes. */
928 while ((fl = *before) && (!IS_POSIX(fl) ||
929 !posix_same_owner(request, fl))) {
930 before = &fl->fl_next;
931 }
932
Jeff Layton1cb36012013-06-21 08:58:12 -0400933 /* Process locks with this owner. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 while ((fl = *before) && posix_same_owner(request, fl)) {
935 /* Detect adjacent or overlapping regions (if same lock type)
936 */
937 if (request->fl_type == fl->fl_type) {
Olaf Kirch449231d2005-08-25 16:25:35 -0700938 /* In all comparisons of start vs end, use
939 * "start - 1" rather than "end + 1". If end
940 * is OFFSET_MAX, end + 1 will become negative.
941 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 if (fl->fl_end < request->fl_start - 1)
943 goto next_lock;
944 /* If the next lock in the list has entirely bigger
945 * addresses than the new one, insert the lock here.
946 */
Olaf Kirch449231d2005-08-25 16:25:35 -0700947 if (fl->fl_start - 1 > request->fl_end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 break;
949
950 /* If we come here, the new and old lock are of the
951 * same type and adjacent or overlapping. Make one
952 * lock yielding from the lower start address of both
953 * locks to the higher end address.
954 */
955 if (fl->fl_start > request->fl_start)
956 fl->fl_start = request->fl_start;
957 else
958 request->fl_start = fl->fl_start;
959 if (fl->fl_end < request->fl_end)
960 fl->fl_end = request->fl_end;
961 else
962 request->fl_end = fl->fl_end;
963 if (added) {
964 locks_delete_lock(before);
965 continue;
966 }
967 request = fl;
Jeff Laytonb9746ef2013-06-21 08:58:13 -0400968 added = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 }
970 else {
971 /* Processing for different lock types is a bit
972 * more complex.
973 */
974 if (fl->fl_end < request->fl_start)
975 goto next_lock;
976 if (fl->fl_start > request->fl_end)
977 break;
978 if (request->fl_type == F_UNLCK)
Jeff Laytonb9746ef2013-06-21 08:58:13 -0400979 added = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 if (fl->fl_start < request->fl_start)
981 left = fl;
982 /* If the next lock in the list has a higher end
983 * address than the new one, insert the new one here.
984 */
985 if (fl->fl_end > request->fl_end) {
986 right = fl;
987 break;
988 }
989 if (fl->fl_start >= request->fl_start) {
990 /* The new lock completely replaces an old
991 * one (This may happen several times).
992 */
993 if (added) {
994 locks_delete_lock(before);
995 continue;
996 }
997 /* Replace the old lock with the new one.
998 * Wake up anybody waiting for the old one,
999 * as the change in lock type might satisfy
1000 * their needs.
1001 */
1002 locks_wake_up_blocks(fl);
1003 fl->fl_start = request->fl_start;
1004 fl->fl_end = request->fl_end;
1005 fl->fl_type = request->fl_type;
Trond Myklebust47831f32006-03-20 13:44:05 -05001006 locks_release_private(fl);
1007 locks_copy_private(fl, request);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 request = fl;
Jeff Laytonb9746ef2013-06-21 08:58:13 -04001009 added = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 }
1011 }
1012 /* Go on to next lock.
1013 */
1014 next_lock:
1015 before = &fl->fl_next;
1016 }
1017
Miklos Szeredi0d9a4902006-06-23 02:05:09 -07001018 /*
Jeff Layton1cb36012013-06-21 08:58:12 -04001019 * The above code only modifies existing locks in case of merging or
1020 * replacing. If new lock(s) need to be inserted all modifications are
1021 * done below this, so it's safe yet to bail out.
Miklos Szeredi0d9a4902006-06-23 02:05:09 -07001022 */
1023 error = -ENOLCK; /* "no luck" */
1024 if (right && left == right && !new_fl2)
1025 goto out;
1026
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 error = 0;
1028 if (!added) {
Trond Myklebustf475ae92006-06-29 16:38:32 -04001029 if (request->fl_type == F_UNLCK) {
1030 if (request->fl_flags & FL_EXISTS)
1031 error = -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 goto out;
Trond Myklebustf475ae92006-06-29 16:38:32 -04001033 }
Miklos Szeredi0d9a4902006-06-23 02:05:09 -07001034
1035 if (!new_fl) {
1036 error = -ENOLCK;
1037 goto out;
1038 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 locks_copy_lock(new_fl, request);
1040 locks_insert_lock(before, new_fl);
1041 new_fl = NULL;
1042 }
1043 if (right) {
1044 if (left == right) {
1045 /* The new lock breaks the old one in two pieces,
1046 * so we have to use the second new lock.
1047 */
1048 left = new_fl2;
1049 new_fl2 = NULL;
1050 locks_copy_lock(left, right);
1051 locks_insert_lock(before, left);
1052 }
1053 right->fl_start = request->fl_end + 1;
1054 locks_wake_up_blocks(right);
1055 }
1056 if (left) {
1057 left->fl_end = request->fl_start - 1;
1058 locks_wake_up_blocks(left);
1059 }
1060 out:
Jeff Layton1c8c6012013-06-21 08:58:15 -04001061 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 /*
1063 * Free any unused locks.
1064 */
1065 if (new_fl)
1066 locks_free_lock(new_fl);
1067 if (new_fl2)
1068 locks_free_lock(new_fl2);
1069 return error;
1070}
1071
1072/**
1073 * posix_lock_file - Apply a POSIX-style lock to a file
1074 * @filp: The file to apply the lock to
1075 * @fl: The lock to be applied
Marc Eshel150b3932007-01-18 16:15:35 -05001076 * @conflock: Place to return a copy of the conflicting lock, if found.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 *
1078 * Add a POSIX style lock to a file.
1079 * We merge adjacent & overlapping locks whenever possible.
1080 * POSIX locks are sorted by owner task, then by starting address
Trond Myklebustf475ae92006-06-29 16:38:32 -04001081 *
1082 * Note that if called with an FL_EXISTS argument, the caller may determine
1083 * whether or not a lock was successfully freed by testing the return
1084 * value for -ENOENT.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 */
Marc Eshel150b3932007-01-18 16:15:35 -05001086int posix_lock_file(struct file *filp, struct file_lock *fl,
Andy Adamson5842add2006-03-26 01:37:26 -08001087 struct file_lock *conflock)
1088{
Al Viro496ad9a2013-01-23 17:07:38 -05001089 return __posix_lock_file(file_inode(filp), fl, conflock);
Andy Adamson5842add2006-03-26 01:37:26 -08001090}
Marc Eshel150b3932007-01-18 16:15:35 -05001091EXPORT_SYMBOL(posix_lock_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092
1093/**
1094 * posix_lock_file_wait - Apply a POSIX-style lock to a file
1095 * @filp: The file to apply the lock to
1096 * @fl: The lock to be applied
1097 *
1098 * Add a POSIX style lock to a file.
1099 * We merge adjacent & overlapping locks whenever possible.
1100 * POSIX locks are sorted by owner task, then by starting address
1101 */
1102int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
1103{
1104 int error;
1105 might_sleep ();
1106 for (;;) {
Marc Eshel150b3932007-01-18 16:15:35 -05001107 error = posix_lock_file(filp, fl, NULL);
Miklos Szeredibde74e42008-07-25 01:48:57 -07001108 if (error != FILE_LOCK_DEFERRED)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 break;
1110 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
1111 if (!error)
1112 continue;
1113
1114 locks_delete_block(fl);
1115 break;
1116 }
1117 return error;
1118}
1119EXPORT_SYMBOL(posix_lock_file_wait);
1120
1121/**
1122 * locks_mandatory_locked - Check for an active lock
1123 * @inode: the file to check
1124 *
1125 * Searches the inode's list of locks to find any POSIX locks which conflict.
1126 * This function is called from locks_verify_locked() only.
1127 */
1128int locks_mandatory_locked(struct inode *inode)
1129{
1130 fl_owner_t owner = current->files;
1131 struct file_lock *fl;
1132
1133 /*
1134 * Search the lock list for this inode for any POSIX locks.
1135 */
Jeff Layton1c8c6012013-06-21 08:58:15 -04001136 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
1138 if (!IS_POSIX(fl))
1139 continue;
1140 if (fl->fl_owner != owner)
1141 break;
1142 }
Jeff Layton1c8c6012013-06-21 08:58:15 -04001143 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 return fl ? -EAGAIN : 0;
1145}
1146
1147/**
1148 * locks_mandatory_area - Check for a conflicting lock
1149 * @read_write: %FLOCK_VERIFY_WRITE for exclusive access, %FLOCK_VERIFY_READ
1150 * for shared
1151 * @inode: the file to check
1152 * @filp: how the file was opened (if it was)
1153 * @offset: start of area to check
1154 * @count: length of area to check
1155 *
1156 * Searches the inode's list of locks to find any POSIX locks which conflict.
1157 * This function is called from rw_verify_area() and
1158 * locks_verify_truncate().
1159 */
1160int locks_mandatory_area(int read_write, struct inode *inode,
1161 struct file *filp, loff_t offset,
1162 size_t count)
1163{
1164 struct file_lock fl;
1165 int error;
1166
1167 locks_init_lock(&fl);
1168 fl.fl_owner = current->files;
1169 fl.fl_pid = current->tgid;
1170 fl.fl_file = filp;
1171 fl.fl_flags = FL_POSIX | FL_ACCESS;
1172 if (filp && !(filp->f_flags & O_NONBLOCK))
1173 fl.fl_flags |= FL_SLEEP;
1174 fl.fl_type = (read_write == FLOCK_VERIFY_WRITE) ? F_WRLCK : F_RDLCK;
1175 fl.fl_start = offset;
1176 fl.fl_end = offset + count - 1;
1177
1178 for (;;) {
Marc Eshel150b3932007-01-18 16:15:35 -05001179 error = __posix_lock_file(inode, &fl, NULL);
Miklos Szeredibde74e42008-07-25 01:48:57 -07001180 if (error != FILE_LOCK_DEFERRED)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 break;
1182 error = wait_event_interruptible(fl.fl_wait, !fl.fl_next);
1183 if (!error) {
1184 /*
1185 * If we've been sleeping someone might have
1186 * changed the permissions behind our back.
1187 */
Pavel Emelyanova16877c2007-10-01 14:41:11 -07001188 if (__mandatory_lock(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 continue;
1190 }
1191
1192 locks_delete_block(&fl);
1193 break;
1194 }
1195
1196 return error;
1197}
1198
1199EXPORT_SYMBOL(locks_mandatory_area);
1200
J. Bruce Fields778fc542011-07-26 18:25:49 -04001201static void lease_clear_pending(struct file_lock *fl, int arg)
1202{
1203 switch (arg) {
1204 case F_UNLCK:
1205 fl->fl_flags &= ~FL_UNLOCK_PENDING;
1206 /* fall through: */
1207 case F_RDLCK:
1208 fl->fl_flags &= ~FL_DOWNGRADE_PENDING;
1209 }
1210}
1211
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212/* We already had a lease on this file; just change its type */
1213int lease_modify(struct file_lock **before, int arg)
1214{
1215 struct file_lock *fl = *before;
1216 int error = assign_type(fl, arg);
1217
1218 if (error)
1219 return error;
J. Bruce Fields778fc542011-07-26 18:25:49 -04001220 lease_clear_pending(fl, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 locks_wake_up_blocks(fl);
Filipe Brandenburger3b6e2722012-07-27 00:42:52 -04001222 if (arg == F_UNLCK) {
1223 struct file *filp = fl->fl_file;
1224
1225 f_delown(filp);
1226 filp->f_owner.signum = 0;
J. Bruce Fields96d6d592012-07-27 16:18:00 -04001227 fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync);
1228 if (fl->fl_fasync != NULL) {
1229 printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync);
1230 fl->fl_fasync = NULL;
1231 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 locks_delete_lock(before);
Filipe Brandenburger3b6e2722012-07-27 00:42:52 -04001233 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 return 0;
1235}
1236
1237EXPORT_SYMBOL(lease_modify);
1238
J. Bruce Fields778fc542011-07-26 18:25:49 -04001239static bool past_time(unsigned long then)
1240{
1241 if (!then)
1242 /* 0 is a special value meaning "this never expires": */
1243 return false;
1244 return time_after(jiffies, then);
1245}
1246
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247static void time_out_leases(struct inode *inode)
1248{
1249 struct file_lock **before;
1250 struct file_lock *fl;
1251
1252 before = &inode->i_flock;
J. Bruce Fieldsab83fa42011-07-26 20:10:51 -04001253 while ((fl = *before) && IS_LEASE(fl) && lease_breaking(fl)) {
J. Bruce Fields778fc542011-07-26 18:25:49 -04001254 if (past_time(fl->fl_downgrade_time))
1255 lease_modify(before, F_RDLCK);
1256 if (past_time(fl->fl_break_time))
1257 lease_modify(before, F_UNLCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 if (fl == *before) /* lease_modify may have freed fl */
1259 before = &fl->fl_next;
1260 }
1261}
1262
1263/**
1264 * __break_lease - revoke all outstanding leases on file
1265 * @inode: the inode of the file to return
1266 * @mode: the open mode (read or write)
1267 *
david m. richter87250dd2007-05-09 16:10:27 -04001268 * break_lease (inlined for speed) has checked there already is at least
1269 * some kind of lock (maybe a lease) on this file. Leases are broken on
1270 * a call to open() or truncate(). This function can sleep unless you
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 * specified %O_NONBLOCK to your open().
1272 */
1273int __break_lease(struct inode *inode, unsigned int mode)
1274{
J. Bruce Fields778fc542011-07-26 18:25:49 -04001275 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 struct file_lock *new_fl, *flock;
1277 struct file_lock *fl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 unsigned long break_time;
1279 int i_have_this_lease = 0;
Al Viro8737c932009-12-24 06:47:55 -05001280 int want_write = (mode & O_ACCMODE) != O_RDONLY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281
Al Viro8737c932009-12-24 06:47:55 -05001282 new_fl = lease_alloc(NULL, want_write ? F_WRLCK : F_RDLCK);
Linus Torvalds6d4b9e32011-12-26 10:25:26 -08001283 if (IS_ERR(new_fl))
1284 return PTR_ERR(new_fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285
Jeff Layton1c8c6012013-06-21 08:58:15 -04001286 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287
1288 time_out_leases(inode);
1289
1290 flock = inode->i_flock;
1291 if ((flock == NULL) || !IS_LEASE(flock))
1292 goto out;
1293
J. Bruce Fields778fc542011-07-26 18:25:49 -04001294 if (!locks_conflict(flock, new_fl))
1295 goto out;
1296
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next)
1298 if (fl->fl_owner == current->files)
1299 i_have_this_lease = 1;
1300
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 break_time = 0;
1302 if (lease_break_time > 0) {
1303 break_time = jiffies + lease_break_time * HZ;
1304 if (break_time == 0)
1305 break_time++; /* so that 0 means no break time */
1306 }
1307
1308 for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) {
J. Bruce Fields778fc542011-07-26 18:25:49 -04001309 if (want_write) {
1310 if (fl->fl_flags & FL_UNLOCK_PENDING)
1311 continue;
1312 fl->fl_flags |= FL_UNLOCK_PENDING;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 fl->fl_break_time = break_time;
J. Bruce Fields778fc542011-07-26 18:25:49 -04001314 } else {
1315 if (lease_breaking(flock))
1316 continue;
1317 fl->fl_flags |= FL_DOWNGRADE_PENDING;
1318 fl->fl_downgrade_time = break_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 }
J. Bruce Fields778fc542011-07-26 18:25:49 -04001320 fl->fl_lmops->lm_break(fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 }
1322
1323 if (i_have_this_lease || (mode & O_NONBLOCK)) {
1324 error = -EWOULDBLOCK;
1325 goto out;
1326 }
1327
1328restart:
1329 break_time = flock->fl_break_time;
1330 if (break_time != 0) {
1331 break_time -= jiffies;
1332 if (break_time == 0)
1333 break_time++;
1334 }
Matthew Wilcox4321e012008-01-14 21:28:30 -07001335 locks_insert_block(flock, new_fl);
Jeff Layton1c8c6012013-06-21 08:58:15 -04001336 spin_unlock(&inode->i_lock);
Matthew Wilcox4321e012008-01-14 21:28:30 -07001337 error = wait_event_interruptible_timeout(new_fl->fl_wait,
1338 !new_fl->fl_next, break_time);
Jeff Layton1c8c6012013-06-21 08:58:15 -04001339 spin_lock(&inode->i_lock);
1340 locks_delete_block(new_fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 if (error >= 0) {
1342 if (error == 0)
1343 time_out_leases(inode);
J. Bruce Fields778fc542011-07-26 18:25:49 -04001344 /*
1345 * Wait for the next conflicting lease that has not been
1346 * broken yet
1347 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 for (flock = inode->i_flock; flock && IS_LEASE(flock);
1349 flock = flock->fl_next) {
J. Bruce Fields778fc542011-07-26 18:25:49 -04001350 if (locks_conflict(new_fl, flock))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 goto restart;
1352 }
1353 error = 0;
1354 }
1355
1356out:
Jeff Layton1c8c6012013-06-21 08:58:15 -04001357 spin_unlock(&inode->i_lock);
Linus Torvalds6d4b9e32011-12-26 10:25:26 -08001358 locks_free_lock(new_fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 return error;
1360}
1361
1362EXPORT_SYMBOL(__break_lease);
1363
1364/**
Randy Dunlapa6b91912008-03-19 17:01:00 -07001365 * lease_get_mtime - get the last modified time of an inode
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 * @inode: the inode
1367 * @time: pointer to a timespec which will contain the last modified time
1368 *
1369 * This is to force NFS clients to flush their caches for files with
1370 * exclusive leases. The justification is that if someone has an
Randy Dunlapa6b91912008-03-19 17:01:00 -07001371 * exclusive lease, then they could be modifying it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 */
1373void lease_get_mtime(struct inode *inode, struct timespec *time)
1374{
1375 struct file_lock *flock = inode->i_flock;
Jeff Layton0ee5c6d2012-08-02 15:46:30 -04001376 if (flock && IS_LEASE(flock) && (flock->fl_type == F_WRLCK))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 *time = current_fs_time(inode->i_sb);
1378 else
1379 *time = inode->i_mtime;
1380}
1381
1382EXPORT_SYMBOL(lease_get_mtime);
1383
1384/**
1385 * fcntl_getlease - Enquire what lease is currently active
1386 * @filp: the file
1387 *
1388 * The value returned by this function will be one of
1389 * (if no lease break is pending):
1390 *
1391 * %F_RDLCK to indicate a shared lease is held.
1392 *
1393 * %F_WRLCK to indicate an exclusive lease is held.
1394 *
1395 * %F_UNLCK to indicate no lease is held.
1396 *
1397 * (if a lease break is pending):
1398 *
1399 * %F_RDLCK to indicate an exclusive lease needs to be
1400 * changed to a shared lease (or removed).
1401 *
1402 * %F_UNLCK to indicate the lease needs to be removed.
1403 *
1404 * XXX: sfr & willy disagree over whether F_INPROGRESS
1405 * should be returned to userspace.
1406 */
1407int fcntl_getlease(struct file *filp)
1408{
1409 struct file_lock *fl;
Jeff Layton1c8c6012013-06-21 08:58:15 -04001410 struct inode *inode = file_inode(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 int type = F_UNLCK;
1412
Jeff Layton1c8c6012013-06-21 08:58:15 -04001413 spin_lock(&inode->i_lock);
Al Viro496ad9a2013-01-23 17:07:38 -05001414 time_out_leases(file_inode(filp));
1415 for (fl = file_inode(filp)->i_flock; fl && IS_LEASE(fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 fl = fl->fl_next) {
1417 if (fl->fl_file == filp) {
J. Bruce Fields778fc542011-07-26 18:25:49 -04001418 type = target_leasetype(fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 break;
1420 }
1421 }
Jeff Layton1c8c6012013-06-21 08:58:15 -04001422 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 return type;
1424}
1425
Jeff Laytond4f22d12013-06-21 08:58:11 -04001426static int generic_add_lease(struct file *filp, long arg, struct file_lock **flp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427{
KAMBAROV, ZAUR7eaae282005-07-07 17:57:06 -07001428 struct file_lock *fl, **before, **my_before = NULL, *lease;
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -08001429 struct dentry *dentry = filp->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 struct inode *inode = dentry->d_inode;
J. Bruce Fieldsc1f24ef2011-08-19 10:59:49 -04001431 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432
J. Bruce Fields096657b2010-10-30 17:31:14 -04001433 lease = *flp;
1434
J. Bruce Fields8335ebd2011-09-21 08:34:32 -04001435 error = -EAGAIN;
1436 if ((arg == F_RDLCK) && (atomic_read(&inode->i_writecount) > 0))
J. Bruce Fields096657b2010-10-30 17:31:14 -04001437 goto out;
J. Bruce Fields8335ebd2011-09-21 08:34:32 -04001438 if ((arg == F_WRLCK)
1439 && ((dentry->d_count > 1)
1440 || (atomic_read(&inode->i_count) > 1)))
J. Bruce Fields096657b2010-10-30 17:31:14 -04001441 goto out;
Pavel Emelyanov85c59582007-09-20 12:45:02 +04001442
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 /*
1444 * At this point, we know that if there is an exclusive
1445 * lease on this file, then we hold it on this filp
1446 * (otherwise our open of this file would have blocked).
1447 * And if we are trying to acquire an exclusive lease,
1448 * then the file is not open by anyone (including us)
1449 * except for this filp.
1450 */
J. Bruce Fieldsc1f24ef2011-08-19 10:59:49 -04001451 error = -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 for (before = &inode->i_flock;
1453 ((fl = *before) != NULL) && IS_LEASE(fl);
1454 before = &fl->fl_next) {
J. Bruce Fieldsc1f24ef2011-08-19 10:59:49 -04001455 if (fl->fl_file == filp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 my_before = before;
J. Bruce Fieldsc1f24ef2011-08-19 10:59:49 -04001457 continue;
1458 }
1459 /*
1460 * No exclusive leases if someone else has a lease on
1461 * this file:
1462 */
1463 if (arg == F_WRLCK)
1464 goto out;
1465 /*
1466 * Modifying our existing lease is OK, but no getting a
1467 * new lease if someone else is opening for write:
1468 */
1469 if (fl->fl_flags & FL_UNLOCK_PENDING)
1470 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 }
1472
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 if (my_before != NULL) {
J. Bruce Fields8fb47a42011-07-20 20:21:59 -04001474 error = lease->fl_lmops->lm_change(my_before, arg);
Christoph Hellwig51ee4b82010-10-31 08:35:10 -04001475 if (!error)
1476 *flp = *my_before;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 goto out;
1478 }
1479
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 error = -EINVAL;
1481 if (!leases_enable)
1482 goto out;
1483
Arnd Bergmannc5b1f0d2010-10-27 15:46:08 +02001484 locks_insert_lock(before, lease);
Pavel Emelyanov85c59582007-09-20 12:45:02 +04001485 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487out:
1488 return error;
1489}
J. Bruce Fields8335ebd2011-09-21 08:34:32 -04001490
Jeff Laytond4f22d12013-06-21 08:58:11 -04001491static int generic_delete_lease(struct file *filp, struct file_lock **flp)
J. Bruce Fields8335ebd2011-09-21 08:34:32 -04001492{
1493 struct file_lock *fl, **before;
1494 struct dentry *dentry = filp->f_path.dentry;
1495 struct inode *inode = dentry->d_inode;
1496
1497 for (before = &inode->i_flock;
1498 ((fl = *before) != NULL) && IS_LEASE(fl);
1499 before = &fl->fl_next) {
1500 if (fl->fl_file != filp)
1501 continue;
1502 return (*flp)->fl_lmops->lm_change(before, F_UNLCK);
1503 }
1504 return -EAGAIN;
1505}
1506
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507/**
1508 * generic_setlease - sets a lease on an open file
1509 * @filp: file pointer
1510 * @arg: type of lease to obtain
1511 * @flp: input - file_lock to use, output - file_lock inserted
1512 *
1513 * The (input) flp->fl_lmops->lm_break function is required
1514 * by break_lease().
1515 *
Jeff Layton1c8c6012013-06-21 08:58:15 -04001516 * Called with inode->i_lock held.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 */
1518int generic_setlease(struct file *filp, long arg, struct file_lock **flp)
1519{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 struct dentry *dentry = filp->f_path.dentry;
1521 struct inode *inode = dentry->d_inode;
J. Bruce Fields8335ebd2011-09-21 08:34:32 -04001522 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523
Eric W. Biederman8e96e3b2012-03-03 21:17:15 -08001524 if ((!uid_eq(current_fsuid(), inode->i_uid)) && !capable(CAP_LEASE))
J. Bruce Fields8335ebd2011-09-21 08:34:32 -04001525 return -EACCES;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526 if (!S_ISREG(inode->i_mode))
J. Bruce Fields8335ebd2011-09-21 08:34:32 -04001527 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 error = security_file_lock(filp, arg);
1529 if (error)
J. Bruce Fields8335ebd2011-09-21 08:34:32 -04001530 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531
1532 time_out_leases(inode);
1533
1534 BUG_ON(!(*flp)->fl_lmops->lm_break);
1535
J. Bruce Fields8335ebd2011-09-21 08:34:32 -04001536 switch (arg) {
1537 case F_UNLCK:
1538 return generic_delete_lease(filp, flp);
1539 case F_RDLCK:
1540 case F_WRLCK:
1541 return generic_add_lease(filp, arg, flp);
1542 default:
Dave Jones8d657eb2012-07-13 13:35:36 -04001543 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545}
Christoph Hellwig0af1a452007-07-31 00:39:22 -07001546EXPORT_SYMBOL(generic_setlease);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547
Arnd Bergmannb89f4322010-09-18 15:09:31 +02001548static int __vfs_setlease(struct file *filp, long arg, struct file_lock **lease)
1549{
1550 if (filp->f_op && filp->f_op->setlease)
1551 return filp->f_op->setlease(filp, arg, lease);
1552 else
1553 return generic_setlease(filp, arg, lease);
1554}
1555
1556/**
J. Bruce Fieldsa9933ce2007-06-07 17:09:49 -04001557 * vfs_setlease - sets a lease on an open file
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 * @filp: file pointer
1559 * @arg: type of lease to obtain
1560 * @lease: file_lock to use
1561 *
1562 * Call this to establish a lease on the file.
J. Bruce Fields8fb47a42011-07-20 20:21:59 -04001563 * The (*lease)->fl_lmops->lm_break operation must be set; if not,
J. Bruce Fieldsf9ffed22006-11-14 15:51:40 -05001564 * break_lease will oops!
1565 *
1566 * This will call the filesystem's setlease file method, if
1567 * defined. Note that there is no getlease method; instead, the
1568 * filesystem setlease method should call back to setlease() to
1569 * add a lease to the inode's lease list, where fcntl_getlease() can
1570 * find it. Since fcntl_getlease() only reports whether the current
1571 * task holds a lease, a cluster filesystem need only do this for
1572 * leases held by processes on this node.
1573 *
1574 * There is also no break_lease method; filesystems that
Adam Buchbinderc9404c92009-12-18 15:40:42 -05001575 * handle their own leases should break leases themselves from the
J. Bruce Fieldsf9ffed22006-11-14 15:51:40 -05001576 * filesystem's open, create, and (on truncate) setattr methods.
1577 *
1578 * Warning: the only current setlease methods exist only to disable
1579 * leases in certain cases. More vfs changes may be required to
1580 * allow a full filesystem lease implementation.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 */
1582
J. Bruce Fieldsa9933ce2007-06-07 17:09:49 -04001583int vfs_setlease(struct file *filp, long arg, struct file_lock **lease)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584{
Jeff Layton1c8c6012013-06-21 08:58:15 -04001585 struct inode *inode = file_inode(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 int error;
1587
Jeff Layton1c8c6012013-06-21 08:58:15 -04001588 spin_lock(&inode->i_lock);
Arnd Bergmannb89f4322010-09-18 15:09:31 +02001589 error = __vfs_setlease(filp, arg, lease);
Jeff Layton1c8c6012013-06-21 08:58:15 -04001590 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591
1592 return error;
1593}
J. Bruce Fieldsa9933ce2007-06-07 17:09:49 -04001594EXPORT_SYMBOL_GPL(vfs_setlease);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595
J. Bruce Fields0ceaf6c2010-10-30 17:31:13 -04001596static int do_fcntl_delete_lease(struct file *filp)
1597{
1598 struct file_lock fl, *flp = &fl;
1599
1600 lease_init(filp, F_UNLCK, flp);
1601
1602 return vfs_setlease(filp, F_UNLCK, &flp);
1603}
1604
1605static int do_fcntl_add_lease(unsigned int fd, struct file *filp, long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606{
J. Bruce Fields3df057a2010-11-03 16:49:44 -04001607 struct file_lock *fl, *ret;
Jeff Layton1c8c6012013-06-21 08:58:15 -04001608 struct inode *inode = file_inode(filp);
Linus Torvaldsf7347ce2010-10-27 12:38:12 -04001609 struct fasync_struct *new;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 int error;
1611
Arnd Bergmannc5b1f0d2010-10-27 15:46:08 +02001612 fl = lease_alloc(filp, arg);
1613 if (IS_ERR(fl))
1614 return PTR_ERR(fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615
Linus Torvaldsf7347ce2010-10-27 12:38:12 -04001616 new = fasync_alloc();
1617 if (!new) {
1618 locks_free_lock(fl);
1619 return -ENOMEM;
1620 }
J. Bruce Fields3df057a2010-11-03 16:49:44 -04001621 ret = fl;
Jeff Layton1c8c6012013-06-21 08:58:15 -04001622 spin_lock(&inode->i_lock);
J. Bruce Fields8896b932010-11-03 18:09:18 -04001623 error = __vfs_setlease(filp, arg, &ret);
Christoph Hellwig51ee4b82010-10-31 08:35:10 -04001624 if (error) {
Jeff Layton1c8c6012013-06-21 08:58:15 -04001625 spin_unlock(&inode->i_lock);
Christoph Hellwig51ee4b82010-10-31 08:35:10 -04001626 locks_free_lock(fl);
1627 goto out_free_fasync;
1628 }
J. Bruce Fields3df057a2010-11-03 16:49:44 -04001629 if (ret != fl)
1630 locks_free_lock(fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631
Linus Torvaldsf7347ce2010-10-27 12:38:12 -04001632 /*
1633 * fasync_insert_entry() returns the old entry if any.
1634 * If there was no old entry, then it used 'new' and
1635 * inserted it into the fasync list. Clear new so that
1636 * we don't release it here.
1637 */
J. Bruce Fields3df057a2010-11-03 16:49:44 -04001638 if (!fasync_insert_entry(fd, filp, &ret->fl_fasync, new))
Linus Torvaldsf7347ce2010-10-27 12:38:12 -04001639 new = NULL;
1640
J. Bruce Fields8896b932010-11-03 18:09:18 -04001641 error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0);
Jeff Layton1c8c6012013-06-21 08:58:15 -04001642 spin_unlock(&inode->i_lock);
Christoph Hellwig51ee4b82010-10-31 08:35:10 -04001643
1644out_free_fasync:
Linus Torvaldsf7347ce2010-10-27 12:38:12 -04001645 if (new)
1646 fasync_free(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 return error;
1648}
1649
1650/**
J. Bruce Fields0ceaf6c2010-10-30 17:31:13 -04001651 * fcntl_setlease - sets a lease on an open file
1652 * @fd: open file descriptor
1653 * @filp: file pointer
1654 * @arg: type of lease to obtain
1655 *
1656 * Call this fcntl to establish a lease on the file.
1657 * Note that you also need to call %F_SETSIG to
1658 * receive a signal when the lease is broken.
1659 */
1660int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
1661{
1662 if (arg == F_UNLCK)
1663 return do_fcntl_delete_lease(filp);
1664 return do_fcntl_add_lease(fd, filp, arg);
1665}
1666
1667/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 * flock_lock_file_wait - Apply a FLOCK-style lock to a file
1669 * @filp: The file to apply the lock to
1670 * @fl: The lock to be applied
1671 *
1672 * Add a FLOCK style lock to a file.
1673 */
1674int flock_lock_file_wait(struct file *filp, struct file_lock *fl)
1675{
1676 int error;
1677 might_sleep();
1678 for (;;) {
1679 error = flock_lock_file(filp, fl);
Miklos Szeredibde74e42008-07-25 01:48:57 -07001680 if (error != FILE_LOCK_DEFERRED)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 break;
1682 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
1683 if (!error)
1684 continue;
1685
1686 locks_delete_block(fl);
1687 break;
1688 }
1689 return error;
1690}
1691
1692EXPORT_SYMBOL(flock_lock_file_wait);
1693
1694/**
1695 * sys_flock: - flock() system call.
1696 * @fd: the file descriptor to lock.
1697 * @cmd: the type of lock to apply.
1698 *
1699 * Apply a %FL_FLOCK style lock to an open file descriptor.
1700 * The @cmd can be one of
1701 *
1702 * %LOCK_SH -- a shared lock.
1703 *
1704 * %LOCK_EX -- an exclusive lock.
1705 *
1706 * %LOCK_UN -- remove an existing lock.
1707 *
1708 * %LOCK_MAND -- a `mandatory' flock. This exists to emulate Windows Share Modes.
1709 *
1710 * %LOCK_MAND can be combined with %LOCK_READ or %LOCK_WRITE to allow other
1711 * processes read and write access respectively.
1712 */
Heiko Carstens002c8972009-01-14 14:14:18 +01001713SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714{
Al Viro2903ff02012-08-28 12:52:22 -04001715 struct fd f = fdget(fd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 struct file_lock *lock;
1717 int can_sleep, unlock;
1718 int error;
1719
1720 error = -EBADF;
Al Viro2903ff02012-08-28 12:52:22 -04001721 if (!f.file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 goto out;
1723
1724 can_sleep = !(cmd & LOCK_NB);
1725 cmd &= ~LOCK_NB;
1726 unlock = (cmd == LOCK_UN);
1727
Al Viroaeb5d722008-09-02 15:28:45 -04001728 if (!unlock && !(cmd & LOCK_MAND) &&
Al Viro2903ff02012-08-28 12:52:22 -04001729 !(f.file->f_mode & (FMODE_READ|FMODE_WRITE)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 goto out_putf;
1731
Al Viro2903ff02012-08-28 12:52:22 -04001732 error = flock_make_lock(f.file, &lock, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 if (error)
1734 goto out_putf;
1735 if (can_sleep)
1736 lock->fl_flags |= FL_SLEEP;
1737
Al Viro2903ff02012-08-28 12:52:22 -04001738 error = security_file_lock(f.file, lock->fl_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 if (error)
1740 goto out_free;
1741
Al Viro2903ff02012-08-28 12:52:22 -04001742 if (f.file->f_op && f.file->f_op->flock)
1743 error = f.file->f_op->flock(f.file,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 (can_sleep) ? F_SETLKW : F_SETLK,
1745 lock);
1746 else
Al Viro2903ff02012-08-28 12:52:22 -04001747 error = flock_lock_file_wait(f.file, lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748
1749 out_free:
Trond Myklebust993dfa82006-03-31 02:30:55 -08001750 locks_free_lock(lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751
1752 out_putf:
Al Viro2903ff02012-08-28 12:52:22 -04001753 fdput(f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 out:
1755 return error;
1756}
1757
J. Bruce Fields3ee17ab2007-02-21 00:58:50 -05001758/**
1759 * vfs_test_lock - test file byte range lock
1760 * @filp: The file to test lock for
J. Bruce Fields6924c552007-05-11 16:22:50 -04001761 * @fl: The lock to test; also used to hold result
J. Bruce Fields3ee17ab2007-02-21 00:58:50 -05001762 *
1763 * Returns -ERRNO on failure. Indicates presence of conflicting lock by
1764 * setting conf->fl_type to something other than F_UNLCK.
1765 */
1766int vfs_test_lock(struct file *filp, struct file_lock *fl)
1767{
1768 if (filp->f_op && filp->f_op->lock)
1769 return filp->f_op->lock(filp, F_GETLK, fl);
1770 posix_test_lock(filp, fl);
1771 return 0;
1772}
1773EXPORT_SYMBOL_GPL(vfs_test_lock);
1774
J. Bruce Fieldsc2fa1b82007-02-20 16:10:11 -05001775static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl)
1776{
1777 flock->l_pid = fl->fl_pid;
1778#if BITS_PER_LONG == 32
1779 /*
1780 * Make sure we can represent the posix lock via
1781 * legacy 32bit flock.
1782 */
1783 if (fl->fl_start > OFFT_OFFSET_MAX)
1784 return -EOVERFLOW;
1785 if (fl->fl_end != OFFSET_MAX && fl->fl_end > OFFT_OFFSET_MAX)
1786 return -EOVERFLOW;
1787#endif
1788 flock->l_start = fl->fl_start;
1789 flock->l_len = fl->fl_end == OFFSET_MAX ? 0 :
1790 fl->fl_end - fl->fl_start + 1;
1791 flock->l_whence = 0;
J. Bruce Fields129a84d2007-05-10 18:38:43 -04001792 flock->l_type = fl->fl_type;
J. Bruce Fieldsc2fa1b82007-02-20 16:10:11 -05001793 return 0;
1794}
1795
1796#if BITS_PER_LONG == 32
1797static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl)
1798{
1799 flock->l_pid = fl->fl_pid;
1800 flock->l_start = fl->fl_start;
1801 flock->l_len = fl->fl_end == OFFSET_MAX ? 0 :
1802 fl->fl_end - fl->fl_start + 1;
1803 flock->l_whence = 0;
1804 flock->l_type = fl->fl_type;
1805}
1806#endif
1807
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808/* Report the first existing lock that would conflict with l.
1809 * This implements the F_GETLK command of fcntl().
1810 */
1811int fcntl_getlk(struct file *filp, struct flock __user *l)
1812{
Marc Eshel9d6a8c52007-02-21 00:55:18 -05001813 struct file_lock file_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 struct flock flock;
1815 int error;
1816
1817 error = -EFAULT;
1818 if (copy_from_user(&flock, l, sizeof(flock)))
1819 goto out;
1820 error = -EINVAL;
1821 if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK))
1822 goto out;
1823
1824 error = flock_to_posix_lock(filp, &file_lock, &flock);
1825 if (error)
1826 goto out;
1827
J. Bruce Fields3ee17ab2007-02-21 00:58:50 -05001828 error = vfs_test_lock(filp, &file_lock);
1829 if (error)
1830 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831
Marc Eshel9d6a8c52007-02-21 00:55:18 -05001832 flock.l_type = file_lock.fl_type;
1833 if (file_lock.fl_type != F_UNLCK) {
1834 error = posix_lock_to_flock(&flock, &file_lock);
J. Bruce Fieldsc2fa1b82007-02-20 16:10:11 -05001835 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837 }
1838 error = -EFAULT;
1839 if (!copy_to_user(l, &flock, sizeof(flock)))
1840 error = 0;
1841out:
1842 return error;
1843}
1844
Marc Eshel7723ec92007-01-18 15:08:55 -05001845/**
1846 * vfs_lock_file - file byte range lock
1847 * @filp: The file to apply the lock to
1848 * @cmd: type of locking operation (F_SETLK, F_GETLK, etc.)
1849 * @fl: The lock to be applied
Marc Eshel150b3932007-01-18 16:15:35 -05001850 * @conf: Place to return a copy of the conflicting lock, if found.
1851 *
1852 * A caller that doesn't care about the conflicting lock may pass NULL
1853 * as the final argument.
1854 *
1855 * If the filesystem defines a private ->lock() method, then @conf will
1856 * be left unchanged; so a caller that cares should initialize it to
1857 * some acceptable default.
Marc Eshel2beb6612006-12-05 23:31:28 -05001858 *
1859 * To avoid blocking kernel daemons, such as lockd, that need to acquire POSIX
1860 * locks, the ->lock() interface may return asynchronously, before the lock has
1861 * been granted or denied by the underlying filesystem, if (and only if)
J. Bruce Fields8fb47a42011-07-20 20:21:59 -04001862 * lm_grant is set. Callers expecting ->lock() to return asynchronously
Marc Eshel2beb6612006-12-05 23:31:28 -05001863 * will only use F_SETLK, not F_SETLKW; they will set FL_SLEEP if (and only if)
1864 * the request is for a blocking lock. When ->lock() does return asynchronously,
J. Bruce Fields8fb47a42011-07-20 20:21:59 -04001865 * it must return FILE_LOCK_DEFERRED, and call ->lm_grant() when the lock
Marc Eshel2beb6612006-12-05 23:31:28 -05001866 * request completes.
1867 * If the request is for non-blocking lock the file system should return
Miklos Szeredibde74e42008-07-25 01:48:57 -07001868 * FILE_LOCK_DEFERRED then try to get the lock and call the callback routine
1869 * with the result. If the request timed out the callback routine will return a
Marc Eshel2beb6612006-12-05 23:31:28 -05001870 * nonzero return code and the file system should release the lock. The file
1871 * system is also responsible to keep a corresponding posix lock when it
1872 * grants a lock so the VFS can find out which locks are locally held and do
1873 * the correct lock cleanup when required.
1874 * The underlying filesystem must not drop the kernel lock or call
J. Bruce Fields8fb47a42011-07-20 20:21:59 -04001875 * ->lm_grant() before returning to the caller with a FILE_LOCK_DEFERRED
Marc Eshel2beb6612006-12-05 23:31:28 -05001876 * return code.
Marc Eshel7723ec92007-01-18 15:08:55 -05001877 */
Marc Eshel150b3932007-01-18 16:15:35 -05001878int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf)
Marc Eshel7723ec92007-01-18 15:08:55 -05001879{
1880 if (filp->f_op && filp->f_op->lock)
1881 return filp->f_op->lock(filp, cmd, fl);
1882 else
Marc Eshel150b3932007-01-18 16:15:35 -05001883 return posix_lock_file(filp, fl, conf);
Marc Eshel7723ec92007-01-18 15:08:55 -05001884}
1885EXPORT_SYMBOL_GPL(vfs_lock_file);
1886
Miklos Szeredib648a6d2008-07-25 01:48:57 -07001887static int do_lock_file_wait(struct file *filp, unsigned int cmd,
1888 struct file_lock *fl)
1889{
1890 int error;
1891
1892 error = security_file_lock(filp, fl->fl_type);
1893 if (error)
1894 return error;
1895
Miklos Szeredi764c76b2008-07-25 01:48:58 -07001896 for (;;) {
1897 error = vfs_lock_file(filp, cmd, fl, NULL);
1898 if (error != FILE_LOCK_DEFERRED)
Miklos Szeredib648a6d2008-07-25 01:48:57 -07001899 break;
Miklos Szeredi764c76b2008-07-25 01:48:58 -07001900 error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
1901 if (!error)
1902 continue;
1903
1904 locks_delete_block(fl);
1905 break;
Miklos Szeredib648a6d2008-07-25 01:48:57 -07001906 }
1907
1908 return error;
1909}
1910
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911/* Apply the lock described by l to an open file descriptor.
1912 * This implements both the F_SETLK and F_SETLKW commands of fcntl().
1913 */
Peter Staubachc2936212005-07-27 11:45:09 -07001914int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd,
1915 struct flock __user *l)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916{
1917 struct file_lock *file_lock = locks_alloc_lock();
1918 struct flock flock;
1919 struct inode *inode;
Al Viro0b2bac22008-05-06 13:58:34 -04001920 struct file *f;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 int error;
1922
1923 if (file_lock == NULL)
1924 return -ENOLCK;
1925
1926 /*
1927 * This might block, so we do it before checking the inode.
1928 */
1929 error = -EFAULT;
1930 if (copy_from_user(&flock, l, sizeof(flock)))
1931 goto out;
1932
Al Viro496ad9a2013-01-23 17:07:38 -05001933 inode = file_inode(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934
1935 /* Don't allow mandatory locks on files that may be memory mapped
1936 * and shared.
1937 */
Pavel Emelyanova16877c2007-10-01 14:41:11 -07001938 if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 error = -EAGAIN;
1940 goto out;
1941 }
1942
Peter Staubachc2936212005-07-27 11:45:09 -07001943again:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 error = flock_to_posix_lock(filp, file_lock, &flock);
1945 if (error)
1946 goto out;
1947 if (cmd == F_SETLKW) {
1948 file_lock->fl_flags |= FL_SLEEP;
1949 }
1950
1951 error = -EBADF;
1952 switch (flock.l_type) {
1953 case F_RDLCK:
1954 if (!(filp->f_mode & FMODE_READ))
1955 goto out;
1956 break;
1957 case F_WRLCK:
1958 if (!(filp->f_mode & FMODE_WRITE))
1959 goto out;
1960 break;
1961 case F_UNLCK:
1962 break;
1963 default:
1964 error = -EINVAL;
1965 goto out;
1966 }
1967
Miklos Szeredib648a6d2008-07-25 01:48:57 -07001968 error = do_lock_file_wait(filp, cmd, file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969
Peter Staubachc2936212005-07-27 11:45:09 -07001970 /*
1971 * Attempt to detect a close/fcntl race and recover by
1972 * releasing the lock that was just acquired.
1973 */
Al Viro0b2bac22008-05-06 13:58:34 -04001974 /*
1975 * we need that spin_lock here - it prevents reordering between
1976 * update of inode->i_flock and check for it done in close().
1977 * rcu_read_lock() wouldn't do.
1978 */
1979 spin_lock(&current->files->file_lock);
1980 f = fcheck(fd);
1981 spin_unlock(&current->files->file_lock);
1982 if (!error && f != filp && flock.l_type != F_UNLCK) {
Peter Staubachc2936212005-07-27 11:45:09 -07001983 flock.l_type = F_UNLCK;
1984 goto again;
1985 }
1986
1987out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 locks_free_lock(file_lock);
1989 return error;
1990}
1991
1992#if BITS_PER_LONG == 32
1993/* Report the first existing lock that would conflict with l.
1994 * This implements the F_GETLK command of fcntl().
1995 */
1996int fcntl_getlk64(struct file *filp, struct flock64 __user *l)
1997{
Marc Eshel9d6a8c52007-02-21 00:55:18 -05001998 struct file_lock file_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999 struct flock64 flock;
2000 int error;
2001
2002 error = -EFAULT;
2003 if (copy_from_user(&flock, l, sizeof(flock)))
2004 goto out;
2005 error = -EINVAL;
2006 if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK))
2007 goto out;
2008
2009 error = flock64_to_posix_lock(filp, &file_lock, &flock);
2010 if (error)
2011 goto out;
2012
J. Bruce Fields3ee17ab2007-02-21 00:58:50 -05002013 error = vfs_test_lock(filp, &file_lock);
2014 if (error)
2015 goto out;
2016
Marc Eshel9d6a8c52007-02-21 00:55:18 -05002017 flock.l_type = file_lock.fl_type;
2018 if (file_lock.fl_type != F_UNLCK)
2019 posix_lock_to_flock64(&flock, &file_lock);
2020
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021 error = -EFAULT;
2022 if (!copy_to_user(l, &flock, sizeof(flock)))
2023 error = 0;
2024
2025out:
2026 return error;
2027}
2028
2029/* Apply the lock described by l to an open file descriptor.
2030 * This implements both the F_SETLK and F_SETLKW commands of fcntl().
2031 */
Peter Staubachc2936212005-07-27 11:45:09 -07002032int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd,
2033 struct flock64 __user *l)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034{
2035 struct file_lock *file_lock = locks_alloc_lock();
2036 struct flock64 flock;
2037 struct inode *inode;
Al Viro0b2bac22008-05-06 13:58:34 -04002038 struct file *f;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 int error;
2040
2041 if (file_lock == NULL)
2042 return -ENOLCK;
2043
2044 /*
2045 * This might block, so we do it before checking the inode.
2046 */
2047 error = -EFAULT;
2048 if (copy_from_user(&flock, l, sizeof(flock)))
2049 goto out;
2050
Al Viro496ad9a2013-01-23 17:07:38 -05002051 inode = file_inode(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052
2053 /* Don't allow mandatory locks on files that may be memory mapped
2054 * and shared.
2055 */
Pavel Emelyanova16877c2007-10-01 14:41:11 -07002056 if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057 error = -EAGAIN;
2058 goto out;
2059 }
2060
Peter Staubachc2936212005-07-27 11:45:09 -07002061again:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062 error = flock64_to_posix_lock(filp, file_lock, &flock);
2063 if (error)
2064 goto out;
2065 if (cmd == F_SETLKW64) {
2066 file_lock->fl_flags |= FL_SLEEP;
2067 }
2068
2069 error = -EBADF;
2070 switch (flock.l_type) {
2071 case F_RDLCK:
2072 if (!(filp->f_mode & FMODE_READ))
2073 goto out;
2074 break;
2075 case F_WRLCK:
2076 if (!(filp->f_mode & FMODE_WRITE))
2077 goto out;
2078 break;
2079 case F_UNLCK:
2080 break;
2081 default:
2082 error = -EINVAL;
2083 goto out;
2084 }
2085
Miklos Szeredib648a6d2008-07-25 01:48:57 -07002086 error = do_lock_file_wait(filp, cmd, file_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087
Peter Staubachc2936212005-07-27 11:45:09 -07002088 /*
2089 * Attempt to detect a close/fcntl race and recover by
2090 * releasing the lock that was just acquired.
2091 */
Al Viro0b2bac22008-05-06 13:58:34 -04002092 spin_lock(&current->files->file_lock);
2093 f = fcheck(fd);
2094 spin_unlock(&current->files->file_lock);
2095 if (!error && f != filp && flock.l_type != F_UNLCK) {
Peter Staubachc2936212005-07-27 11:45:09 -07002096 flock.l_type = F_UNLCK;
2097 goto again;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098 }
2099
2100out:
2101 locks_free_lock(file_lock);
2102 return error;
2103}
2104#endif /* BITS_PER_LONG == 32 */
2105
2106/*
2107 * This function is called when the file is being removed
2108 * from the task's fd array. POSIX locks belonging to this task
2109 * are deleted at this time.
2110 */
2111void locks_remove_posix(struct file *filp, fl_owner_t owner)
2112{
Miklos Szerediff7b86b2006-06-23 02:05:11 -07002113 struct file_lock lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114
2115 /*
2116 * If there are no locks held on this file, we don't need to call
2117 * posix_lock_file(). Another process could be setting a lock on this
2118 * file at the same time, but we wouldn't remove that lock anyway.
2119 */
Al Viro496ad9a2013-01-23 17:07:38 -05002120 if (!file_inode(filp)->i_flock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121 return;
2122
2123 lock.fl_type = F_UNLCK;
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07002124 lock.fl_flags = FL_POSIX | FL_CLOSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125 lock.fl_start = 0;
2126 lock.fl_end = OFFSET_MAX;
2127 lock.fl_owner = owner;
2128 lock.fl_pid = current->tgid;
2129 lock.fl_file = filp;
2130 lock.fl_ops = NULL;
2131 lock.fl_lmops = NULL;
2132
Marc Eshel150b3932007-01-18 16:15:35 -05002133 vfs_lock_file(filp, F_SETLK, &lock, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135 if (lock.fl_ops && lock.fl_ops->fl_release_private)
2136 lock.fl_ops->fl_release_private(&lock);
2137}
2138
2139EXPORT_SYMBOL(locks_remove_posix);
2140
2141/*
2142 * This function is called on the last close of an open file.
2143 */
2144void locks_remove_flock(struct file *filp)
2145{
Al Viro496ad9a2013-01-23 17:07:38 -05002146 struct inode * inode = file_inode(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147 struct file_lock *fl;
2148 struct file_lock **before;
2149
2150 if (!inode->i_flock)
2151 return;
2152
2153 if (filp->f_op && filp->f_op->flock) {
2154 struct file_lock fl = {
2155 .fl_pid = current->tgid,
2156 .fl_file = filp,
2157 .fl_flags = FL_FLOCK,
2158 .fl_type = F_UNLCK,
2159 .fl_end = OFFSET_MAX,
2160 };
2161 filp->f_op->flock(filp, F_SETLKW, &fl);
Trond Myklebust80fec4c2005-06-22 17:16:31 +00002162 if (fl.fl_ops && fl.fl_ops->fl_release_private)
2163 fl.fl_ops->fl_release_private(&fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164 }
2165
Jeff Layton1c8c6012013-06-21 08:58:15 -04002166 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167 before = &inode->i_flock;
2168
2169 while ((fl = *before) != NULL) {
2170 if (fl->fl_file == filp) {
Peter Staubachc2936212005-07-27 11:45:09 -07002171 if (IS_FLOCK(fl)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172 locks_delete_lock(before);
2173 continue;
2174 }
2175 if (IS_LEASE(fl)) {
2176 lease_modify(before, F_UNLCK);
2177 continue;
2178 }
2179 /* What? */
2180 BUG();
2181 }
2182 before = &fl->fl_next;
2183 }
Jeff Layton1c8c6012013-06-21 08:58:15 -04002184 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185}
2186
2187/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188 * posix_unblock_lock - stop waiting for a file lock
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189 * @waiter: the lock which was waiting
2190 *
2191 * lockd needs to block waiting for locks.
2192 */
J. Bruce Fields64a318e2006-01-03 09:55:46 +01002193int
Jeff Laytonf891a292013-06-21 08:58:09 -04002194posix_unblock_lock(struct file_lock *waiter)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195{
J. Bruce Fields64a318e2006-01-03 09:55:46 +01002196 int status = 0;
2197
Jeff Layton1c8c6012013-06-21 08:58:15 -04002198 spin_lock(&file_lock_lock);
J. Bruce Fields5996a292006-01-03 09:55:44 +01002199 if (waiter->fl_next)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200 __locks_delete_block(waiter);
J. Bruce Fields64a318e2006-01-03 09:55:46 +01002201 else
2202 status = -ENOENT;
Jeff Layton1c8c6012013-06-21 08:58:15 -04002203 spin_unlock(&file_lock_lock);
J. Bruce Fields64a318e2006-01-03 09:55:46 +01002204 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206EXPORT_SYMBOL(posix_unblock_lock);
2207
Marc Eshel9b9d2ab2007-01-18 17:52:58 -05002208/**
2209 * vfs_cancel_lock - file byte range unblock lock
2210 * @filp: The file to apply the unblock to
2211 * @fl: The lock to be unblocked
2212 *
2213 * Used by lock managers to cancel blocked requests
2214 */
2215int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
2216{
2217 if (filp->f_op && filp->f_op->lock)
2218 return filp->f_op->lock(filp, F_CANCELLK, fl);
2219 return 0;
2220}
2221
2222EXPORT_SYMBOL_GPL(vfs_cancel_lock);
2223
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002224#ifdef CONFIG_PROC_FS
Alexey Dobriyand8ba7a32008-10-04 22:34:18 +04002225#include <linux/proc_fs.h>
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002226#include <linux/seq_file.h>
2227
2228static void lock_get_status(struct seq_file *f, struct file_lock *fl,
Jerome Marchand99dc8292010-10-26 14:22:33 -07002229 loff_t id, char *pfx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230{
2231 struct inode *inode = NULL;
Vitaliy Gusevab1f1612008-01-17 00:07:08 +00002232 unsigned int fl_pid;
2233
2234 if (fl->fl_nspid)
Pavel Emelyanov6c5f3e72008-02-08 04:19:20 -08002235 fl_pid = pid_vnr(fl->fl_nspid);
Vitaliy Gusevab1f1612008-01-17 00:07:08 +00002236 else
2237 fl_pid = fl->fl_pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238
2239 if (fl->fl_file != NULL)
Al Viro496ad9a2013-01-23 17:07:38 -05002240 inode = file_inode(fl->fl_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241
Jerome Marchand99dc8292010-10-26 14:22:33 -07002242 seq_printf(f, "%lld:%s ", id, pfx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243 if (IS_POSIX(fl)) {
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002244 seq_printf(f, "%6s %s ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 (fl->fl_flags & FL_ACCESS) ? "ACCESS" : "POSIX ",
2246 (inode == NULL) ? "*NOINODE*" :
Pavel Emelyanova16877c2007-10-01 14:41:11 -07002247 mandatory_lock(inode) ? "MANDATORY" : "ADVISORY ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248 } else if (IS_FLOCK(fl)) {
2249 if (fl->fl_type & LOCK_MAND) {
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002250 seq_printf(f, "FLOCK MSNFS ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251 } else {
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002252 seq_printf(f, "FLOCK ADVISORY ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253 }
2254 } else if (IS_LEASE(fl)) {
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002255 seq_printf(f, "LEASE ");
J. Bruce Fieldsab83fa42011-07-26 20:10:51 -04002256 if (lease_breaking(fl))
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002257 seq_printf(f, "BREAKING ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258 else if (fl->fl_file)
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002259 seq_printf(f, "ACTIVE ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260 else
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002261 seq_printf(f, "BREAKER ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262 } else {
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002263 seq_printf(f, "UNKNOWN UNKNOWN ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264 }
2265 if (fl->fl_type & LOCK_MAND) {
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002266 seq_printf(f, "%s ",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267 (fl->fl_type & LOCK_READ)
2268 ? (fl->fl_type & LOCK_WRITE) ? "RW " : "READ "
2269 : (fl->fl_type & LOCK_WRITE) ? "WRITE" : "NONE ");
2270 } else {
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002271 seq_printf(f, "%s ",
J. Bruce Fieldsab83fa42011-07-26 20:10:51 -04002272 (lease_breaking(fl))
Jeff Layton0ee5c6d2012-08-02 15:46:30 -04002273 ? (fl->fl_type == F_UNLCK) ? "UNLCK" : "READ "
2274 : (fl->fl_type == F_WRLCK) ? "WRITE" : "READ ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275 }
2276 if (inode) {
2277#ifdef WE_CAN_BREAK_LSLK_NOW
Vitaliy Gusevab1f1612008-01-17 00:07:08 +00002278 seq_printf(f, "%d %s:%ld ", fl_pid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 inode->i_sb->s_id, inode->i_ino);
2280#else
2281 /* userspace relies on this representation of dev_t ;-( */
Vitaliy Gusevab1f1612008-01-17 00:07:08 +00002282 seq_printf(f, "%d %02x:%02x:%ld ", fl_pid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 MAJOR(inode->i_sb->s_dev),
2284 MINOR(inode->i_sb->s_dev), inode->i_ino);
2285#endif
2286 } else {
Vitaliy Gusevab1f1612008-01-17 00:07:08 +00002287 seq_printf(f, "%d <none>:0 ", fl_pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288 }
2289 if (IS_POSIX(fl)) {
2290 if (fl->fl_end == OFFSET_MAX)
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002291 seq_printf(f, "%Ld EOF\n", fl->fl_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292 else
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002293 seq_printf(f, "%Ld %Ld\n", fl->fl_start, fl->fl_end);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 } else {
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002295 seq_printf(f, "0 EOF\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296 }
2297}
2298
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002299static int locks_show(struct seq_file *f, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300{
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002301 struct file_lock *fl, *bfl;
2302
2303 fl = list_entry(v, struct file_lock, fl_link);
2304
Jerome Marchand99dc8292010-10-26 14:22:33 -07002305 lock_get_status(f, fl, *((loff_t *)f->private), "");
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002306
2307 list_for_each_entry(bfl, &fl->fl_block, fl_block)
Jerome Marchand99dc8292010-10-26 14:22:33 -07002308 lock_get_status(f, bfl, *((loff_t *)f->private), " ->");
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002309
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002310 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311}
2312
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002313static void *locks_start(struct seq_file *f, loff_t *pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314{
Jerome Marchand99dc8292010-10-26 14:22:33 -07002315 loff_t *p = f->private;
2316
Jeff Layton1c8c6012013-06-21 08:58:15 -04002317 spin_lock(&file_lock_lock);
Jerome Marchand99dc8292010-10-26 14:22:33 -07002318 *p = (*pos + 1);
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002319 return seq_list_start(&file_lock_list, *pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320}
2321
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002322static void *locks_next(struct seq_file *f, void *v, loff_t *pos)
2323{
Jerome Marchand99dc8292010-10-26 14:22:33 -07002324 loff_t *p = f->private;
2325 ++*p;
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002326 return seq_list_next(v, &file_lock_list, pos);
2327}
2328
2329static void locks_stop(struct seq_file *f, void *v)
2330{
Jeff Layton1c8c6012013-06-21 08:58:15 -04002331 spin_unlock(&file_lock_lock);
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002332}
2333
Alexey Dobriyand8ba7a32008-10-04 22:34:18 +04002334static const struct seq_operations locks_seq_operations = {
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002335 .start = locks_start,
2336 .next = locks_next,
2337 .stop = locks_stop,
2338 .show = locks_show,
2339};
Alexey Dobriyand8ba7a32008-10-04 22:34:18 +04002340
2341static int locks_open(struct inode *inode, struct file *filp)
2342{
Jerome Marchand99dc8292010-10-26 14:22:33 -07002343 return seq_open_private(filp, &locks_seq_operations, sizeof(loff_t));
Alexey Dobriyand8ba7a32008-10-04 22:34:18 +04002344}
2345
2346static const struct file_operations proc_locks_operations = {
2347 .open = locks_open,
2348 .read = seq_read,
2349 .llseek = seq_lseek,
Jerome Marchand99dc8292010-10-26 14:22:33 -07002350 .release = seq_release_private,
Alexey Dobriyand8ba7a32008-10-04 22:34:18 +04002351};
2352
2353static int __init proc_locks_init(void)
2354{
2355 proc_create("locks", 0, NULL, &proc_locks_operations);
2356 return 0;
2357}
2358module_init(proc_locks_init);
Pavel Emelyanov7f8ada92007-10-01 14:41:15 -07002359#endif
2360
Linus Torvalds1da177e2005-04-16 15:20:36 -07002361/**
2362 * lock_may_read - checks that the region is free of locks
2363 * @inode: the inode that is being read
2364 * @start: the first byte to read
2365 * @len: the number of bytes to read
2366 *
2367 * Emulates Windows locking requirements. Whole-file
2368 * mandatory locks (share modes) can prohibit a read and
2369 * byte-range POSIX locks can prohibit a read if they overlap.
2370 *
2371 * N.B. this function is only ever called
2372 * from knfsd and ownership of locks is never checked.
2373 */
2374int lock_may_read(struct inode *inode, loff_t start, unsigned long len)
2375{
2376 struct file_lock *fl;
2377 int result = 1;
Jeff Layton1c8c6012013-06-21 08:58:15 -04002378
2379 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
2381 if (IS_POSIX(fl)) {
2382 if (fl->fl_type == F_RDLCK)
2383 continue;
2384 if ((fl->fl_end < start) || (fl->fl_start > (start + len)))
2385 continue;
2386 } else if (IS_FLOCK(fl)) {
2387 if (!(fl->fl_type & LOCK_MAND))
2388 continue;
2389 if (fl->fl_type & LOCK_READ)
2390 continue;
2391 } else
2392 continue;
2393 result = 0;
2394 break;
2395 }
Jeff Layton1c8c6012013-06-21 08:58:15 -04002396 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002397 return result;
2398}
2399
2400EXPORT_SYMBOL(lock_may_read);
2401
2402/**
2403 * lock_may_write - checks that the region is free of locks
2404 * @inode: the inode that is being written
2405 * @start: the first byte to write
2406 * @len: the number of bytes to write
2407 *
2408 * Emulates Windows locking requirements. Whole-file
2409 * mandatory locks (share modes) can prohibit a write and
2410 * byte-range POSIX locks can prohibit a write if they overlap.
2411 *
2412 * N.B. this function is only ever called
2413 * from knfsd and ownership of locks is never checked.
2414 */
2415int lock_may_write(struct inode *inode, loff_t start, unsigned long len)
2416{
2417 struct file_lock *fl;
2418 int result = 1;
Jeff Layton1c8c6012013-06-21 08:58:15 -04002419
2420 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
2422 if (IS_POSIX(fl)) {
2423 if ((fl->fl_end < start) || (fl->fl_start > (start + len)))
2424 continue;
2425 } else if (IS_FLOCK(fl)) {
2426 if (!(fl->fl_type & LOCK_MAND))
2427 continue;
2428 if (fl->fl_type & LOCK_WRITE)
2429 continue;
2430 } else
2431 continue;
2432 result = 0;
2433 break;
2434 }
Jeff Layton1c8c6012013-06-21 08:58:15 -04002435 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436 return result;
2437}
2438
2439EXPORT_SYMBOL(lock_may_write);
2440
Linus Torvalds1da177e2005-04-16 15:20:36 -07002441static int __init filelock_init(void)
2442{
2443 filelock_cache = kmem_cache_create("file_lock_cache",
Miklos Szerediee19cc42011-07-07 13:06:09 +02002444 sizeof(struct file_lock), 0, SLAB_PANIC, NULL);
2445
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446 return 0;
2447}
2448
2449core_initcall(filelock_init);