PageRenderTime 117ms CodeModel.GetById 34ms app.highlight 69ms RepoModel.GetById 1ms app.codeStats 1ms

/linux-2.6.21.x/fs/locks.c

https://bitbucket.org/altlc/wive-rtnl-ralink-rt305x-routers-firmware-amod
C | 2284 lines | 1450 code | 242 blank | 592 comment | 418 complexity | 3227967cd345c1dd9a8b0a529f7f85e9 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/*
   2 *  linux/fs/locks.c
   3 *
   4 *  Provide support for fcntl()'s F_GETLK, F_SETLK, and F_SETLKW calls.
   5 *  Doug Evans (dje@spiff.uucp), August 07, 1992
   6 *
   7 *  Deadlock detection added.
   8 *  FIXME: one thing isn't handled yet:
   9 *	- mandatory locks (requires lots of changes elsewhere)
  10 *  Kelly Carmichael (kelly@[142.24.8.65]), September 17, 1994.
  11 *
  12 *  Miscellaneous edits, and a total rewrite of posix_lock_file() code.
  13 *  Kai Petzke (wpp@marie.physik.tu-berlin.de), 1994
  14 *  
  15 *  Converted file_lock_table to a linked list from an array, which eliminates
  16 *  the limits on how many active file locks are open.
  17 *  Chad Page (pageone@netcom.com), November 27, 1994
  18 * 
  19 *  Removed dependency on file descriptors. dup()'ed file descriptors now
  20 *  get the same locks as the original file descriptors, and a close() on
  21 *  any file descriptor removes ALL the locks on the file for the current
  22 *  process. Since locks still depend on the process id, locks are inherited
  23 *  after an exec() but not after a fork(). This agrees with POSIX, and both
  24 *  BSD and SVR4 practice.
  25 *  Andy Walker (andy@lysaker.kvaerner.no), February 14, 1995
  26 *
  27 *  Scrapped free list which is redundant now that we allocate locks
  28 *  dynamically with kmalloc()/kfree().
  29 *  Andy Walker (andy@lysaker.kvaerner.no), February 21, 1995
  30 *
  31 *  Implemented two lock personalities - FL_FLOCK and FL_POSIX.
  32 *
  33 *  FL_POSIX locks are created with calls to fcntl() and lockf() through the
  34 *  fcntl() system call. They have the semantics described above.
  35 *
  36 *  FL_FLOCK locks are created with calls to flock(), through the flock()
  37 *  system call, which is new. Old C libraries implement flock() via fcntl()
  38 *  and will continue to use the old, broken implementation.
  39 *
  40 *  FL_FLOCK locks follow the 4.4 BSD flock() semantics. They are associated
  41 *  with a file pointer (filp). As a result they can be shared by a parent
  42 *  process and its children after a fork(). They are removed when the last
  43 *  file descriptor referring to the file pointer is closed (unless explicitly
  44 *  unlocked). 
  45 *
  46 *  FL_FLOCK locks never deadlock, an existing lock is always removed before
  47 *  upgrading from shared to exclusive (or vice versa). When this happens
  48 *  any processes blocked by the current lock are woken up and allowed to
  49 *  run before the new lock is applied.
  50 *  Andy Walker (andy@lysaker.kvaerner.no), June 09, 1995
  51 *
  52 *  Removed some race conditions in flock_lock_file(), marked other possible
  53 *  races. Just grep for FIXME to see them. 
  54 *  Dmitry Gorodchanin (pgmdsg@ibi.com), February 09, 1996.
  55 *
  56 *  Addressed Dmitry's concerns. Deadlock checking no longer recursive.
  57 *  Lock allocation changed to GFP_ATOMIC as we can't afford to sleep
  58 *  once we've checked for blocking and deadlocking.
  59 *  Andy Walker (andy@lysaker.kvaerner.no), April 03, 1996.
  60 *
  61 *  Initial implementation of mandatory locks. SunOS turned out to be
  62 *  a rotten model, so I implemented the "obvious" semantics.
  63 *  See 'Documentation/mandatory.txt' for details.
  64 *  Andy Walker (andy@lysaker.kvaerner.no), April 06, 1996.
  65 *
  66 *  Don't allow mandatory locks on mmap()'ed files. Added simple functions to
  67 *  check if a file has mandatory locks, used by mmap(), open() and creat() to
  68 *  see if system call should be rejected. Ref. HP-UX/SunOS/Solaris Reference
  69 *  Manual, Section 2.
  70 *  Andy Walker (andy@lysaker.kvaerner.no), April 09, 1996.
  71 *
  72 *  Tidied up block list handling. Added '/proc/locks' interface.
  73 *  Andy Walker (andy@lysaker.kvaerner.no), April 24, 1996.
  74 *
  75 *  Fixed deadlock condition for pathological code that mixes calls to
  76 *  flock() and fcntl().
  77 *  Andy Walker (andy@lysaker.kvaerner.no), April 29, 1996.
  78 *
  79 *  Allow only one type of locking scheme (FL_POSIX or FL_FLOCK) to be in use
  80 *  for a given file at a time. Changed the CONFIG_LOCK_MANDATORY scheme to
  81 *  guarantee sensible behaviour in the case where file system modules might
  82 *  be compiled with different options than the kernel itself.
  83 *  Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996.
  84 *
  85 *  Added a couple of missing wake_up() calls. Thanks to Thomas Meckel
  86 *  (Thomas.Meckel@mni.fh-giessen.de) for spotting this.
  87 *  Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996.
  88 *
  89 *  Changed FL_POSIX locks to use the block list in the same way as FL_FLOCK
  90 *  locks. Changed process synchronisation to avoid dereferencing locks that
  91 *  have already been freed.
  92 *  Andy Walker (andy@lysaker.kvaerner.no), Sep 21, 1996.
  93 *
  94 *  Made the block list a circular list to minimise searching in the list.
  95 *  Andy Walker (andy@lysaker.kvaerner.no), Sep 25, 1996.
  96 *
  97 *  Made mandatory locking a mount option. Default is not to allow mandatory
  98 *  locking.
  99 *  Andy Walker (andy@lysaker.kvaerner.no), Oct 04, 1996.
 100 *
 101 *  Some adaptations for NFS support.
 102 *  Olaf Kirch (okir@monad.swb.de), Dec 1996,
 103 *
 104 *  Fixed /proc/locks interface so that we can't overrun the buffer we are handed.
 105 *  Andy Walker (andy@lysaker.kvaerner.no), May 12, 1997.
 106 *
 107 *  Use slab allocator instead of kmalloc/kfree.
 108 *  Use generic list implementation from <linux/list.h>.
 109 *  Sped up posix_locks_deadlock by only considering blocked locks.
 110 *  Matthew Wilcox <willy@debian.org>, March, 2000.
 111 *
 112 *  Leases and LOCK_MAND
 113 *  Matthew Wilcox <willy@debian.org>, June, 2000.
 114 *  Stephen Rothwell <sfr@canb.auug.org.au>, June, 2000.
 115 */
 116
 117#include <linux/capability.h>
 118#include <linux/file.h>
 119#include <linux/fs.h>
 120#include <linux/init.h>
 121#include <linux/module.h>
 122#include <linux/security.h>
 123#include <linux/slab.h>
 124#include <linux/smp_lock.h>
 125#include <linux/syscalls.h>
 126#include <linux/time.h>
 127#include <linux/rcupdate.h>
 128
 129#include <asm/semaphore.h>
 130#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
 136int leases_enable = 1;
 137int lease_break_time = 45;
 138
 139#define for_each_lock(inode, lockp) \
 140	for (lockp = &inode->i_flock; *lockp != NULL; lockp = &(*lockp)->fl_next)
 141
 142static LIST_HEAD(file_lock_list);
 143static LIST_HEAD(blocked_list);
 144
 145static struct kmem_cache *filelock_cache __read_mostly;
 146
 147/* Allocate an empty lock structure. */
 148static struct file_lock *locks_alloc_lock(void)
 149{
 150	return kmem_cache_alloc(filelock_cache, GFP_KERNEL);
 151}
 152
 153static void locks_release_private(struct file_lock *fl)
 154{
 155	if (fl->fl_ops) {
 156		if (fl->fl_ops->fl_release_private)
 157			fl->fl_ops->fl_release_private(fl);
 158		fl->fl_ops = NULL;
 159	}
 160	if (fl->fl_lmops) {
 161		if (fl->fl_lmops->fl_release_private)
 162			fl->fl_lmops->fl_release_private(fl);
 163		fl->fl_lmops = NULL;
 164	}
 165
 166}
 167
 168/* Free a lock which is not in use. */
 169static void locks_free_lock(struct file_lock *fl)
 170{
 171	BUG_ON(waitqueue_active(&fl->fl_wait));
 172	BUG_ON(!list_empty(&fl->fl_block));
 173	BUG_ON(!list_empty(&fl->fl_link));
 174
 175	locks_release_private(fl);
 176	kmem_cache_free(filelock_cache, fl);
 177}
 178
 179void locks_init_lock(struct file_lock *fl)
 180{
 181	INIT_LIST_HEAD(&fl->fl_link);
 182	INIT_LIST_HEAD(&fl->fl_block);
 183	init_waitqueue_head(&fl->fl_wait);
 184	fl->fl_next = NULL;
 185	fl->fl_fasync = NULL;
 186	fl->fl_owner = NULL;
 187	fl->fl_pid = 0;
 188	fl->fl_file = NULL;
 189	fl->fl_flags = 0;
 190	fl->fl_type = 0;
 191	fl->fl_start = fl->fl_end = 0;
 192	fl->fl_ops = NULL;
 193	fl->fl_lmops = NULL;
 194}
 195
 196EXPORT_SYMBOL(locks_init_lock);
 197
 198/*
 199 * Initialises the fields of the file lock which are invariant for
 200 * free file_locks.
 201 */
 202static void init_once(void *foo, struct kmem_cache *cache, unsigned long flags)
 203{
 204	struct file_lock *lock = (struct file_lock *) foo;
 205
 206	if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) !=
 207					SLAB_CTOR_CONSTRUCTOR)
 208		return;
 209
 210	locks_init_lock(lock);
 211}
 212
 213static void locks_copy_private(struct file_lock *new, struct file_lock *fl)
 214{
 215	if (fl->fl_ops) {
 216		if (fl->fl_ops->fl_copy_lock)
 217			fl->fl_ops->fl_copy_lock(new, fl);
 218		new->fl_ops = fl->fl_ops;
 219	}
 220	if (fl->fl_lmops) {
 221		if (fl->fl_lmops->fl_copy_lock)
 222			fl->fl_lmops->fl_copy_lock(new, fl);
 223		new->fl_lmops = fl->fl_lmops;
 224	}
 225}
 226
 227/*
 228 * Initialize a new lock from an existing file_lock structure.
 229 */
 230static void __locks_copy_lock(struct file_lock *new, const struct file_lock *fl)
 231{
 232	new->fl_owner = fl->fl_owner;
 233	new->fl_pid = fl->fl_pid;
 234	new->fl_file = NULL;
 235	new->fl_flags = fl->fl_flags;
 236	new->fl_type = fl->fl_type;
 237	new->fl_start = fl->fl_start;
 238	new->fl_end = fl->fl_end;
 239	new->fl_ops = NULL;
 240	new->fl_lmops = NULL;
 241}
 242
 243void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
 244{
 245	locks_release_private(new);
 246
 247	__locks_copy_lock(new, fl);
 248	new->fl_file = fl->fl_file;
 249	new->fl_ops = fl->fl_ops;
 250	new->fl_lmops = fl->fl_lmops;
 251
 252	locks_copy_private(new, fl);
 253}
 254
 255EXPORT_SYMBOL(locks_copy_lock);
 256
 257static inline int flock_translate_cmd(int cmd) {
 258	if (cmd & LOCK_MAND)
 259		return cmd & (LOCK_MAND | LOCK_RW);
 260	switch (cmd) {
 261	case LOCK_SH:
 262		return F_RDLCK;
 263	case LOCK_EX:
 264		return F_WRLCK;
 265	case LOCK_UN:
 266		return F_UNLCK;
 267	}
 268	return -EINVAL;
 269}
 270
 271/* Fill in a file_lock structure with an appropriate FLOCK lock. */
 272static int flock_make_lock(struct file *filp, struct file_lock **lock,
 273		unsigned int cmd)
 274{
 275	struct file_lock *fl;
 276	int type = flock_translate_cmd(cmd);
 277	if (type < 0)
 278		return type;
 279	
 280	fl = locks_alloc_lock();
 281	if (fl == NULL)
 282		return -ENOMEM;
 283
 284	fl->fl_file = filp;
 285	fl->fl_pid = current->tgid;
 286	fl->fl_flags = FL_FLOCK;
 287	fl->fl_type = type;
 288	fl->fl_end = OFFSET_MAX;
 289	
 290	*lock = fl;
 291	return 0;
 292}
 293
 294static int assign_type(struct file_lock *fl, int type)
 295{
 296	switch (type) {
 297	case F_RDLCK:
 298	case F_WRLCK:
 299	case F_UNLCK:
 300		fl->fl_type = type;
 301		break;
 302	default:
 303		return -EINVAL;
 304	}
 305	return 0;
 306}
 307
 308/* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX
 309 * style lock.
 310 */
 311static int flock_to_posix_lock(struct file *filp, struct file_lock *fl,
 312			       struct flock *l)
 313{
 314	off_t start, end;
 315
 316	switch (l->l_whence) {
 317	case SEEK_SET:
 318		start = 0;
 319		break;
 320	case SEEK_CUR:
 321		start = filp->f_pos;
 322		break;
 323	case SEEK_END:
 324		start = i_size_read(filp->f_path.dentry->d_inode);
 325		break;
 326	default:
 327		return -EINVAL;
 328	}
 329
 330	/* POSIX-1996 leaves the case l->l_len < 0 undefined;
 331	   POSIX-2001 defines it. */
 332	start += l->l_start;
 333	if (start < 0)
 334		return -EINVAL;
 335	fl->fl_end = OFFSET_MAX;
 336	if (l->l_len > 0) {
 337		end = start + l->l_len - 1;
 338		fl->fl_end = end;
 339	} else if (l->l_len < 0) {
 340		end = start - 1;
 341		fl->fl_end = end;
 342		start += l->l_len;
 343		if (start < 0)
 344			return -EINVAL;
 345	}
 346	fl->fl_start = start;	/* we record the absolute position */
 347	if (fl->fl_end < fl->fl_start)
 348		return -EOVERFLOW;
 349	
 350	fl->fl_owner = current->files;
 351	fl->fl_pid = current->tgid;
 352	fl->fl_file = filp;
 353	fl->fl_flags = FL_POSIX;
 354	fl->fl_ops = NULL;
 355	fl->fl_lmops = NULL;
 356
 357	return assign_type(fl, l->l_type);
 358}
 359
 360#if BITS_PER_LONG == 32
 361static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl,
 362				 struct flock64 *l)
 363{
 364	loff_t start;
 365
 366	switch (l->l_whence) {
 367	case SEEK_SET:
 368		start = 0;
 369		break;
 370	case SEEK_CUR:
 371		start = filp->f_pos;
 372		break;
 373	case SEEK_END:
 374		start = i_size_read(filp->f_path.dentry->d_inode);
 375		break;
 376	default:
 377		return -EINVAL;
 378	}
 379
 380	start += l->l_start;
 381	if (start < 0)
 382		return -EINVAL;
 383	fl->fl_end = OFFSET_MAX;
 384	if (l->l_len > 0) {
 385		fl->fl_end = start + l->l_len - 1;
 386	} else if (l->l_len < 0) {
 387		fl->fl_end = start - 1;
 388		start += l->l_len;
 389		if (start < 0)
 390			return -EINVAL;
 391	}
 392	fl->fl_start = start;	/* we record the absolute position */
 393	if (fl->fl_end < fl->fl_start)
 394		return -EOVERFLOW;
 395	
 396	fl->fl_owner = current->files;
 397	fl->fl_pid = current->tgid;
 398	fl->fl_file = filp;
 399	fl->fl_flags = FL_POSIX;
 400	fl->fl_ops = NULL;
 401	fl->fl_lmops = NULL;
 402
 403	switch (l->l_type) {
 404	case F_RDLCK:
 405	case F_WRLCK:
 406	case F_UNLCK:
 407		fl->fl_type = l->l_type;
 408		break;
 409	default:
 410		return -EINVAL;
 411	}
 412
 413	return (0);
 414}
 415#endif
 416
 417/* default lease lock manager operations */
 418static void lease_break_callback(struct file_lock *fl)
 419{
 420	kill_fasync(&fl->fl_fasync, SIGIO, POLL_MSG);
 421}
 422
 423static void lease_release_private_callback(struct file_lock *fl)
 424{
 425	if (!fl->fl_file)
 426		return;
 427
 428	f_delown(fl->fl_file);
 429	fl->fl_file->f_owner.signum = 0;
 430}
 431
 432static int lease_mylease_callback(struct file_lock *fl, struct file_lock *try)
 433{
 434	return fl->fl_file == try->fl_file;
 435}
 436
 437static struct lock_manager_operations lease_manager_ops = {
 438	.fl_break = lease_break_callback,
 439	.fl_release_private = lease_release_private_callback,
 440	.fl_mylease = lease_mylease_callback,
 441	.fl_change = lease_modify,
 442};
 443
 444/*
 445 * Initialize a lease, use the default lock manager operations
 446 */
 447static int lease_init(struct file *filp, int type, struct file_lock *fl)
 448 {
 449	if (assign_type(fl, type) != 0)
 450		return -EINVAL;
 451
 452	fl->fl_owner = current->files;
 453	fl->fl_pid = current->tgid;
 454
 455	fl->fl_file = filp;
 456	fl->fl_flags = FL_LEASE;
 457	fl->fl_start = 0;
 458	fl->fl_end = OFFSET_MAX;
 459	fl->fl_ops = NULL;
 460	fl->fl_lmops = &lease_manager_ops;
 461	return 0;
 462}
 463
 464/* Allocate a file_lock initialised to this type of lease */
 465static struct file_lock *lease_alloc(struct file *filp, int type)
 466{
 467	struct file_lock *fl = locks_alloc_lock();
 468	int error = -ENOMEM;
 469
 470	if (fl == NULL)
 471		return ERR_PTR(error);
 472
 473	error = lease_init(filp, type, fl);
 474	if (error) {
 475		locks_free_lock(fl);
 476		return ERR_PTR(error);
 477	}
 478	return fl;
 479}
 480
 481/* Check if two locks overlap each other.
 482 */
 483static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2)
 484{
 485	return ((fl1->fl_end >= fl2->fl_start) &&
 486		(fl2->fl_end >= fl1->fl_start));
 487}
 488
 489/*
 490 * Check whether two locks have the same owner.
 491 */
 492static int posix_same_owner(struct file_lock *fl1, struct file_lock *fl2)
 493{
 494	if (fl1->fl_lmops && fl1->fl_lmops->fl_compare_owner)
 495		return fl2->fl_lmops == fl1->fl_lmops &&
 496			fl1->fl_lmops->fl_compare_owner(fl1, fl2);
 497	return fl1->fl_owner == fl2->fl_owner;
 498}
 499
 500/* Remove waiter from blocker's block list.
 501 * When blocker ends up pointing to itself then the list is empty.
 502 */
 503static void __locks_delete_block(struct file_lock *waiter)
 504{
 505	list_del_init(&waiter->fl_block);
 506	list_del_init(&waiter->fl_link);
 507	waiter->fl_next = NULL;
 508}
 509
 510/*
 511 */
 512static void locks_delete_block(struct file_lock *waiter)
 513{
 514	lock_kernel();
 515	__locks_delete_block(waiter);
 516	unlock_kernel();
 517}
 518
 519/* Insert waiter into blocker's block list.
 520 * We use a circular list so that processes can be easily woken up in
 521 * the order they blocked. The documentation doesn't require this but
 522 * it seems like the reasonable thing to do.
 523 */
 524static void locks_insert_block(struct file_lock *blocker, 
 525			       struct file_lock *waiter)
 526{
 527	BUG_ON(!list_empty(&waiter->fl_block));
 528	list_add_tail(&waiter->fl_block, &blocker->fl_block);
 529	waiter->fl_next = blocker;
 530	if (IS_POSIX(blocker))
 531		list_add(&waiter->fl_link, &blocked_list);
 532}
 533
 534/* Wake up processes blocked waiting for blocker.
 535 * If told to wait then schedule the processes until the block list
 536 * is empty, otherwise empty the block list ourselves.
 537 */
 538static void locks_wake_up_blocks(struct file_lock *blocker)
 539{
 540	while (!list_empty(&blocker->fl_block)) {
 541		struct file_lock *waiter;
 542
 543		waiter = list_first_entry(&blocker->fl_block,
 544				struct file_lock, fl_block);
 545		__locks_delete_block(waiter);
 546		if (waiter->fl_lmops && waiter->fl_lmops->fl_notify)
 547			waiter->fl_lmops->fl_notify(waiter);
 548		else
 549			wake_up(&waiter->fl_wait);
 550	}
 551}
 552
 553/* Insert file lock fl into an inode's lock list at the position indicated
 554 * by pos. At the same time add the lock to the global file lock list.
 555 */
 556static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl)
 557{
 558	list_add(&fl->fl_link, &file_lock_list);
 559
 560	/* insert into file's list */
 561	fl->fl_next = *pos;
 562	*pos = fl;
 563
 564	if (fl->fl_ops && fl->fl_ops->fl_insert)
 565		fl->fl_ops->fl_insert(fl);
 566}
 567
 568/*
 569 * Delete a lock and then free it.
 570 * Wake up processes that are blocked waiting for this lock,
 571 * notify the FS that the lock has been cleared and
 572 * finally free the lock.
 573 */
 574static void locks_delete_lock(struct file_lock **thisfl_p)
 575{
 576	struct file_lock *fl = *thisfl_p;
 577
 578	*thisfl_p = fl->fl_next;
 579	fl->fl_next = NULL;
 580	list_del_init(&fl->fl_link);
 581
 582	fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync);
 583	if (fl->fl_fasync != NULL) {
 584		printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync);
 585		fl->fl_fasync = NULL;
 586	}
 587
 588	if (fl->fl_ops && fl->fl_ops->fl_remove)
 589		fl->fl_ops->fl_remove(fl);
 590
 591	locks_wake_up_blocks(fl);
 592	locks_free_lock(fl);
 593}
 594
 595/* Determine if lock sys_fl blocks lock caller_fl. Common functionality
 596 * checks for shared/exclusive status of overlapping locks.
 597 */
 598static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
 599{
 600	if (sys_fl->fl_type == F_WRLCK)
 601		return 1;
 602	if (caller_fl->fl_type == F_WRLCK)
 603		return 1;
 604	return 0;
 605}
 606
 607/* Determine if lock sys_fl blocks lock caller_fl. POSIX specific
 608 * checking before calling the locks_conflict().
 609 */
 610static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
 611{
 612	/* POSIX locks owned by the same process do not conflict with
 613	 * each other.
 614	 */
 615	if (!IS_POSIX(sys_fl) || posix_same_owner(caller_fl, sys_fl))
 616		return (0);
 617
 618	/* Check whether they overlap */
 619	if (!locks_overlap(caller_fl, sys_fl))
 620		return 0;
 621
 622	return (locks_conflict(caller_fl, sys_fl));
 623}
 624
 625/* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific
 626 * checking before calling the locks_conflict().
 627 */
 628static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
 629{
 630	/* FLOCK locks referring to the same filp do not conflict with
 631	 * each other.
 632	 */
 633	if (!IS_FLOCK(sys_fl) || (caller_fl->fl_file == sys_fl->fl_file))
 634		return (0);
 635	if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND))
 636		return 0;
 637
 638	return (locks_conflict(caller_fl, sys_fl));
 639}
 640
 641void
 642posix_test_lock(struct file *filp, struct file_lock *fl)
 643{
 644	struct file_lock *cfl;
 645
 646	lock_kernel();
 647	for (cfl = filp->f_path.dentry->d_inode->i_flock; cfl; cfl = cfl->fl_next) {
 648		if (!IS_POSIX(cfl))
 649			continue;
 650		if (posix_locks_conflict(fl, cfl))
 651			break;
 652	}
 653	if (cfl)
 654		__locks_copy_lock(fl, cfl);
 655	else
 656		fl->fl_type = F_UNLCK;
 657	unlock_kernel();
 658	return;
 659}
 660
 661EXPORT_SYMBOL(posix_test_lock);
 662
 663/* This function tests for deadlock condition before putting a process to
 664 * sleep. The detection scheme is no longer recursive. Recursive was neat,
 665 * but dangerous - we risked stack corruption if the lock data was bad, or
 666 * if the recursion was too deep for any other reason.
 667 *
 668 * We rely on the fact that a task can only be on one lock's wait queue
 669 * at a time. When we find blocked_task on a wait queue we can re-search
 670 * with blocked_task equal to that queue's owner, until either blocked_task
 671 * isn't found, or blocked_task is found on a queue owned by my_task.
 672 *
 673 * Note: the above assumption may not be true when handling lock requests
 674 * from a broken NFS client. But broken NFS clients have a lot more to
 675 * worry about than proper deadlock detection anyway... --okir
 676 *
 677 * However, the failure of this assumption (also possible in the case of
 678 * multiple tasks sharing the same open file table) also means there's no
 679 * guarantee that the loop below will terminate.  As a hack, we give up
 680 * after a few iterations.
 681 */
 682
 683#define MAX_DEADLK_ITERATIONS 10
 684
 685static int posix_locks_deadlock(struct file_lock *caller_fl,
 686				struct file_lock *block_fl)
 687{
 688	struct list_head *tmp;
 689	int i = 0;
 690
 691next_task:
 692	if (posix_same_owner(caller_fl, block_fl))
 693		return 1;
 694	list_for_each(tmp, &blocked_list) {
 695		struct file_lock *fl = list_entry(tmp, struct file_lock, fl_link);
 696		if (posix_same_owner(fl, block_fl)) {
 697			if (i++ > MAX_DEADLK_ITERATIONS)
 698				return 0;
 699			fl = fl->fl_next;
 700			block_fl = fl;
 701			goto next_task;
 702		}
 703	}
 704	return 0;
 705}
 706
 707/* Try to create a FLOCK lock on filp. We always insert new FLOCK locks
 708 * after any leases, but before any posix locks.
 709 *
 710 * Note that if called with an FL_EXISTS argument, the caller may determine
 711 * whether or not a lock was successfully freed by testing the return
 712 * value for -ENOENT.
 713 */
 714static int flock_lock_file(struct file *filp, struct file_lock *request)
 715{
 716	struct file_lock *new_fl = NULL;
 717	struct file_lock **before;
 718	struct inode * inode = filp->f_path.dentry->d_inode;
 719	int error = 0;
 720	int found = 0;
 721
 722	lock_kernel();
 723	if (request->fl_flags & FL_ACCESS)
 724		goto find_conflict;
 725
 726	if (request->fl_type != F_UNLCK) {
 727		error = -ENOMEM;
 728		new_fl = locks_alloc_lock();
 729		if (new_fl == NULL)
 730			goto out;
 731		error = 0;
 732	}
 733
 734	for_each_lock(inode, before) {
 735		struct file_lock *fl = *before;
 736		if (IS_POSIX(fl))
 737			break;
 738		if (IS_LEASE(fl))
 739			continue;
 740		if (filp != fl->fl_file)
 741			continue;
 742		if (request->fl_type == fl->fl_type)
 743			goto out;
 744		found = 1;
 745		locks_delete_lock(before);
 746		break;
 747	}
 748
 749	if (request->fl_type == F_UNLCK) {
 750		if ((request->fl_flags & FL_EXISTS) && !found)
 751			error = -ENOENT;
 752		goto out;
 753	}
 754
 755	/*
 756	 * If a higher-priority process was blocked on the old file lock,
 757	 * give it the opportunity to lock the file.
 758	 */
 759	if (found)
 760		cond_resched();
 761
 762find_conflict:
 763	for_each_lock(inode, before) {
 764		struct file_lock *fl = *before;
 765		if (IS_POSIX(fl))
 766			break;
 767		if (IS_LEASE(fl))
 768			continue;
 769		if (!flock_locks_conflict(request, fl))
 770			continue;
 771		error = -EAGAIN;
 772		if (request->fl_flags & FL_SLEEP)
 773			locks_insert_block(fl, request);
 774		goto out;
 775	}
 776	if (request->fl_flags & FL_ACCESS)
 777		goto out;
 778	locks_copy_lock(new_fl, request);
 779	locks_insert_lock(&inode->i_flock, new_fl);
 780	new_fl = NULL;
 781	error = 0;
 782
 783out:
 784	unlock_kernel();
 785	if (new_fl)
 786		locks_free_lock(new_fl);
 787	return error;
 788}
 789
 790static int __posix_lock_file(struct inode *inode, struct file_lock *request, struct file_lock *conflock)
 791{
 792	struct file_lock *fl;
 793	struct file_lock *new_fl = NULL;
 794	struct file_lock *new_fl2 = NULL;
 795	struct file_lock *left = NULL;
 796	struct file_lock *right = NULL;
 797	struct file_lock **before;
 798	int error, added = 0;
 799
 800	/*
 801	 * We may need two file_lock structures for this operation,
 802	 * so we get them in advance to avoid races.
 803	 *
 804	 * In some cases we can be sure, that no new locks will be needed
 805	 */
 806	if (!(request->fl_flags & FL_ACCESS) &&
 807	    (request->fl_type != F_UNLCK ||
 808	     request->fl_start != 0 || request->fl_end != OFFSET_MAX)) {
 809		new_fl = locks_alloc_lock();
 810		new_fl2 = locks_alloc_lock();
 811	}
 812
 813	lock_kernel();
 814	if (request->fl_type != F_UNLCK) {
 815		for_each_lock(inode, before) {
 816			fl = *before;
 817			if (!IS_POSIX(fl))
 818				continue;
 819			if (!posix_locks_conflict(request, fl))
 820				continue;
 821			if (conflock)
 822				locks_copy_lock(conflock, fl);
 823			error = -EAGAIN;
 824			if (!(request->fl_flags & FL_SLEEP))
 825				goto out;
 826			error = -EDEADLK;
 827			if (posix_locks_deadlock(request, fl))
 828				goto out;
 829			error = -EAGAIN;
 830			locks_insert_block(fl, request);
 831			goto out;
 832  		}
 833  	}
 834
 835	/* If we're just looking for a conflict, we're done. */
 836	error = 0;
 837	if (request->fl_flags & FL_ACCESS)
 838		goto out;
 839
 840	/*
 841	 * Find the first old lock with the same owner as the new lock.
 842	 */
 843	
 844	before = &inode->i_flock;
 845
 846	/* First skip locks owned by other processes.  */
 847	while ((fl = *before) && (!IS_POSIX(fl) ||
 848				  !posix_same_owner(request, fl))) {
 849		before = &fl->fl_next;
 850	}
 851
 852	/* Process locks with this owner.  */
 853	while ((fl = *before) && posix_same_owner(request, fl)) {
 854		/* Detect adjacent or overlapping regions (if same lock type)
 855		 */
 856		if (request->fl_type == fl->fl_type) {
 857			/* In all comparisons of start vs end, use
 858			 * "start - 1" rather than "end + 1". If end
 859			 * is OFFSET_MAX, end + 1 will become negative.
 860			 */
 861			if (fl->fl_end < request->fl_start - 1)
 862				goto next_lock;
 863			/* If the next lock in the list has entirely bigger
 864			 * addresses than the new one, insert the lock here.
 865			 */
 866			if (fl->fl_start - 1 > request->fl_end)
 867				break;
 868
 869			/* If we come here, the new and old lock are of the
 870			 * same type and adjacent or overlapping. Make one
 871			 * lock yielding from the lower start address of both
 872			 * locks to the higher end address.
 873			 */
 874			if (fl->fl_start > request->fl_start)
 875				fl->fl_start = request->fl_start;
 876			else
 877				request->fl_start = fl->fl_start;
 878			if (fl->fl_end < request->fl_end)
 879				fl->fl_end = request->fl_end;
 880			else
 881				request->fl_end = fl->fl_end;
 882			if (added) {
 883				locks_delete_lock(before);
 884				continue;
 885			}
 886			request = fl;
 887			added = 1;
 888		}
 889		else {
 890			/* Processing for different lock types is a bit
 891			 * more complex.
 892			 */
 893			if (fl->fl_end < request->fl_start)
 894				goto next_lock;
 895			if (fl->fl_start > request->fl_end)
 896				break;
 897			if (request->fl_type == F_UNLCK)
 898				added = 1;
 899			if (fl->fl_start < request->fl_start)
 900				left = fl;
 901			/* If the next lock in the list has a higher end
 902			 * address than the new one, insert the new one here.
 903			 */
 904			if (fl->fl_end > request->fl_end) {
 905				right = fl;
 906				break;
 907			}
 908			if (fl->fl_start >= request->fl_start) {
 909				/* The new lock completely replaces an old
 910				 * one (This may happen several times).
 911				 */
 912				if (added) {
 913					locks_delete_lock(before);
 914					continue;
 915				}
 916				/* Replace the old lock with the new one.
 917				 * Wake up anybody waiting for the old one,
 918				 * as the change in lock type might satisfy
 919				 * their needs.
 920				 */
 921				locks_wake_up_blocks(fl);
 922				fl->fl_start = request->fl_start;
 923				fl->fl_end = request->fl_end;
 924				fl->fl_type = request->fl_type;
 925				locks_release_private(fl);
 926				locks_copy_private(fl, request);
 927				request = fl;
 928				added = 1;
 929			}
 930		}
 931		/* Go on to next lock.
 932		 */
 933	next_lock:
 934		before = &fl->fl_next;
 935	}
 936
 937	/*
 938	 * The above code only modifies existing locks in case of
 939	 * merging or replacing.  If new lock(s) need to be inserted
 940	 * all modifications are done bellow this, so it's safe yet to
 941	 * bail out.
 942	 */
 943	error = -ENOLCK; /* "no luck" */
 944	if (right && left == right && !new_fl2)
 945		goto out;
 946
 947	error = 0;
 948	if (!added) {
 949		if (request->fl_type == F_UNLCK) {
 950			if (request->fl_flags & FL_EXISTS)
 951				error = -ENOENT;
 952			goto out;
 953		}
 954
 955		if (!new_fl) {
 956			error = -ENOLCK;
 957			goto out;
 958		}
 959		locks_copy_lock(new_fl, request);
 960		locks_insert_lock(before, new_fl);
 961		new_fl = NULL;
 962	}
 963	if (right) {
 964		if (left == right) {
 965			/* The new lock breaks the old one in two pieces,
 966			 * so we have to use the second new lock.
 967			 */
 968			left = new_fl2;
 969			new_fl2 = NULL;
 970			locks_copy_lock(left, right);
 971			locks_insert_lock(before, left);
 972		}
 973		right->fl_start = request->fl_end + 1;
 974		locks_wake_up_blocks(right);
 975	}
 976	if (left) {
 977		left->fl_end = request->fl_start - 1;
 978		locks_wake_up_blocks(left);
 979	}
 980 out:
 981	unlock_kernel();
 982	/*
 983	 * Free any unused locks.
 984	 */
 985	if (new_fl)
 986		locks_free_lock(new_fl);
 987	if (new_fl2)
 988		locks_free_lock(new_fl2);
 989	return error;
 990}
 991
 992/**
 993 * posix_lock_file - Apply a POSIX-style lock to a file
 994 * @filp: The file to apply the lock to
 995 * @fl: The lock to be applied
 996 * @conflock: Place to return a copy of the conflicting lock, if found.
 997 *
 998 * Add a POSIX style lock to a file.
 999 * We merge adjacent & overlapping locks whenever possible.
1000 * POSIX locks are sorted by owner task, then by starting address
1001 *
1002 * Note that if called with an FL_EXISTS argument, the caller may determine
1003 * whether or not a lock was successfully freed by testing the return
1004 * value for -ENOENT.
1005 */
1006int posix_lock_file(struct file *filp, struct file_lock *fl,
1007			struct file_lock *conflock)
1008{
1009	return __posix_lock_file(filp->f_path.dentry->d_inode, fl, conflock);
1010}
1011EXPORT_SYMBOL(posix_lock_file);
1012
1013/**
1014 * posix_lock_file_wait - Apply a POSIX-style lock to a file
1015 * @filp: The file to apply the lock to
1016 * @fl: The lock to be applied
1017 *
1018 * Add a POSIX style lock to a file.
1019 * We merge adjacent & overlapping locks whenever possible.
1020 * POSIX locks are sorted by owner task, then by starting address
1021 */
1022int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
1023{
1024	int error;
1025	might_sleep ();
1026	for (;;) {
1027		error = posix_lock_file(filp, fl, NULL);
1028		if ((error != -EAGAIN) || !(fl->fl_flags & FL_SLEEP))
1029			break;
1030		error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
1031		if (!error)
1032			continue;
1033
1034		locks_delete_block(fl);
1035		break;
1036	}
1037	return error;
1038}
1039EXPORT_SYMBOL(posix_lock_file_wait);
1040
1041/**
1042 * locks_mandatory_locked - Check for an active lock
1043 * @inode: the file to check
1044 *
1045 * Searches the inode's list of locks to find any POSIX locks which conflict.
1046 * This function is called from locks_verify_locked() only.
1047 */
1048int locks_mandatory_locked(struct inode *inode)
1049{
1050	fl_owner_t owner = current->files;
1051	struct file_lock *fl;
1052
1053	/*
1054	 * Search the lock list for this inode for any POSIX locks.
1055	 */
1056	lock_kernel();
1057	for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
1058		if (!IS_POSIX(fl))
1059			continue;
1060		if (fl->fl_owner != owner)
1061			break;
1062	}
1063	unlock_kernel();
1064	return fl ? -EAGAIN : 0;
1065}
1066
1067/**
1068 * locks_mandatory_area - Check for a conflicting lock
1069 * @read_write: %FLOCK_VERIFY_WRITE for exclusive access, %FLOCK_VERIFY_READ
1070 *		for shared
1071 * @inode:      the file to check
1072 * @filp:       how the file was opened (if it was)
1073 * @offset:     start of area to check
1074 * @count:      length of area to check
1075 *
1076 * Searches the inode's list of locks to find any POSIX locks which conflict.
1077 * This function is called from rw_verify_area() and
1078 * locks_verify_truncate().
1079 */
1080int locks_mandatory_area(int read_write, struct inode *inode,
1081			 struct file *filp, loff_t offset,
1082			 size_t count)
1083{
1084	struct file_lock fl;
1085	int error;
1086
1087	locks_init_lock(&fl);
1088	fl.fl_owner = current->files;
1089	fl.fl_pid = current->tgid;
1090	fl.fl_file = filp;
1091	fl.fl_flags = FL_POSIX | FL_ACCESS;
1092	if (filp && !(filp->f_flags & O_NONBLOCK))
1093		fl.fl_flags |= FL_SLEEP;
1094	fl.fl_type = (read_write == FLOCK_VERIFY_WRITE) ? F_WRLCK : F_RDLCK;
1095	fl.fl_start = offset;
1096	fl.fl_end = offset + count - 1;
1097
1098	for (;;) {
1099		error = __posix_lock_file(inode, &fl, NULL);
1100		if (error != -EAGAIN)
1101			break;
1102		if (!(fl.fl_flags & FL_SLEEP))
1103			break;
1104		error = wait_event_interruptible(fl.fl_wait, !fl.fl_next);
1105		if (!error) {
1106			/*
1107			 * If we've been sleeping someone might have
1108			 * changed the permissions behind our back.
1109			 */
1110			if ((inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
1111				continue;
1112		}
1113
1114		locks_delete_block(&fl);
1115		break;
1116	}
1117
1118	return error;
1119}
1120
1121EXPORT_SYMBOL(locks_mandatory_area);
1122
1123/* We already had a lease on this file; just change its type */
1124int lease_modify(struct file_lock **before, int arg)
1125{
1126	struct file_lock *fl = *before;
1127	int error = assign_type(fl, arg);
1128
1129	if (error)
1130		return error;
1131	locks_wake_up_blocks(fl);
1132	if (arg == F_UNLCK)
1133		locks_delete_lock(before);
1134	return 0;
1135}
1136
1137EXPORT_SYMBOL(lease_modify);
1138
1139static void time_out_leases(struct inode *inode)
1140{
1141	struct file_lock **before;
1142	struct file_lock *fl;
1143
1144	before = &inode->i_flock;
1145	while ((fl = *before) && IS_LEASE(fl) && (fl->fl_type & F_INPROGRESS)) {
1146		if ((fl->fl_break_time == 0)
1147				|| time_before(jiffies, fl->fl_break_time)) {
1148			before = &fl->fl_next;
1149			continue;
1150		}
1151		lease_modify(before, fl->fl_type & ~F_INPROGRESS);
1152		if (fl == *before)	/* lease_modify may have freed fl */
1153			before = &fl->fl_next;
1154	}
1155}
1156
1157/**
1158 *	__break_lease	-	revoke all outstanding leases on file
1159 *	@inode: the inode of the file to return
1160 *	@mode: the open mode (read or write)
1161 *
1162 *	break_lease (inlined for speed) has checked there already
1163 *	is a lease on this file.  Leases are broken on a call to open()
1164 *	or truncate().  This function can sleep unless you
1165 *	specified %O_NONBLOCK to your open().
1166 */
1167int __break_lease(struct inode *inode, unsigned int mode)
1168{
1169	int error = 0, future;
1170	struct file_lock *new_fl, *flock;
1171	struct file_lock *fl;
1172	unsigned long break_time;
1173	int i_have_this_lease = 0;
1174
1175	new_fl = lease_alloc(NULL, mode & FMODE_WRITE ? F_WRLCK : F_RDLCK);
1176
1177	lock_kernel();
1178
1179	time_out_leases(inode);
1180
1181	flock = inode->i_flock;
1182	if ((flock == NULL) || !IS_LEASE(flock))
1183		goto out;
1184
1185	for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next)
1186		if (fl->fl_owner == current->files)
1187			i_have_this_lease = 1;
1188
1189	if (mode & FMODE_WRITE) {
1190		/* If we want write access, we have to revoke any lease. */
1191		future = F_UNLCK | F_INPROGRESS;
1192	} else if (flock->fl_type & F_INPROGRESS) {
1193		/* If the lease is already being broken, we just leave it */
1194		future = flock->fl_type;
1195	} else if (flock->fl_type & F_WRLCK) {
1196		/* Downgrade the exclusive lease to a read-only lease. */
1197		future = F_RDLCK | F_INPROGRESS;
1198	} else {
1199		/* the existing lease was read-only, so we can read too. */
1200		goto out;
1201	}
1202
1203	if (IS_ERR(new_fl) && !i_have_this_lease
1204			&& ((mode & O_NONBLOCK) == 0)) {
1205		error = PTR_ERR(new_fl);
1206		goto out;
1207	}
1208
1209	break_time = 0;
1210	if (lease_break_time > 0) {
1211		break_time = jiffies + lease_break_time * HZ;
1212		if (break_time == 0)
1213			break_time++;	/* so that 0 means no break time */
1214	}
1215
1216	for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) {
1217		if (fl->fl_type != future) {
1218			fl->fl_type = future;
1219			fl->fl_break_time = break_time;
1220			/* lease must have lmops break callback */
1221			fl->fl_lmops->fl_break(fl);
1222		}
1223	}
1224
1225	if (i_have_this_lease || (mode & O_NONBLOCK)) {
1226		error = -EWOULDBLOCK;
1227		goto out;
1228	}
1229
1230restart:
1231	break_time = flock->fl_break_time;
1232	if (break_time != 0) {
1233		break_time -= jiffies;
1234		if (break_time == 0)
1235			break_time++;
1236	}
1237	locks_insert_block(flock, new_fl);
1238	error = wait_event_interruptible_timeout(new_fl->fl_wait,
1239						!new_fl->fl_next, break_time);
1240	__locks_delete_block(new_fl);
1241	if (error >= 0) {
1242		if (error == 0)
1243			time_out_leases(inode);
1244		/* Wait for the next lease that has not been broken yet */
1245		for (flock = inode->i_flock; flock && IS_LEASE(flock);
1246				flock = flock->fl_next) {
1247			if (flock->fl_type & F_INPROGRESS)
1248				goto restart;
1249		}
1250		error = 0;
1251	}
1252
1253out:
1254	unlock_kernel();
1255	if (!IS_ERR(new_fl))
1256		locks_free_lock(new_fl);
1257	return error;
1258}
1259
1260EXPORT_SYMBOL(__break_lease);
1261
1262/**
1263 *	lease_get_mtime
1264 *	@inode: the inode
1265 *      @time:  pointer to a timespec which will contain the last modified time
1266 *
1267 * This is to force NFS clients to flush their caches for files with
1268 * exclusive leases.  The justification is that if someone has an
1269 * exclusive lease, then they could be modifiying it.
1270 */
1271void lease_get_mtime(struct inode *inode, struct timespec *time)
1272{
1273	struct file_lock *flock = inode->i_flock;
1274	if (flock && IS_LEASE(flock) && (flock->fl_type & F_WRLCK))
1275		*time = current_fs_time(inode->i_sb);
1276	else
1277		*time = inode->i_mtime;
1278}
1279
1280EXPORT_SYMBOL(lease_get_mtime);
1281
1282/**
1283 *	fcntl_getlease - Enquire what lease is currently active
1284 *	@filp: the file
1285 *
1286 *	The value returned by this function will be one of
1287 *	(if no lease break is pending):
1288 *
1289 *	%F_RDLCK to indicate a shared lease is held.
1290 *
1291 *	%F_WRLCK to indicate an exclusive lease is held.
1292 *
1293 *	%F_UNLCK to indicate no lease is held.
1294 *
1295 *	(if a lease break is pending):
1296 *
1297 *	%F_RDLCK to indicate an exclusive lease needs to be
1298 *		changed to a shared lease (or removed).
1299 *
1300 *	%F_UNLCK to indicate the lease needs to be removed.
1301 *
1302 *	XXX: sfr & willy disagree over whether F_INPROGRESS
1303 *	should be returned to userspace.
1304 */
1305int fcntl_getlease(struct file *filp)
1306{
1307	struct file_lock *fl;
1308	int type = F_UNLCK;
1309
1310	lock_kernel();
1311	time_out_leases(filp->f_path.dentry->d_inode);
1312	for (fl = filp->f_path.dentry->d_inode->i_flock; fl && IS_LEASE(fl);
1313			fl = fl->fl_next) {
1314		if (fl->fl_file == filp) {
1315			type = fl->fl_type & ~F_INPROGRESS;
1316			break;
1317		}
1318	}
1319	unlock_kernel();
1320	return type;
1321}
1322
1323/**
1324 *	setlease	-	sets a lease on an open file
1325 *	@filp: file pointer
1326 *	@arg: type of lease to obtain
1327 *	@flp: input - file_lock to use, output - file_lock inserted
1328 *
1329 *	The (input) flp->fl_lmops->fl_break function is required
1330 *	by break_lease().
1331 *
1332 *	Called with kernel lock held.
1333 */
1334int setlease(struct file *filp, long arg, struct file_lock **flp)
1335{
1336	struct file_lock *fl, **before, **my_before = NULL, *lease;
1337	struct file_lock *new_fl = NULL;
1338	struct dentry *dentry = filp->f_path.dentry;
1339	struct inode *inode = dentry->d_inode;
1340	int error, rdlease_count = 0, wrlease_count = 0;
1341
1342	if ((current->fsuid != inode->i_uid) && !capable(CAP_LEASE))
1343		return -EACCES;
1344	if (!S_ISREG(inode->i_mode))
1345		return -EINVAL;
1346	error = security_file_lock(filp, arg);
1347	if (error)
1348		return error;
1349
1350	time_out_leases(inode);
1351
1352	BUG_ON(!(*flp)->fl_lmops->fl_break);
1353
1354	lease = *flp;
1355
1356	error = -EAGAIN;
1357	if ((arg == F_RDLCK) && (atomic_read(&inode->i_writecount) > 0))
1358		goto out;
1359	if ((arg == F_WRLCK)
1360	    && ((atomic_read(&dentry->d_count) > 1)
1361		|| (atomic_read(&inode->i_count) > 1)))
1362		goto out;
1363
1364	error = -ENOMEM;
1365	new_fl = locks_alloc_lock();
1366	if (new_fl == NULL)
1367		goto out;
1368
1369	/*
1370	 * At this point, we know that if there is an exclusive
1371	 * lease on this file, then we hold it on this filp
1372	 * (otherwise our open of this file would have blocked).
1373	 * And if we are trying to acquire an exclusive lease,
1374	 * then the file is not open by anyone (including us)
1375	 * except for this filp.
1376	 */
1377	for (before = &inode->i_flock;
1378			((fl = *before) != NULL) && IS_LEASE(fl);
1379			before = &fl->fl_next) {
1380		if (lease->fl_lmops->fl_mylease(fl, lease))
1381			my_before = before;
1382		else if (fl->fl_type == (F_INPROGRESS | F_UNLCK))
1383			/*
1384			 * Someone is in the process of opening this
1385			 * file for writing so we may not take an
1386			 * exclusive lease on it.
1387			 */
1388			wrlease_count++;
1389		else
1390			rdlease_count++;
1391	}
1392
1393	error = -EAGAIN;
1394	if ((arg == F_RDLCK && (wrlease_count > 0)) ||
1395	    (arg == F_WRLCK && ((rdlease_count + wrlease_count) > 0)))
1396		goto out;
1397
1398	if (my_before != NULL) {
1399		*flp = *my_before;
1400		error = lease->fl_lmops->fl_change(my_before, arg);
1401		goto out;
1402	}
1403
1404	error = 0;
1405	if (arg == F_UNLCK)
1406		goto out;
1407
1408	error = -EINVAL;
1409	if (!leases_enable)
1410		goto out;
1411
1412	locks_copy_lock(new_fl, lease);
1413	locks_insert_lock(before, new_fl);
1414
1415	*flp = new_fl;
1416	return 0;
1417
1418out:
1419	if (new_fl != NULL)
1420		locks_free_lock(new_fl);
1421	return error;
1422}
1423EXPORT_SYMBOL(setlease);
1424
1425 /**
1426 *	vfs_setlease        -       sets a lease on an open file
1427 *	@filp: file pointer
1428 *	@arg: type of lease to obtain
1429 *	@lease: file_lock to use
1430 *
1431 *	Call this to establish a lease on the file.
1432 *	The (*lease)->fl_lmops->fl_break operation must be set; if not,
1433 *	break_lease will oops!
1434 *
1435 *	This will call the filesystem's setlease file method, if
1436 *	defined.  Note that there is no getlease method; instead, the
1437 *	filesystem setlease method should call back to setlease() to
1438 *	add a lease to the inode's lease list, where fcntl_getlease() can
1439 *	find it.  Since fcntl_getlease() only reports whether the current
1440 *	task holds a lease, a cluster filesystem need only do this for
1441 *	leases held by processes on this node.
1442 *
1443 *	There is also no break_lease method; filesystems that
1444 *	handle their own leases shoud break leases themselves from the
1445 *	filesystem's open, create, and (on truncate) setattr methods.
1446 *
1447 *	Warning: the only current setlease methods exist only to disable
1448 *	leases in certain cases.  More vfs changes may be required to
1449 *	allow a full filesystem lease implementation.
1450 */
1451
1452int vfs_setlease(struct file *filp, long arg, struct file_lock **lease)
1453{
1454	int error;
1455
1456	lock_kernel();
1457	if (filp->f_op && filp->f_op->setlease)
1458		error = filp->f_op->setlease(filp, arg, lease);
1459	else
1460		error = setlease(filp, arg, lease);
1461	unlock_kernel();
1462
1463	return error;
1464}
1465EXPORT_SYMBOL_GPL(vfs_setlease);
1466
1467/**
1468 *	fcntl_setlease	-	sets a lease on an open file
1469 *	@fd: open file descriptor
1470 *	@filp: file pointer
1471 *	@arg: type of lease to obtain
1472 *
1473 *	Call this fcntl to establish a lease on the file.
1474 *	Note that you also need to call %F_SETSIG to
1475 *	receive a signal when the lease is broken.
1476 */
1477int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
1478{
1479	struct file_lock fl, *flp = &fl;
1480	struct dentry *dentry = filp->f_path.dentry;
1481	struct inode *inode = dentry->d_inode;
1482	int error;
1483
1484	locks_init_lock(&fl);
1485	error = lease_init(filp, arg, &fl);
1486	if (error)
1487		return error;
1488
1489	lock_kernel();
1490
1491	error = vfs_setlease(filp, arg, &flp);
1492	if (error || arg == F_UNLCK)
1493		goto out_unlock;
1494
1495	error = fasync_helper(fd, filp, 1, &flp->fl_fasync);
1496	if (error < 0) {
1497		/* remove lease just inserted by setlease */
1498		flp->fl_type = F_UNLCK | F_INPROGRESS;
1499		flp->fl_break_time = jiffies - 10;
1500		time_out_leases(inode);
1501		goto out_unlock;
1502	}
1503
1504	error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0);
1505out_unlock:
1506	unlock_kernel();
1507	return error;
1508}
1509
1510/**
1511 * flock_lock_file_wait - Apply a FLOCK-style lock to a file
1512 * @filp: The file to apply the lock to
1513 * @fl: The lock to be applied
1514 *
1515 * Add a FLOCK style lock to a file.
1516 */
1517int flock_lock_file_wait(struct file *filp, struct file_lock *fl)
1518{
1519	int error;
1520	might_sleep();
1521	for (;;) {
1522		error = flock_lock_file(filp, fl);
1523		if ((error != -EAGAIN) || !(fl->fl_flags & FL_SLEEP))
1524			break;
1525		error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
1526		if (!error)
1527			continue;
1528
1529		locks_delete_block(fl);
1530		break;
1531	}
1532	return error;
1533}
1534
1535EXPORT_SYMBOL(flock_lock_file_wait);
1536
1537/**
1538 *	sys_flock: - flock() system call.
1539 *	@fd: the file descriptor to lock.
1540 *	@cmd: the type of lock to apply.
1541 *
1542 *	Apply a %FL_FLOCK style lock to an open file descriptor.
1543 *	The @cmd can be one of
1544 *
1545 *	%LOCK_SH -- a shared lock.
1546 *
1547 *	%LOCK_EX -- an exclusive lock.
1548 *
1549 *	%LOCK_UN -- remove an existing lock.
1550 *
1551 *	%LOCK_MAND -- a `mandatory' flock.  This exists to emulate Windows Share Modes.
1552 *
1553 *	%LOCK_MAND can be combined with %LOCK_READ or %LOCK_WRITE to allow other
1554 *	processes read and write access respectively.
1555 */
1556asmlinkage long sys_flock(unsigned int fd, unsigned int cmd)
1557{
1558	struct file *filp;
1559	struct file_lock *lock;
1560	int can_sleep, unlock;
1561	int error;
1562
1563	error = -EBADF;
1564	filp = fget(fd);
1565	if (!filp)
1566		goto out;
1567
1568	can_sleep = !(cmd & LOCK_NB);
1569	cmd &= ~LOCK_NB;
1570	unlock = (cmd == LOCK_UN);
1571
1572	if (!unlock && !(cmd & LOCK_MAND) && !(filp->f_mode & 3))
1573		goto out_putf;
1574
1575	error = flock_make_lock(filp, &lock, cmd);
1576	if (error)
1577		goto out_putf;
1578	if (can_sleep)
1579		lock->fl_flags |= FL_SLEEP;
1580
1581	error = security_file_lock(filp, cmd);
1582	if (error)
1583		goto out_free;
1584
1585	if (filp->f_op && filp->f_op->flock)
1586		error = filp->f_op->flock(filp,
1587					  (can_sleep) ? F_SETLKW : F_SETLK,
1588					  lock);
1589	else
1590		error = flock_lock_file_wait(filp, lock);
1591
1592 out_free:
1593	locks_free_lock(lock);
1594
1595 out_putf:
1596	fput(filp);
1597 out:
1598	return error;
1599}
1600
1601/**
1602 * vfs_test_lock - test file byte range lock
1603 * @filp: The file to test lock for
1604 * @fl: The lock to test; also used to hold result
1605 *
1606 * Returns -ERRNO on failure.  Indicates presence of conflicting lock by
1607 * setting conf->fl_type to something other than F_UNLCK.
1608 */
1609int vfs_test_lock(struct file *filp, struct file_lock *fl)
1610{
1611	if (filp->f_op && filp->f_op->lock)
1612		return filp->f_op->lock(filp, F_GETLK, fl);
1613	posix_test_lock(filp, fl);
1614	return 0;
1615}
1616EXPORT_SYMBOL_GPL(vfs_test_lock);
1617
1618static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl)
1619{
1620	flock->l_pid = fl->fl_pid;
1621#if BITS_PER_LONG == 32
1622	/*
1623	 * Make sure we can represent the posix lock via
1624	 * legacy 32bit flock.
1625	 */
1626	if (fl->fl_start > OFFT_OFFSET_MAX)
1627		return -EOVERFLOW;
1628	if (fl->fl_end != OFFSET_MAX && fl->fl_end > OFFT_OFFSET_MAX)
1629		return -EOVERFLOW;
1630#endif
1631	flock->l_start = fl->fl_start;
1632	flock->l_len = fl->fl_end == OFFSET_MAX ? 0 :
1633		fl->fl_end - fl->fl_start + 1;
1634	flock->l_whence = 0;
1635	flock->l_type = fl->fl_type;
1636	return 0;
1637}
1638
1639#if BITS_PER_LONG == 32
1640static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl)
1641{
1642	flock->l_pid = fl->fl_pid;
1643	flock->l_start = fl->fl_start;
1644	flock->l_len = fl->fl_end == OFFSET_MAX ? 0 :
1645		fl->fl_end - fl->fl_start + 1;
1646	flock->l_whence = 0;
1647	flock->l_type = fl->fl_type;
1648}
1649#endif
1650
1651/* Report the first existing lock that would conflict with l.
1652 * This implements the F_GETLK command of fcntl().
1653 */
1654int fcntl_getlk(struct file *filp, struct flock __user *l)
1655{
1656	struct file_lock file_lock;
1657	struct flock flock;
1658	int error;
1659
1660	error = -EFAULT;
1661	if (copy_from_user(&flock, l, sizeof(flock)))
1662		goto out;
1663	error = -EINVAL;
1664	if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK))
1665		goto out;
1666
1667	error = flock_to_posix_lock(filp, &file_lock, &flock);
1668	if (error)
1669		goto out;
1670
1671	error = vfs_test_lock(filp, &file_lock);
1672	if (error)
1673		goto out;
1674 
1675	flock.l_type = file_lock.fl_type;
1676	if (file_lock.fl_type != F_UNLCK) {
1677		error = posix_lock_to_flock(&flock, &file_lock);
1678		if (error)
1679			goto out;
1680	}
1681	error = -EFAULT;
1682	if (!copy_to_user(l, &flock, sizeof(flock)))
1683		error = 0;
1684out:
1685	return error;
1686}
1687
1688/**
1689 * vfs_lock_file - file byte range lock
1690 * @filp: The file to apply the lock to
1691 * @cmd: type of locking operation (F_SETLK, F_GETLK, etc.)
1692 * @fl: The lock to be applied
1693 * @conf: Place to return a copy of the conflicting lock, if found.
1694 *
1695 * A caller that doesn't care about the conflicting lock may pass NULL
1696 * as the final argument.
1697 *
1698 * If the filesystem defines a private ->lock() method, then @conf will
1699 * be left unchanged; so a caller that cares should initialize it to
1700 * some acceptable default.
1701 *
1702 * To avoid blocking kernel daemons, such as lockd, that need to acquire POSIX
1703 * locks, the ->lock() interface may return asynchronously, before the lock has
1704 * been granted or denied by the underlying filesystem, if (and only if)
1705 * fl_grant is set. Callers expecting ->lock() to return asynchronously
1706 * will only use F_SETLK, not F_SETLKW; they will set FL_SLEEP if (and only if)
1707 * the request is for a blocking lock. When ->lock() does return asynchronously,
1708 * it must return -EINPROGRESS, and call ->fl_grant() when the lock
1709 * request completes.
1710 * If the request is for non-blocking lock the file system should return
1711 * -EINPROGRESS then try to get the lock and call the callback routine with
1712 * the result. If the request timed out the callback routine will return a
1713 * nonzero return code and the file system should release the lock. The file
1714 * system is also responsible to keep a corresponding posix lock when it
1715 * grants a lock so the VFS can find out which locks are locally held and do
1716 * the correct lock cleanup when required.
1717 * The underlying filesystem must not drop the kernel lock or call
1718 * ->fl_grant() before returning to the caller with a -EINPROGRESS
1719 * return code.
1720 */
1721int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf)
1722{
1723	if (filp->f_op && filp->f_op->lock)
1724		return filp->f_op->lock(filp, cmd, fl);
1725	else
1726		return posix_lock_file(filp, fl, conf);
1727}
1728EXPORT_SYMBOL_GPL(vfs_lock_file);
1729
1730/* Apply the lock described by l to an open file descriptor.
1731 * This implements both the F_SETLK and F_SETLKW commands of fcntl().
1732 */
1733int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd,
1734		struct flock __user *l)
1735{
1736	struct file_lock *file_lock = locks_alloc_lock();
1737	struct flock flock;
1738	struct inode *inode;
1739	int error;
1740
1741	if (file_lock == NULL)
1742		return -ENOLCK;
1743
1744	/*
1745	 * This might block, so we do it before checking the inode.
1746	 */
1747	error = -EFAULT;
1748	if (copy_from_user(&flock, l, sizeof(flock)))
1749		goto out;
1750
1751	inode = filp->f_path.dentry->d_inode;
1752
1753	/* Don't allow mandatory locks on files that may be memory mapped
1754	 * and shared.
1755	 */
1756	if (IS_MANDLOCK(inode) &&
1757	    (inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID &&
1758	    mapping_writably_mapped(filp->f_mapping)) {
1759		error = -EAGAIN;
1760		goto out;
1761	}
1762
1763again:
1764	error = flock_to_posix_lock(filp, file_lock, &flock);
1765	if (error)
1766		goto out;
1767	if (cmd == F_SETLKW) {
1768		file_lock->fl_flags |= FL_SLEEP;
1769	}
1770	
1771	error = -EBADF;
1772	switch (flock.l_type) {
1773	case F_RDLCK:
1774		if (!(filp->f_mode & FMODE_READ))
1775			goto out;
1776		break;
1777	case F_WRLCK:
1778		if (!(filp->f_mode & FMODE_WRITE))
1779			goto out;
1780		break;
1781	case F_UNLCK:
1782		break;
1783	default:
1784		error = -EINVAL;
1785		goto out;
1786	}
1787
1788	error = security_file_lock(filp, file_lock->fl_type);
1789	if (error)
1790		goto out;
1791
1792	for (;;) {
1793		error = vfs_lock_file(filp, cmd, file_lock, NULL);
1794		if (error != -EAGAIN || cmd == F_SETLK)
1795			break;
1796		error = wait_event_interruptible(file_lock->fl_wait,
1797				!file_lock->fl_next);
1798		if (!error)
1799			continue;
1800
1801		locks_delete_block(file_lock);
1802		break;
1803	}
1804
1805	/*
1806	 * Attempt to detect a close/fcntl race and recover by
1807	 * releasing the lock that was just acquired.
1808	 */
1809	if (!error && fcheck(fd) != filp && flock.l_type != F_UNLCK) {
1810		flock.l_type = F_UNLCK;
1811		goto again;
1812	}
1813
1814out:
1815	locks_free_lock(file_lock);
1816	return error;
1817}
1818
1819#if BITS_PER_LONG == 32
1820/* Report the first existing lock that would conflict with l.
1821 * This implements the F_GETLK command of fcntl().
1822 */
1823int fcntl_getlk64(struct file *filp, struct flock64 __user *l)
1824{
1825	struct file_lock file_lock;
1826	struct flock64 flock;
1827	int error;
1828
1829	error = -EFAULT;
1830	if (copy_from_user(&flock, l, sizeof(flock)))
1831		goto out;
1832	error = -EINVAL;
1833	if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK))
1834		goto out;
1835
1836	error = flock64_to_posix_lock(filp, &file_lock, &flock);
1837	if (error)
1838		goto out;
1839
1840	error = vfs_test_lock(filp, &file_lock);
1841	if (error)
1842		goto out;
1843
1844	flock.l_type = file_lock.fl_type;
1845	if (file_lock.fl_type != F_UNLCK)
1846		posix_lock_to_flock64(&flock, &file_lock);
1847
1848	error = -EFAULT;
1849	if (!copy_to_user(l, &flock, sizeof(flock)))
1850		error = 0;
1851  
1852out:
1853	return error;
1854}
1855
1856/* Apply the lock described by l to an open file descriptor.
1857 * This implements both the F_SETLK and F_SETLKW commands of fcntl().
1858 */
1859int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd,
1860		struct flock64 __user *l)
1861{
1862	struct file_lock *file_lock = locks_alloc_lock();
1863	struct flock64 flock;
1864	struct inode *inode;
1865	int error;
1866
1867	if (file_lock == NULL)
1868		return -ENOLCK;
1869
1870	/*
1871	 * This might block, so we do it before checking the inode.
1872	 */
1873	error = -EFAULT;
1874	if (copy_from_user(&flock, l, sizeof(flock)))
1875		goto out;
1876
1877	inode = filp->f_path.dentry->d_inode;
1878
1879	/* Don't allow mandatory locks on files that may be memory mapped
1880	 * and shared.
1881	 */
1882	if (IS_MANDLOCK(inode) &&
1883	    (inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID &&
1884	    mapping_writably_mapped(filp->f_mapping)) {
1885		error = -EAGAIN;
1886		goto out;
1887	}
1888
1889again:
1890	error = flock64_to_posix_lock(filp, file_lock, &flock);
1891	if (error)
1892		goto out;
1893	if (cmd == F_SETLKW64) {
1894		file_lock->fl_flags |= FL_SLEEP;
1895	}
1896	
1897	error = -EBADF;
1898	switch (flock.l_type) {
1899	case F_RDLCK:
1900		if (!(filp->f_mode & FMODE_READ))
1901			goto out;
1902		break;
1903	case F_WRLCK:
1904		if (!(filp->f_mode & FMODE_WRITE))
1905			goto out;
1906		break;
1907	case F_UNLCK:
1908		break;
1909	default:
1910		error = -EINVAL;
1911		goto out;
1912	}
1913
1914	error = security_file_lock(filp, file_lock->fl_type);
1915	if (error)
1916		goto out;
1917
1918	for (;;) {
1919		error = vfs_lock_file(fi

Large files files are truncated, but you can click here to view the full file