diff -urNX ../exclude linux-2.3.99pre8-linus/fs/fcntl.c linux-2.3.99pre8+lock/fs/fcntl.c
--- linux-2.3.99pre8-linus/fs/fcntl.c	Sun Mar 12 12:03:14 2000
+++ linux-2.3.99pre8+lock/fs/fcntl.c	Sat May 20 04:43:39 2000
@@ -13,6 +15,8 @@
 #include <asm/uaccess.h>
 
 extern int sock_fcntl (struct file *, unsigned int cmd, unsigned long arg);
+extern int fcntl_setlease(unsigned int fd, long arg);
+extern int fcntl_getlease(unsigned int fd);
 
 /*
  * locate_fd finds a free file descriptor in the open_fds fdset,
@@ -181,11 +185,9 @@
 	filp = fget(fd);
 	if (!filp)
 		goto out;
-	err = 0;
-	lock_kernel();
+	err = -EINVAL;
 	switch (cmd) {
 		case F_DUPFD:
-			err = -EINVAL;
 			if (arg < NR_OPEN) {
 				get_file(filp);
 				err = dupfd(filp, arg);
@@ -195,6 +197,7 @@
 			err = FD_ISSET(fd, current->files->close_on_exec);
 			break;
 		case F_SETFD:
+			err = 0;
 			if (arg&1)
 				FD_SET(fd, current->files->close_on_exec);
 			else
@@ -204,14 +207,14 @@
 			err = filp->f_flags;
 			break;
 		case F_SETFL:
+			lock_kernel();
 			err = setfl(fd, filp, arg);
+			unlock_kernel();
 			break;
 		case F_GETLK:
 			err = fcntl_getlk(fd, (struct flock *) arg);
 			break;
 		case F_SETLK:
-			err = fcntl_setlk(fd, cmd, (struct flock *) arg);
-			break;
 		case F_SETLKW:
 			err = fcntl_setlk(fd, cmd, (struct flock *) arg);
 			break;
@@ -226,11 +229,14 @@
 			err = filp->f_owner.pid;
 			break;
 		case F_SETOWN:
+			lock_kernel();
 			filp->f_owner.pid = arg;
 			filp->f_owner.uid = current->uid;
 			filp->f_owner.euid = current->euid;
+			err = 0;
 			if (S_ISSOCK (filp->f_dentry->d_inode->i_mode))
 				err = sock_fcntl (filp, F_SETOWN, arg);
+			unlock_kernel();
 			break;
 		case F_GETSIG:
 			err = filp->f_owner.signum;
@@ -238,21 +244,19 @@
 		case F_SETSIG:
 			/* arg == 0 restores default behaviour. */
 			if (arg < 0 || arg > _NSIG) {
-				err = -EINVAL;
 				break;
 			}
 			err = 0;
 			filp->f_owner.signum = arg;
 			break;
-		default:
-			/* sockets need a few special fcntls. */
-			err = -EINVAL;
-			if (S_ISSOCK (filp->f_dentry->d_inode->i_mode))
-				err = sock_fcntl (filp, cmd, arg);
+		case F_GETLEASE:
+			err = fcntl_getlease(fd);
+			break;
+		case F_SETLEASE:
+			err = fcntl_setlease(fd, arg);
 			break;
 	}
 	fput(filp);
-	unlock_kernel();
 out:
 	return err;
 }
diff -urNX ../exclude linux-2.3.99pre8-linus/fs/lockd/clntlock.c linux-2.3.99pre8+lock/fs/lockd/clntlock.c
--- linux-2.3.99pre8-linus/fs/lockd/clntlock.c	Tue Apr 25 02:13:25 2000
+++ linux-2.3.99pre8+lock/fs/lockd/clntlock.c	Mon May 15 08:31:52 2000
@@ -157,33 +157,38 @@
 	}
 }
 
+/* lockd is way too incestuous with fs/locks.c */
+
 static int
 reclaimer(void *ptr)
 {
 	struct nlm_host	  *host = (struct nlm_host *) ptr;
 	struct nlm_wait	  *block;
-	struct file_lock  *fl;
-	struct inode	  *inode;
+	struct list_head  *tmp;
 
 	/* This one ensures that our parent doesn't terminate while the
 	 * reclaim is in progress */
 	lock_kernel();
 	lockd_up();
+	down(&file_lock_sem);
 
 	/* First, reclaim all locks that have been granted previously. */
-	do {
-		for (fl = file_lock_table; fl; fl = fl->fl_nextlink) {
-			inode = fl->fl_file->f_dentry->d_inode;
-			if (inode->i_sb->s_magic == NFS_SUPER_MAGIC
-			 && nlm_cmp_addr(NFS_ADDR(inode), &host->h_addr)
-			 && fl->fl_u.nfs_fl.state != host->h_state
-			 && (fl->fl_u.nfs_fl.flags & NFS_LCK_GRANTED)) {
-				fl->fl_u.nfs_fl.flags &= ~ NFS_LCK_GRANTED;
-				nlmclnt_reclaim(host, fl);
-				break;
-			}
+restart:
+	tmp = file_lock_list.next;
+	while (tmp != &file_lock_list) {
+		struct file_lock *fl = list_entry(tmp, struct file_lock, fl_link);
+		struct inode *inode = fl->fl_file->f_dentry->d_inode;
+		if (inode->i_sb->s_magic == NFS_SUPER_MAGIC &&
+				nlm_cmp_addr(NFS_ADDR(inode), &host->h_addr) &&
+				fl->fl_u.nfs_fl.state != host->h_state &&
+				(fl->fl_u.nfs_fl.flags & NFS_LCK_GRANTED)) {
+			fl->fl_u.nfs_fl.flags &= ~ NFS_LCK_GRANTED;
+			nlmclnt_reclaim(host, fl);
+			goto restart;
 		}
-	} while (fl);
+		tmp = tmp->next;
+	}
+	up(&file_lock_sem);
 
 	host->h_reclaiming = 0;
 	wake_up(&host->h_gracewait);
diff -urNX ../exclude linux-2.3.99pre8-linus/fs/lockd/svclock.c linux-2.3.99pre8+lock/fs/lockd/svclock.c
--- linux-2.3.99pre8-linus/fs/lockd/svclock.c	Tue Apr 25 02:13:26 2000
+++ linux-2.3.99pre8+lock/fs/lockd/svclock.c	Mon May 15 08:31:52 2000
@@ -347,7 +347,7 @@
 	/* Append to list of blocked */
 	nlmsvc_insert_block(block, NLM_NEVER);
 
-	if (!block->b_call.a_args.lock.fl.fl_prevblock) {
+	if (!list_empty(&block->b_call.a_args.lock.fl.fl_block)) {
 		/* Now add block to block list of the conflicting lock
 		   if we haven't done so. */
 		dprintk("lockd: blocking on this lock.\n");
diff -urNX ../exclude linux-2.3.99pre8-linus/fs/locks.c linux-2.3.99pre8+lock/fs/locks.c
--- linux-2.3.99pre8-linus/fs/locks.c	Mon May 15 07:58:45 2000
+++ linux-2.3.99pre8+lock/fs/locks.c	Sat May 20 04:40:16 2000
@@ -101,72 +101,231 @@
  *  Some adaptations for NFS support.
  *  Olaf Kirch (okir@monad.swb.de), Dec 1996,
  *
- *  Fixed /proc/locks interface so that we can't overrun the buffer we are handed.
+ *  Fixed /proc/locks interface so that we can't overrun the buffer we are
+ *  handed.
  *  Andy Walker (andy@lysaker.kvaerner.no), May 12, 1997.
+ *
+ *  Added process limits to prevent attacks.
+ *  Use slab allocator instead of kmalloc/kfree.
+ *  Use generic list implementation from <linux/list.h>.
+ *  Ensure the lock notifier method is always called when a lock is deleted.
+ *  Sped up posix_locks_deadlock by only considering blocked locks.
+ *  No longer require kernel_lock -- file_lock_sem protects us instead.
+ *  Matthew Wilcox <willy@linuxcare.com>, March, 2000.
  */
 
 #include <linux/malloc.h>
 #include <linux/file.h>
 #include <linux/smp_lock.h>
+#include <linux/init.h>
 
+#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 
-static int flock_make_lock(struct file *filp, struct file_lock *fl,
-			       unsigned int cmd);
-static int posix_make_lock(struct file *filp, struct file_lock *fl,
-			       struct flock *l);
-static int flock_locks_conflict(struct file_lock *caller_fl,
-				struct file_lock *sys_fl);
-static int posix_locks_conflict(struct file_lock *caller_fl,
-				struct file_lock *sys_fl);
-static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl);
-static int flock_lock_file(struct file *filp, struct file_lock *caller,
-			   unsigned int wait);
-static int posix_locks_deadlock(struct file_lock *caller,
-				struct file_lock *blocker);
-
-static struct file_lock *locks_empty_lock(void);
-static struct file_lock *locks_init_lock(struct file_lock *,
-					 struct file_lock *);
-static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl);
-static void locks_delete_lock(struct file_lock **thisfl_p, unsigned int wait);
-static void lock_get_status(char* out, struct file_lock *fl, int id, char *pfx);
-
-static void locks_insert_block(struct file_lock *blocker, struct file_lock *waiter);
-static void locks_delete_block(struct file_lock *blocker, struct file_lock *waiter);
-static void locks_wake_up_blocks(struct file_lock *blocker, unsigned int wait);
-
-struct file_lock *file_lock_table = NULL;
-
-/* Allocate a new lock, and initialize its fields from fl.
- * The lock is not inserted into any lists until locks_insert_lock() or 
- * locks_insert_block() are called.
- */
-static inline struct file_lock *locks_alloc_lock(struct file_lock *fl)
+DECLARE_MUTEX(file_lock_sem);
+
+#define acquire_fl_sem() do {					\
+/*	printk(KERN_DEBUG __FUNCTION__ ": acquiring file_lock_sem\n");*/\
+	down(&file_lock_sem);					\
+/*	printk(KERN_DEBUG __FUNCTION__ ": acquired file_lock_sem\n");*/	\
+} while (0)
+
+#define release_fl_sem()	up(&file_lock_sem)
+
+LIST_HEAD(file_lock_list);
+static LIST_HEAD(blocked_list);
+
+static kmem_cache_t *filelock_cache;
+
+/* Allocate an empty lock structure. */
+static struct file_lock *locks_alloc_lock(int account)
 {
-	return locks_init_lock(locks_empty_lock(), fl);
+	struct file_lock *lock;
+	if (account && current->locks >= current->rlim[RLIMIT_LOCKS].rlim_cur)
+		return NULL;
+	lock = kmem_cache_alloc(filelock_cache, SLAB_KERNEL);
+	if (lock) {
+		current->locks += 1;
+	}
+	return lock;
 }
 
-/* Free lock not inserted in any queue.
- */
-static inline void locks_free_lock(struct file_lock *fl)
+/* Free an unused lock */
+static void locks_free_lock(struct file_lock *fl)
 {
+	if (fl == NULL) {
+		BUG();
+		return;
+	}
+	current->locks -= 1;
 	if (waitqueue_active(&fl->fl_wait))
 		panic("Attempting to free lock with active wait queue");
 
-	if (fl->fl_nextblock != NULL || fl->fl_prevblock != NULL)
+	if (!list_empty(&fl->fl_block))
 		panic("Attempting to free lock with active block list");
-		
-	kfree(fl);
-	return;
+
+	if (!list_empty(&fl->fl_link))
+		panic("Attempting to free lock on active lock list");
+
+	kmem_cache_free(filelock_cache, fl);
 }
 
-/* Check if two locks overlap each other.
+/*
+ * Initialises the fields of the file lock which are invariant for
+ * free file_locks.
  */
-static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2)
+static void init_once(void *foo, kmem_cache_t *cache, unsigned long flags)
 {
-	return ((fl1->fl_end >= fl2->fl_start) &&
-		(fl2->fl_end >= fl1->fl_start));
+	struct file_lock *lock = (struct file_lock *) foo;
+
+	if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) !=
+					SLAB_CTOR_CONSTRUCTOR)
+		return;
+
+	lock->fl_next = NULL;
+	INIT_LIST_HEAD(&lock->fl_link);
+	INIT_LIST_HEAD(&lock->fl_block);
+	init_waitqueue_head(&lock->fl_wait);
+}
+
+/* Initialize a new lock from an existing file_lock structure. */
+static struct file_lock *locks_copy_lock(struct file_lock *new,
+		struct file_lock *fl)
+{
+	new->fl_owner = fl->fl_owner;
+	new->fl_pid = fl->fl_pid;
+	new->fl_file = fl->fl_file;
+	new->fl_flags = fl->fl_flags;
+	new->fl_type = fl->fl_type;
+	new->fl_start = fl->fl_start;
+	new->fl_end = fl->fl_end;
+	new->fl_notify = fl->fl_notify;
+	new->fl_insert = fl->fl_insert;
+	new->fl_remove = fl->fl_remove;
+	new->fl_u = fl->fl_u;
+	return new;
+}
+
+static inline int flock_translate_cmd(int cmd) {
+	switch (cmd &~ LOCK_NB) {
+	case LOCK_SH:
+		return F_RDLCK;
+	case LOCK_EX:
+		return F_WRLCK;
+	case LOCK_UN:
+		return F_UNLCK;
+	}
+	return -EINVAL;
+}
+
+/* Fill in a file_lock structure with an appropriate FLOCK lock. */
+static struct file_lock *flock_make_lock(struct file *filp, unsigned int type)
+{
+	struct file_lock *fl = locks_alloc_lock(1);
+	if (fl == NULL)
+		return NULL;
+
+	fl->fl_owner = NULL;
+	fl->fl_file = filp;
+	fl->fl_flags = FL_FLOCK;
+	fl->fl_type = type;
+	fl->fl_start = 0;
+	fl->fl_end = OFFSET_MAX;
+	fl->fl_notify = NULL;
+	fl->fl_insert = NULL;
+	fl->fl_remove = NULL;
+
+	return fl;
+}
+
+static int assign_type(struct file_lock *fl, int type)
+{
+	switch (type) {
+	case F_RDLCK:
+	case F_WRLCK:
+	case F_UNLCK:
+		fl->fl_type = type;
+		break;
+	default:
+		return 0;
+	}
+	return 1;
+}
+
+/* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX
+ * style lock.
+ */
+static int posix_make_lock(struct file *filp, struct file_lock *fl,
+			   struct flock *l)
+{
+	loff_t start;
+
+	switch (l->l_whence) {
+	case 0: /*SEEK_SET*/
+		start = 0;
+		break;
+	case 1: /*SEEK_CUR*/
+		start = filp->f_pos;
+		break;
+	case 2: /*SEEK_END*/
+		start = filp->f_dentry->d_inode->i_size;
+		break;
+	default:
+		return 0;
+	}
+
+	start += l->l_start;
+	if ((start < 0) || (l->l_len < 0))
+		return 0;
+	fl->fl_start = start;	/* we record the absolute position */
+
+	fl->fl_end = start + l->l_len - 1;
+	if (l->l_len == 0)
+		fl->fl_end = OFFSET_MAX;
+
+	fl->fl_owner = current->files;
+	fl->fl_pid = current->pid;
+	fl->fl_file = filp;
+	fl->fl_flags = FL_POSIX;
+	fl->fl_notify = NULL;
+	fl->fl_insert = NULL;
+	fl->fl_remove = NULL;
+
+	return assign_type(fl, l->l_type);
+}
+
+/* Allocate a file_lock initialised to this type of lease */
+static struct file_lock *lease_alloc(struct file *filp, int type)
+{
+	struct file_lock *fl = locks_alloc_lock(1);
+	if (fl == NULL)
+		return NULL;
+
+	fl->fl_owner = current->files;
+	fl->fl_pid = current->pid;
+
+	fl->fl_file = filp;
+	fl->fl_flags = FL_LEASE;
+	if (assign_type(fl, type) == 0)
+		goto bad;
+	fl->fl_start = 0;
+	fl->fl_end = OFFSET_MAX;
+	fl->fl_notify = NULL;
+	fl->fl_insert = NULL;
+	fl->fl_remove = NULL;
+
+	return fl;
+
+bad:
+	locks_free_lock(fl);
+	return NULL;
+}
+
+/* Check if two locks overlap each other. */
+static int locks_overlap(struct file_lock *fl1, struct file_lock *fl2)
+{
+	return  (fl1->fl_end >= fl2->fl_start) &&
+		(fl2->fl_end >= fl1->fl_start);
 }
 
 /*
@@ -174,86 +333,108 @@
  * N.B. Do we need the test on PID as well as owner?
  * (Clone tasks should be considered as one "owner".)
  */
-static inline int
-locks_same_owner(struct file_lock *fl1, struct file_lock *fl2)
+static int locks_same_owner(struct file_lock *fl1, struct file_lock *fl2)
 {
 	return (fl1->fl_owner == fl2->fl_owner) &&
 	       (fl1->fl_pid   == fl2->fl_pid);
 }
 
-/* Insert waiter into blocker's block list.
- * We use a circular list so that processes can be easily woken up in
- * the order they blocked. The documentation doesn't require this but
- * it seems like the reasonable thing to do.
+/* Determine if lock sys_fl blocks lock caller_fl. Common functionality
+ * checks for overlapping locks and shared/exclusive status.
  */
-static void locks_insert_block(struct file_lock *blocker, 
-			       struct file_lock *waiter)
+static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
 {
-	struct file_lock *prevblock;
+	if (!locks_overlap(caller_fl, sys_fl))
+		return 0;
 
-	if (waiter->fl_prevblock) {
-		printk(KERN_ERR "locks_insert_block: remove duplicated lock "
-			"(pid=%d %Ld-%Ld type=%d)\n",
-			waiter->fl_pid, (long long)waiter->fl_start,
-			(long long)waiter->fl_end, waiter->fl_type);
-		locks_delete_block(waiter->fl_prevblock, waiter);
-	}
-
-	if (blocker->fl_prevblock == NULL)
-		/* No previous waiters - list is empty */
-		prevblock = blocker;
-	else
-		/* Previous waiters exist - add to end of list */
-		prevblock = blocker->fl_prevblock;
-
-	prevblock->fl_nextblock = waiter;
-	blocker->fl_prevblock = waiter;
-	waiter->fl_nextblock = blocker;
-	waiter->fl_prevblock = prevblock;
-	
-	return;
+	switch (caller_fl->fl_type) {
+	case F_RDLCK:
+		return (sys_fl->fl_type == F_WRLCK);
+		
+	case F_WRLCK:
+		return 1;
+
+	default:
+		printk("locks_conflict(): impossible lock type - %d\n",
+		       caller_fl->fl_type);
+		break;
+	}
+	return 0;	/* This should never happen */
 }
 
-/* Remove waiter from blocker's block list.
- * When blocker ends up pointing to itself then the list is empty.
+/* Determine if lock sys_fl blocks lock caller_fl. POSIX specific
+ * checking before calling the locks_conflict().
  */
-static void locks_delete_block(struct file_lock *blocker,
-			       struct file_lock *waiter)
+static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
 {
-	struct file_lock *nextblock;
-	struct file_lock *prevblock;
-	
-	nextblock = waiter->fl_nextblock;
-	prevblock = waiter->fl_prevblock;
+	/* POSIX locks owned by the same process do not conflict with
+	 * each other.
+	 */
+	if (!(sys_fl->fl_flags & FL_POSIX) ||
+			locks_same_owner(caller_fl, sys_fl))
+		return 0;
 
-	if (nextblock == NULL)
-		return;
-	
-	nextblock->fl_prevblock = prevblock;
-	prevblock->fl_nextblock = nextblock;
+	return locks_conflict(caller_fl, sys_fl);
+}
+
+/* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific
+ * checking before calling the locks_conflict().
+ */
+static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
+{
+	/* FLOCK locks referring to the same filp do not conflict with
+	 * each other.
+	 */
+	if (!(sys_fl->fl_flags & FL_FLOCK) ||
+	    (caller_fl->fl_file == sys_fl->fl_file))
+		return 0;
 
-	waiter->fl_prevblock = waiter->fl_nextblock = NULL;
-	if (blocker->fl_nextblock == blocker)
-		/* No more locks on blocker's blocked list */
-		blocker->fl_prevblock = blocker->fl_nextblock = NULL;
-	return;
+	return locks_conflict(caller_fl, sys_fl);
 }
 
-/* The following two are for the benefit of lockd.
+/* Insert file lock fl into an inode's lock list at the position indicated
+ * by pos. At the same time add the lock to the global file lock list.
  */
-void
-posix_block_lock(struct file_lock *blocker, struct file_lock *waiter)
+static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl)
 {
-	locks_insert_block(blocker, waiter);
-	return;
+	list_add(&fl->fl_link, &file_lock_list);
+
+	/* insert into file's list */
+	fl->fl_next = *pos;
+	*pos = fl;
+
+	if (fl->fl_insert)
+		fl->fl_insert(fl);
 }
 
-void
-posix_unblock_lock(struct file_lock *waiter)
+/* Remove waiter from blocker's block list.
+ * When blocker ends up pointing to itself then the list is empty.
+ */
+static inline void locks_delete_block(struct file_lock *waiter)
+{
+	list_del(&waiter->fl_block);
+	INIT_LIST_HEAD(&waiter->fl_block);
+	list_del(&waiter->fl_link);
+	INIT_LIST_HEAD(&waiter->fl_link);
+}
+
+/* Insert waiter into blocker's block list.
+ * We use a circular list so that processes can be easily woken up in
+ * the order they blocked. The documentation doesn't require this but
+ * it seems like the reasonable thing to do.
+ */
+static inline void locks_insert_block(struct file_lock *blocker, 
+			       struct file_lock *waiter)
 {
-	if (waiter->fl_prevblock)
-		locks_delete_block(waiter->fl_prevblock, waiter);
-	return;
+	if (!list_empty(&waiter->fl_block)) {
+		printk(KERN_ERR "locks_insert_block: removing duplicated lock "
+			"(pid=%d %Ld-%Ld type=%d)\n", waiter->fl_pid,
+			waiter->fl_start, waiter->fl_end, waiter->fl_type);
+		locks_delete_block(waiter);
+	}
+	list_add_tail(&waiter->fl_block, &blocker->fl_block);
+	list_add(&waiter->fl_link, &blocked_list);
+	waiter->fl_next = blocker;
 }
 
 /* Wake up processes blocked waiting for blocker.
@@ -262,56 +443,132 @@
  */
 static void locks_wake_up_blocks(struct file_lock *blocker, unsigned int wait)
 {
-	struct file_lock *waiter;
-
-	while ((waiter = blocker->fl_nextblock) != NULL) {
+	while (!list_empty(&blocker->fl_block)) {
+		struct file_lock *waiter = list_entry(&blocker->fl_block,
+						struct file_lock, fl_block);
 		/* N.B. Is it possible for the notify function to block?? */
-		if (waiter->fl_notify)
+		if (waiter->fl_notify) {
+			printk(KERN_EMERG "fl_notify = %p\n", waiter->fl_notify);
 			waiter->fl_notify(waiter);
+		} else {
+			printk(KERN_EMERG "fl_notify = NULL\n");
+		}
 		wake_up(&waiter->fl_wait);
 		if (wait) {
 			/* Let the blocked process remove waiter from the
 			 * block list when it gets scheduled.
 			 */
+printk("locks_wake_up_blocks: scheduling\n");
 			current->policy |= SCHED_YIELD;
 			schedule();
 		} else {
 			/* Remove waiter from the block list, because by the
 			 * time it wakes up blocker won't exist any more.
 			 */
-			locks_delete_block(blocker, waiter);
+			locks_delete_block(waiter);
 		}
 	}
-	return;
 }
 
-/* flock() system call entry point. Apply a FL_FLOCK style lock to
- * an open file descriptor.
+/* Delete a lock and then free it.
+ * Remove our lock from the lock lists, wake up processes that are blocked
+ * waiting for this lock, notify the FS that the lock has been cleared and
+ * finally free the lock.
  */
-asmlinkage long sys_flock(unsigned int fd, unsigned int cmd)
+static void locks_delete_lock(struct file_lock **thisfl_p, unsigned int wait)
 {
-	struct file_lock file_lock;
-	struct file *filp;
-	int error;
+	int (*lock)(struct file *, int, struct file_lock *);
+	struct file_lock *fl = *thisfl_p;
 
-	lock_kernel();
-	error = -EBADF;
-	filp = fget(fd);
-	if (!filp)
-		goto out;
-	error = -EINVAL;
-	if (!flock_make_lock(filp, &file_lock, cmd))
-		goto out_putf;
-	error = -EBADF;
-	if ((file_lock.fl_type != F_UNLCK) && !(filp->f_mode & 3))
-		goto out_putf;
-	error = flock_lock_file(filp, &file_lock,
-				(cmd & (LOCK_UN | LOCK_NB)) ? 0 : 1);
-out_putf:
-	fput(filp);
-out:
-	unlock_kernel();
-	return (error);
+	*thisfl_p = fl->fl_next;
+	fl->fl_next = NULL;
+
+	list_del(&fl->fl_link);
+	INIT_LIST_HEAD(&fl->fl_link);
+
+	if (fl->fl_remove)
+		fl->fl_remove(fl);
+
+	locks_wake_up_blocks(fl, wait);
+	lock = fl->fl_file->f_op->lock;
+	if (lock) {
+		fl->fl_type = F_UNLCK;
+		lock(fl->fl_file, F_SETLK, fl);
+	}
+	locks_free_lock(fl);
+}
+
+int interruptible_sleep_on_locked(wait_queue_head_t *fl_wait, struct semaphore *sem, int timeout)
+{
+	int result = 0;
+	wait_queue_t wait;
+	init_waitqueue_entry(&wait, current);
+
+	__add_wait_queue(fl_wait, &wait);
+	current->state = TASK_INTERRUPTIBLE;
+	up(sem);
+	if (timeout == 0) {
+		schedule();
+	} else {
+		result = schedule_timeout(timeout);
+	}
+	if (signal_pending(current)) {
+		result = -ERESTARTSYS;
+	}
+	down(sem);
+	remove_wait_queue(fl_wait, &wait);
+	current->state = TASK_RUNNING;
+	return result;
+}
+
+static int locks_block_on(struct file_lock *blocker, struct file_lock *waiter)
+{
+	int result;
+	locks_insert_block(blocker, waiter);
+	result = interruptible_sleep_on_locked(&waiter->fl_wait, &file_lock_sem, 0);
+	locks_delete_block(waiter);
+	return result;
+}
+
+/* This function tests for deadlock condition before putting a process to
+ * sleep. The detection scheme is no longer recursive. Recursive was neat,
+ * but dangerous - we risked stack corruption if the lock data was bad, or
+ * if the recursion was too deep for any other reason.
+ *
+ * We rely on the fact that a task can only be on one lock's wait queue
+ * at a time. When we find blocked_task on a wait queue we can re-search
+ * with blocked_task equal to that queue's owner, until either blocked_task
+ * isn't found, or blocked_task is found on a queue owned by my_task.
+ *
+ * Note: the above assumption may not be true when handling lock requests
+ * from a broken NFS client. But broken NFS clients have a lot more to
+ * worry about than proper deadlock detection anyway... --okir
+ */
+static int posix_locks_deadlock(struct file_lock *caller_fl,
+				struct file_lock *block_fl)
+{
+	struct file_lock *fl = block_fl;
+	struct list_head *tmp = blocked_list.next;
+	fl_owner_t 	caller_owner, blocked_owner;
+	unsigned int	caller_pid, blocked_pid;
+
+	caller_owner = caller_fl->fl_owner;
+	caller_pid = caller_fl->fl_pid;
+
+next_task:
+	blocked_owner = fl->fl_owner;
+	blocked_pid = fl->fl_pid;
+	if (caller_owner == blocked_owner && caller_pid == blocked_pid)
+		return 1;
+	while (tmp != &blocked_list) {
+		fl = list_entry(tmp, struct file_lock, fl_link);
+		tmp = tmp->next;
+		if (fl->fl_owner != blocked_owner || fl->fl_pid != blocked_pid)
+			continue;
+		fl = fl->fl_next;
+		goto next_task;
+	}
+	return 0;
 }
 
 /* Report the first existing lock that would conflict with l.
@@ -320,7 +577,7 @@
 int fcntl_getlk(unsigned int fd, struct flock *l)
 {
 	struct file *filp;
-	struct file_lock *fl,file_lock;
+	struct file_lock *fl, file_lock;
 	struct flock flock;
 	int error;
 
@@ -343,11 +600,13 @@
 		error = filp->f_op->lock(filp, F_GETLK, &file_lock);
 		if (error < 0)
 			goto out_putf;
-		else if (error == LOCK_USE_CLNT)
-		  /* Bypass for NFS with no locking - 2.0.36 compat */
-		  fl = posix_test_lock(filp, &file_lock);
-		else
-		  fl = (file_lock.fl_type == F_UNLCK ? NULL : &file_lock);
+
+		if (error == LOCK_USE_CLNT) {
+			/* Bypass for NFS with no locking - 2.0.36 compat */
+			fl = posix_test_lock(filp, &file_lock);
+		} else {
+			fl = (file_lock.fl_type == F_UNLCK ? NULL : &file_lock);
+		}
 	} else {
 		fl = posix_test_lock(filp, &file_lock);
 	}
@@ -377,7 +636,7 @@
 int fcntl_setlk(unsigned int fd, unsigned int cmd, struct flock *l)
 {
 	struct file *filp;
-	struct file_lock file_lock;
+	struct file_lock *fl = locks_alloc_lock(0);
 	struct flock flock;
 	struct inode *inode;
 	int error;
@@ -389,8 +648,7 @@
 	if (copy_from_user(&flock, l, sizeof(flock)))
 		goto out;
 
-	/* Get arguments and validate them ...
-	 */
+	/* Get arguments and validate them ...  */
 
 	error = -EBADF;
 	filp = fget(fd);
@@ -419,7 +677,7 @@
 	}
 
 	error = -EINVAL;
-	if (!posix_make_lock(filp, &file_lock, &flock))
+	if (!posix_make_lock(filp, fl, &flock))
 		goto out_putf;
 	
 	error = -EBADF;
@@ -442,8 +700,8 @@
 	static int count = 0;
 	if (!count) {
 		count=1;
-		printk(KERN_WARNING
-		       "fcntl_setlk() called by process %d (%s) with broken flock() emulation\n",
+		printk(KERN_WARNING "fcntl_setlk() called by process %d (%s) "
+				"with broken flock() emulation\n",
 		       current->pid, current->comm);
 	}
 }
@@ -457,409 +715,187 @@
 	}
 
 	if (filp->f_op->lock != NULL) {
-		error = filp->f_op->lock(filp, cmd, &file_lock);
+		error = filp->f_op->lock(filp, cmd, fl);
 		if (error < 0)
 			goto out_putf;
 	}
-	error = posix_lock_file(filp, &file_lock, cmd == F_SETLKW);
+	error = posix_lock_file(filp, fl, cmd == F_SETLKW);
 
 out_putf:
 	fput(filp);
 out:
+	locks_free_lock(fl);
 	return error;
 }
 
 /*
  * This function is called when the file is being removed
- * from the task's fd array.
+ * from the task's fd array.  For POSIX locks we free all
+ * locks on this file for the given task.
  */
 void locks_remove_posix(struct file *filp, fl_owner_t owner)
 {
-	struct inode * inode = filp->f_dentry->d_inode;
-	struct file_lock file_lock, *fl;
-	struct file_lock **before;
-
-	/*
-	 * For POSIX locks we free all locks on this file for the given task.
-	 */
-repeat:
+	struct inode *inode = filp->f_dentry->d_inode;
+	struct file_lock *fl, **before;
+	acquire_fl_sem();
 	before = &inode->i_flock;
 	while ((fl = *before) != NULL) {
-		if ((fl->fl_flags & FL_POSIX) && fl->fl_owner == owner) {
-			int (*lock)(struct file *, int, struct file_lock *);
-			lock = filp->f_op->lock;
-			if (lock) {
-				file_lock = *fl;
-				file_lock.fl_type = F_UNLCK;
-			}
-			locks_delete_lock(before, 0);
-			if (lock) {
-				lock(filp, F_SETLK, &file_lock);
-				/* List may have changed: */
-				goto repeat;
-			}
-			continue;
-		}
-		before = &fl->fl_next;
-	}
-}
-
-/*
- * This function is called on the last close of an open file.
- */
-void locks_remove_flock(struct file *filp)
-{
-	struct inode * inode = filp->f_dentry->d_inode; 
-	struct file_lock file_lock, *fl;
-	struct file_lock **before;
-
-repeat:
-	before = &inode->i_flock;
-	while ((fl = *before) != NULL) {
-		if ((fl->fl_flags & FL_FLOCK) && fl->fl_file == filp) {
-			int (*lock)(struct file *, int, struct file_lock *);
-			lock = NULL;
-			if (filp->f_op)
-				lock = filp->f_op->lock;
-			if (lock) {
-				file_lock = *fl;
-				file_lock.fl_type = F_UNLCK;
-			}
-			locks_delete_lock(before, 0);
-			if (lock) {
-				lock(filp, F_SETLK, &file_lock);
-				/* List may have changed: */
-				goto repeat;
-			}
-			continue;
-		}
-		before = &fl->fl_next;
-	}
-}
-
-struct file_lock *
-posix_test_lock(struct file *filp, struct file_lock *fl)
-{
-	struct file_lock *cfl;
-
-	for (cfl = filp->f_dentry->d_inode->i_flock; cfl; cfl = cfl->fl_next) {
-		if (!(cfl->fl_flags & FL_POSIX))
-			continue;
-		if (posix_locks_conflict(cfl, fl))
-			break;
-	}
-
-	return (cfl);
-}
-
-int locks_mandatory_locked(struct inode *inode)
-{
-	fl_owner_t owner = current->files;
-	struct file_lock *fl;
-
-	/*
-	 * Search the lock list for this inode for any POSIX locks.
-	 */
-	lock_kernel();
-	for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
-		if (!(fl->fl_flags & FL_POSIX))
-			continue;
-		if (fl->fl_owner != owner)
-			break;
-	}
-	unlock_kernel();
-	return fl ? -EAGAIN : 0;
-}
-
-int locks_mandatory_area(int read_write, struct inode *inode,
-			 struct file *filp, loff_t offset,
-			 size_t count)
-{
-	struct file_lock *fl;
-	struct file_lock tfl;
-	int error;
-
-	memset(&tfl, 0, sizeof(tfl));
-
-	tfl.fl_file = filp;
-	tfl.fl_flags = FL_POSIX | FL_ACCESS;
-	tfl.fl_owner = current->files;
-	tfl.fl_pid = current->pid;
-	init_waitqueue_head(&tfl.fl_wait);
-	tfl.fl_type = (read_write == FLOCK_VERIFY_WRITE) ? F_WRLCK : F_RDLCK;
-	tfl.fl_start = offset;
-	tfl.fl_end = offset + count - 1;
-
-	error = 0;
-	lock_kernel();
-
-repeat:
-	/* Search the lock list for this inode for locks that conflict with
-	 * the proposed read/write.
-	 */
-	for (fl = inode->i_flock; ; fl = fl->fl_next) {
-		error = 0;
-		if (!fl)
-			break;
-		if (!(fl->fl_flags & FL_POSIX))
-			continue;
-		/* Block for writes against a "read" lock,
-		 * and both reads and writes against a "write" lock.
-		 */
-		if (posix_locks_conflict(&tfl, fl)) {
-			error = -EAGAIN;
-			if (filp && (filp->f_flags & O_NONBLOCK))
-				break;
-			error = -ERESTARTSYS;
-			if (signal_pending(current))
-				break;
-			error = -EDEADLK;
-			if (posix_locks_deadlock(&tfl, fl))
-				break;
-
-			locks_insert_block(fl, &tfl);
-			interruptible_sleep_on(&tfl.fl_wait);
-			locks_delete_block(fl, &tfl);
-
-			/*
-			 * If we've been sleeping someone might have
-			 * changed the permissions behind our back.
-			 */
-			if ((inode->i_mode & (S_ISGID | S_IXGRP)) != S_ISGID)
-				break;
-			goto repeat;
-		}
-	}
-	unlock_kernel();
-	return error;
-}
-
-/* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX
- * style lock.
- */
-static int posix_make_lock(struct file *filp, struct file_lock *fl,
-			   struct flock *l)
-{
-	loff_t start;
-
-	memset(fl, 0, sizeof(*fl));
-	
-	init_waitqueue_head(&fl->fl_wait);
-	fl->fl_flags = FL_POSIX;
-
-	switch (l->l_type) {
-	case F_RDLCK:
-	case F_WRLCK:
-	case F_UNLCK:
-		fl->fl_type = l->l_type;
-		break;
-	default:
-		return (0);
-	}
-
-	switch (l->l_whence) {
-	case 0: /*SEEK_SET*/
-		start = 0;
-		break;
-	case 1: /*SEEK_CUR*/
-		start = filp->f_pos;
-		break;
-	case 2: /*SEEK_END*/
-		start = filp->f_dentry->d_inode->i_size;
-		break;
-	default:
-		return (0);
-	}
-
-	if (((start += l->l_start) < 0) || (l->l_len < 0))
-		return (0);
-	fl->fl_end = start + l->l_len - 1;
-	if (l->l_len > 0 && fl->fl_end < 0)
-		return (0);
-	fl->fl_start = start;	/* we record the absolute position */
-	if (l->l_len == 0)
-		fl->fl_end = OFFSET_MAX;
-	
-	fl->fl_file = filp;
-	fl->fl_owner = current->files;
-	fl->fl_pid = current->pid;
-
-	return (1);
-}
-
-/* Verify a call to flock() and fill in a file_lock structure with
- * an appropriate FLOCK lock.
- */
-static int flock_make_lock(struct file *filp, struct file_lock *fl,
-			   unsigned int cmd)
-{
-	memset(fl, 0, sizeof(*fl));
-
-	init_waitqueue_head(&fl->fl_wait);
-
-	switch (cmd & ~LOCK_NB) {
-	case LOCK_SH:
-		fl->fl_type = F_RDLCK;
-		break;
-	case LOCK_EX:
-		fl->fl_type = F_WRLCK;
-		break;
-	case LOCK_UN:
-		fl->fl_type = F_UNLCK;
-		break;
-	default:
-		return (0);
+		if ((fl->fl_flags & FL_POSIX) && fl->fl_owner == owner) {
+			locks_delete_lock(before, 0);
+		}
+		before = &fl->fl_next;
 	}
-
-	fl->fl_flags = FL_FLOCK;
-	fl->fl_start = 0;
-	fl->fl_end = OFFSET_MAX;
-	fl->fl_file = filp;
-	fl->fl_owner = NULL;
-	
-	return (1);
+	release_fl_sem();
 }
 
-/* Determine if lock sys_fl blocks lock caller_fl. POSIX specific
- * checking before calling the locks_conflict().
+/*
+ * This function is called on the last close of an open file.
  */
-static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
+void locks_remove_flock(struct file *filp)
 {
-	/* POSIX locks owned by the same process do not conflict with
-	 * each other.
-	 */
-	if (!(sys_fl->fl_flags & FL_POSIX) ||
-	    locks_same_owner(caller_fl, sys_fl))
-		return (0);
+	struct inode * inode = filp->f_dentry->d_inode; 
+	struct file_lock *fl, **before;
 
-	return (locks_conflict(caller_fl, sys_fl));
+	acquire_fl_sem();
+	before = &inode->i_flock;
+	while ((fl = *before) != NULL) {
+		if ((fl->fl_flags & FL_FLOCK) && fl->fl_file == filp) {
+			locks_delete_lock(before, 0);
+		}
+		before = &fl->fl_next;
+	}
+	release_fl_sem();
 }
 
-/* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific
- * checking before calling the locks_conflict().
- */
-static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
+struct file_lock *
+posix_test_lock(struct file *filp, struct file_lock *fl)
 {
-	/* FLOCK locks referring to the same filp do not conflict with
-	 * each other.
-	 */
-	if (!(sys_fl->fl_flags & FL_FLOCK) ||
-	    (caller_fl->fl_file == sys_fl->fl_file))
-		return (0);
+	struct file_lock *cfl;
+
+	acquire_fl_sem();
+	for (cfl = filp->f_dentry->d_inode->i_flock; cfl; cfl = cfl->fl_next) {
+		if (!(cfl->fl_flags & FL_POSIX))
+			continue;
+		if (posix_locks_conflict(cfl, fl))
+			break;
+	}
+	release_fl_sem();
 
-	return (locks_conflict(caller_fl, sys_fl));
+	return cfl;
 }
 
-/* Determine if lock sys_fl blocks lock caller_fl. Common functionality
- * checks for overlapping locks and shared/exclusive status.
- */
-static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
+int locks_mandatory_locked(struct inode *inode)
 {
-	if (!locks_overlap(caller_fl, sys_fl))
-		return (0);
-
-	switch (caller_fl->fl_type) {
-	case F_RDLCK:
-		return (sys_fl->fl_type == F_WRLCK);
-		
-	case F_WRLCK:
-		return (1);
+	fl_owner_t owner = current->files;
+	struct file_lock *fl;
 
-	default:
-		printk("locks_conflict(): impossible lock type - %d\n",
-		       caller_fl->fl_type);
-		break;
+	/*
+	 * Search the lock list for this inode for any POSIX locks.
+	 */
+	acquire_fl_sem();
+	for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
+		if (!(fl->fl_flags & FL_POSIX))
+			continue;
+		if (fl->fl_owner != owner)
+			break;
 	}
-	return (0);	/* This should never happen */
+	release_fl_sem();
+	return fl ? -EAGAIN : 0;
 }
 
-/* This function tests for deadlock condition before putting a process to
- * sleep. The detection scheme is no longer recursive. Recursive was neat,
- * but dangerous - we risked stack corruption if the lock data was bad, or
- * if the recursion was too deep for any other reason.
- *
- * We rely on the fact that a task can only be on one lock's wait queue
- * at a time. When we find blocked_task on a wait queue we can re-search
- * with blocked_task equal to that queue's owner, until either blocked_task
- * isn't found, or blocked_task is found on a queue owned by my_task.
- *
- * Note: the above assumption may not be true when handling lock requests
- * from a broken NFS client. But broken NFS clients have a lot more to
- * worry about than proper deadlock detection anyway... --okir
- */
-static int posix_locks_deadlock(struct file_lock *caller_fl,
-				struct file_lock *block_fl)
+int locks_mandatory_area(int read_write, struct inode *inode,
+			 struct file *filp, loff_t offset,
+			 size_t count)
 {
 	struct file_lock *fl;
-	struct file_lock *bfl;
-	void		 *caller_owner, *blocked_owner;
-	unsigned int	 caller_pid, blocked_pid;
+	struct file_lock *tfl = locks_alloc_lock(0);
+	int error;
 
-	caller_owner = caller_fl->fl_owner;
-	caller_pid = caller_fl->fl_pid;
-	blocked_owner = block_fl->fl_owner;
-	blocked_pid = block_fl->fl_pid;
+	tfl->fl_owner = current->files;
+	tfl->fl_pid = current->pid;
+	tfl->fl_file = filp;
+	tfl->fl_flags = FL_POSIX | FL_ACCESS;
+	tfl->fl_type = (read_write == FLOCK_VERIFY_WRITE) ? F_WRLCK : F_RDLCK;
+	tfl->fl_start = offset;
+	tfl->fl_end = offset + count - 1;
 
-next_task:
-	if (caller_owner == blocked_owner && caller_pid == blocked_pid)
-		return (1);
-	for (fl = file_lock_table; fl != NULL; fl = fl->fl_nextlink) {
-		if (fl->fl_owner == NULL || fl->fl_nextblock == NULL)
+	error = 0;
+	acquire_fl_sem();
+
+	/* Search the lock list for this inode for locks that conflict with
+	 * the proposed read/write.
+	 */
+	for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
+		if (!(fl->fl_flags & FL_POSIX))
 			continue;
-		for (bfl = fl->fl_nextblock; bfl != fl; bfl = bfl->fl_nextblock) {
-			if (bfl->fl_owner == blocked_owner &&
-			    bfl->fl_pid == blocked_pid) {
-				if (fl->fl_owner == caller_owner &&
-				    fl->fl_pid == caller_pid) {
-					return (1);
-				}
-				blocked_owner = fl->fl_owner;
-				blocked_pid = fl->fl_pid;
-				goto next_task;
-			}
-		}
+		if (fl->fl_start > tfl->fl_end)
+			break;
+		error = 0;
+		if (!posix_locks_conflict(tfl, fl))
+			continue;
+
+		error = -EAGAIN;
+		if (filp && (filp->f_flags & O_NONBLOCK))
+			break;
+		error = -EDEADLK;
+		if (posix_locks_deadlock(tfl, fl))
+			break;
+
+		error = locks_block_on(fl, tfl);
+		if (error != 0)
+			break;
+
+		/*
+		 * If we've been sleeping someone might have
+		 * changed the permissions behind our back.
+		 */
+		if ((inode->i_mode & (S_ISGID | S_IXGRP)) != S_ISGID)
+			break;
+		fl = inode->i_flock;
 	}
-	return (0);
+	release_fl_sem();
+	locks_free_lock(tfl);
+	return error;
 }
 
-/* Try to create a FLOCK lock on filp. We always insert new FLOCK locks at
- * the head of the list, but that's secret knowledge known only to the next
- * two functions.
+/* Try to create a FLOCK lock on filp. We always insert new FLOCK locks
+ * at the head of the list, but that's secret knowledge known only to
+ * flock_lock_file and posix_lock_file.
  */
-static int flock_lock_file(struct file *filp, struct file_lock *caller,
+static int flock_lock_file(struct file *filp, unsigned int lock_type,
 			   unsigned int wait)
 {
 	struct file_lock *fl;
 	struct file_lock *new_fl = NULL;
 	struct file_lock **before;
-	struct inode * inode = filp->f_dentry->d_inode;
+	struct inode *inode = filp->f_dentry->d_inode;
 	int error, change;
-	int unlock = (caller->fl_type == F_UNLCK);
+	int unlock = (lock_type == F_UNLCK);
 
-	/*
-	 * If we need a new lock, get it in advance to avoid races.
-	 */
 	if (!unlock) {
 		error = -ENOLCK;
-		new_fl = locks_alloc_lock(caller);
-		if (!new_fl)
-			goto out;
+		new_fl = flock_make_lock(filp, lock_type);
+		if (new_fl == NULL)
+			return error;
 	}
 
 	error = 0;
 search:
 	change = 0;
 	before = &inode->i_flock;
-	while (((fl = *before) != NULL) && (fl->fl_flags & FL_FLOCK)) {
-		if (caller->fl_file == fl->fl_file) {
-			if (caller->fl_type == fl->fl_type)
+	for (;;) {
+		fl = *before;
+		if ((fl == NULL) || ((fl->fl_flags & FL_FLOCK) == 0))
+			break;
+		if (filp == fl->fl_file) {
+			if (lock_type == fl->fl_type)
 				goto out;
 			change = 1;
 			break;
 		}
 		before = &fl->fl_next;
 	}
-	/* change means that we are changing the type of an existing lock, or
+	/* change means that we are changing the type of an existing lock,
 	 * or else unlocking it.
 	 */
 	if (change) {
@@ -874,11 +910,6 @@
 	if (unlock)
 		goto out;
 
-repeat:
-	/* Check signals each time we start */
-	error = -ERESTARTSYS;
-	if (signal_pending(current))
-		goto out;
 	for (fl = inode->i_flock; (fl != NULL) && (fl->fl_flags & FL_FLOCK);
 	     fl = fl->fl_next) {
 		if (!flock_locks_conflict(new_fl, fl))
@@ -886,10 +917,12 @@
 		error = -EAGAIN;
 		if (!wait)
 			goto out;
-		locks_insert_block(fl, new_fl);
-		interruptible_sleep_on(&new_fl->fl_wait);
-		locks_delete_block(fl, new_fl);
-		goto repeat;
+
+		error = locks_block_on(fl, new_fl);
+		if (error != 0)
+			goto out;
+
+		fl = inode->i_flock;
 	}
 	locks_insert_lock(&inode->i_flock, new_fl);
 	new_fl = NULL;
@@ -901,7 +934,13 @@
 	return error;
 }
 
-/* Add a POSIX style lock to a file.
+/**
+ *	posix_lock_file:
+ *	@filp: The file to apply the lock to
+ *	@caller: The lock to be applied
+ *	@wait: 1 to retry automatically, 0 to return -EAGAIN
+ *
+ * Add a POSIX style lock to a file.
  * We merge adjacent locks whenever possible. POSIX locks are sorted by owner
  * task, then by starting address
  *
@@ -924,18 +963,21 @@
 	struct inode * inode = filp->f_dentry->d_inode;
 	int error, added = 0;
 
+	if (caller->fl_notify != NULL)
+		printk("notify = %p\n", caller->fl_notify);
+
+	acquire_fl_sem();
 	/*
 	 * We may need two file_lock structures for this operation,
 	 * so we get them in advance to avoid races.
 	 */
-	new_fl  = locks_empty_lock();
-	new_fl2 = locks_empty_lock();
+	new_fl = locks_alloc_lock(0);
+	new_fl2 = locks_alloc_lock(0);
 	error = -ENOLCK; /* "no luck" */
 	if (!(new_fl && new_fl2))
 		goto out;
 
 	if (caller->fl_type != F_UNLCK) {
-  repeat:
 		for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
 			if (!(fl->fl_flags & FL_POSIX))
 				continue;
@@ -947,13 +989,12 @@
 			error = -EDEADLK;
 			if (posix_locks_deadlock(caller, fl))
 				goto out;
-			error = -ERESTARTSYS;
-			if (signal_pending(current))
+
+			error = locks_block_on(fl, caller);
+			if (error != 0)
 				goto out;
-			locks_insert_block(fl, caller);
-			interruptible_sleep_on(&caller->fl_wait);
-			locks_delete_block(fl, caller);
-			goto repeat;
+
+			fl = inode->i_flock;
   		}
   	}
 
@@ -972,7 +1013,6 @@
 				  !locks_same_owner(caller, fl))) {
 		before = &fl->fl_next;
 	}
-
 	/* Process locks with this owner.
 	 */
 	while ((fl = *before) && locks_same_owner(caller, fl)) {
@@ -992,22 +1032,23 @@
 			 * lock yielding from the lower start address of both
 			 * locks to the higher end address.
 			 */
-			if (fl->fl_start > caller->fl_start)
+			if (fl->fl_start > caller->fl_start) {
 				fl->fl_start = caller->fl_start;
-			else
+			} else {
 				caller->fl_start = fl->fl_start;
-			if (fl->fl_end < caller->fl_end)
+			}
+			if (fl->fl_end < caller->fl_end) {
 				fl->fl_end = caller->fl_end;
-			else
+			} else {
 				caller->fl_end = fl->fl_end;
+			}
 			if (added) {
 				locks_delete_lock(before, 0);
 				continue;
 			}
 			caller = fl;
 			added = 1;
-		}
-		else {
+		} else {
 			/* Processing for different lock types is a bit
 			 * more complex.
 			 */
@@ -1048,9 +1089,8 @@
 				added = 1;
 			}
 		}
-		/* Go on to next lock.
-		 */
-	next_lock:
+		/* Go on to next lock.  */
+next_lock:
 		before = &fl->fl_next;
 	}
 
@@ -1058,7 +1098,7 @@
 	if (!added) {
 		if (caller->fl_type == F_UNLCK)
 			goto out;
-		locks_init_lock(new_fl, caller);
+		locks_copy_lock(new_fl, caller);
 		locks_insert_lock(before, new_fl);
 		new_fl = NULL;
 	}
@@ -1068,7 +1108,7 @@
 			 * so we have to use the second new lock (in this
 			 * case, even F_UNLCK may fail!).
 			 */
-			left = locks_init_lock(new_fl2, right);
+			left = locks_copy_lock(new_fl2, right);
 			locks_insert_lock(before, left);
 			new_fl2 = NULL;
 		}
@@ -1080,106 +1120,211 @@
 		locks_wake_up_blocks(left, 0);
 	}
 out:
-	/*
-	 * Free any unused locks.  (They haven't
-	 * ever been used, so we use kfree().)
-	 */
+	release_fl_sem();
+	/* Free any unused locks. */
 	if (new_fl)
-		kfree(new_fl);
+		locks_free_lock(new_fl);
 	if (new_fl2)
-		kfree(new_fl2);
+		locks_free_lock(new_fl2);
 	return error;
 }
 
 /*
- * Allocate an empty lock structure. We can use GFP_KERNEL now that
- * all allocations are done in advance.
+ * get_lease has checked there _is_ a lease on this 
  */
-static struct file_lock *locks_empty_lock(void)
+int __get_lease(struct inode *inode, unsigned int mode)
 {
-	/* Okay, let's make a new file_lock structure... */
-	return ((struct file_lock *) kmalloc(sizeof(struct file_lock),
-						GFP_KERNEL));
+	int error = 0, future;
+	struct file_lock *new_fl, *flock = inode->i_flock;
+
+	if (flock->fl_owner == current->files)
+		return 0;
+
+	acquire_fl_sem();
+
+	while (flock->fl_type & F_INPROGRESS) {
+		error = interruptible_sleep_on_locked(&flock->fl_wait, &file_lock_sem, 0);
+		if (error != 0)
+			goto out;
+
+		flock = inode->i_flock;
+		if ((flock == NULL) || (flock->fl_flags != FL_LEASE))
+			goto out;
+	}
+
+	if (mode & FMODE_WRITE) {
+		/* If we want write access, we have to revoke any lease. */
+		future = F_UNLCK | F_INPROGRESS;
+	} else if (flock->fl_type & F_WRLCK) {
+		/* Downgrade the exclusive lease to a read-only lease. */
+		future = F_RDLCK | F_INPROGRESS;
+	} else {
+		/* the existing lease was read-only, so we can read too. */
+		goto out;
+	}
+
+	new_fl = flock;
+	do {
+		new_fl->fl_type = future;
+		new_fl = new_fl->fl_next;
+	} while (new_fl->fl_flags & FL_LEASE);
+
+	inode_send_fasync(inode);
+	error = 30 * HZ;
+restart:
+	error = interruptible_sleep_on_locked(&flock->fl_wait, &file_lock_sem, error);
+	if (error < 0)
+		goto out;
+
+	if (error == 0) {
+		/* We timed out.  Unilaterally break the lease. */
+		printk(KERN_DEBUG "lease timed out");
+		locks_delete_lock(&inode->i_flock, 0);
+	} else {
+		flock = inode->i_flock;
+		if (flock->fl_flags & FL_LEASE)
+			goto restart;
+		error = 0;
+	}
+
+out:
+	release_fl_sem();	
+	return error;
 }
 
-/*
- * Initialize a new lock from an existing file_lock structure.
- */
-static struct file_lock *locks_init_lock(struct file_lock *new,
-					 struct file_lock *fl)
+int fcntl_getlease(unsigned int fd)
 {
-	if (new) {
-		memset(new, 0, sizeof(*new));
-		new->fl_owner = fl->fl_owner;
-		new->fl_pid = fl->fl_pid;
-		init_waitqueue_head(&new->fl_wait);
-		new->fl_file = fl->fl_file;
-		new->fl_flags = fl->fl_flags;
-		new->fl_type = fl->fl_type;
-		new->fl_start = fl->fl_start;
-		new->fl_end = fl->fl_end;
-		new->fl_notify = fl->fl_notify;
-		new->fl_insert = fl->fl_insert;
-		new->fl_remove = fl->fl_remove;
-		new->fl_u = fl->fl_u;
+	struct file_lock *fl;
+	struct file *filp;
+	int error;
+	
+	error = -EBADF;
+	filp = fget(fd);
+	if (!filp)
+		goto out;
+
+	fl = filp->f_dentry->d_inode->i_flock;
+	if ((fl == NULL) || ((fl->fl_flags & FL_LEASE) == 0)) {
+		error = F_UNLCK;
+	} else {
+		error = fl->fl_type;
 	}
-	return new;
+out:
+	return error;
 }
 
-/* Insert file lock fl into an inode's lock list at the position indicated
- * by pos. At the same time add the lock to the global file lock list.
- */
-static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl)
+/* We already had a lease on this file; just change its type */
+static int lease_modify(struct file_lock **before, int arg, int fd, struct file *filp)
 {
-	fl->fl_nextlink = file_lock_table;
-	fl->fl_prevlink = NULL;
-	if (file_lock_table != NULL)
-		file_lock_table->fl_prevlink = fl;
-	file_lock_table = fl;
-	fl->fl_next = *pos;	/* insert into file's list */
-	*pos = fl;
+	if (assign_type(*before, arg) != 0)
+		return -EINVAL;
 
-	if (fl->fl_insert)
-		fl->fl_insert(fl);
+	wake_up(&(*before)->fl_wait);
 
-	return;
+	if (arg == F_UNLCK) {
+		locks_delete_lock(before, 0);
+		file_fasync(fd, filp, 0);
+	}
+	return 0;
 }
 
-/* Delete a lock and free it.
- * First remove our lock from the active lock lists. Then call
- * locks_wake_up_blocks() to wake up processes that are blocked
- * waiting for this lock. Finally free the lock structure.
- */
-static void locks_delete_lock(struct file_lock **thisfl_p, unsigned int wait)
+int fcntl_setlease(unsigned int fd, long arg)
 {
-	struct file_lock *thisfl;
-	struct file_lock *prevfl;
-	struct file_lock *nextfl;
-	
-	thisfl = *thisfl_p;
-	*thisfl_p = thisfl->fl_next;
+	struct file_lock *fl, *my_fl, **before;
+	struct file *filp;
+	struct inode *inode;
+	int error, read_allowed = 1, write_allowed = 1;
+
+	error = -EBADF;
+	filp = fget(fd);
+	if (!filp)
+		goto out;
+
+	inode = filp->f_dentry->d_inode;
+	before = &inode->i_flock;
 
-	prevfl = thisfl->fl_prevlink;
-	nextfl = thisfl->fl_nextlink;
+	acquire_fl_sem();
 
-	if (nextfl != NULL)
-		nextfl->fl_prevlink = prevfl;
+	while ((fl = *before) != NULL) {
+		if (fl->fl_flags != FL_LEASE)
+			break;
+		if (fl->fl_owner == current->files)
+			my_fl = fl;
+		write_allowed = 0;
+		if ((fl->fl_type & F_RDLCK) == 0)
+			read_allowed = 0;
+		before = &fl->fl_next;
+	}
 
-	if (prevfl != NULL)
-		prevfl->fl_nextlink = nextfl;
-	else
-		file_lock_table = nextfl;
+	if ((fl != NULL) && (fl->fl_owner == current->files)) {
+		error = lease_modify(before, arg, fd, filp);
+		goto out_unlock;
+	}
 
-	if (thisfl->fl_remove)
-		thisfl->fl_remove(thisfl);
+	fl = lease_alloc(filp, arg);
 	
-	locks_wake_up_blocks(thisfl, wait);
-	locks_free_lock(thisfl);
+	error = -EINVAL;
+	if (fl ==  NULL)
+		goto out_unlock;
+
+	error = -EAGAIN;
+	if ((fl->fl_type == F_RDLCK && read_allowed)
+	  || (fl->fl_type == F_WRLCK && write_allowed))
+		goto out_freelock;
+
+	error = file_fasync(fd, filp, 1);
+	if (error < 0)
+		goto out_freelock;
+
+	fl->fl_next = *before;
+	*before = fl;
+
+out_unlock:
+	release_fl_sem();
+out:
+	return error;
+
+out_freelock:
+	*before = fl->fl_next;
+	locks_free_lock(fl);
+	goto out_unlock;
+}
+
+/* flock() system call entry point. Apply a FL_FLOCK style lock to
+ * an open file descriptor.
+ */
+asmlinkage long sys_flock(unsigned int fd, unsigned int cmd)
+{
+	struct file *filp;
+	int error, type;
+
+	error = -EBADF;
+	filp = fget(fd);
+	if (!filp)
+		goto out;
+
+	error = flock_translate_cmd(cmd);
+	if (error < 0)
+		goto out;
+	type = error;
 
-	return;
+	error = -EBADF;
+	if ((type != F_UNLCK) && !(filp->f_mode & 3))
+		goto out_putf;
+
+	acquire_fl_sem();
+	error = flock_lock_file(filp, type,
+				(cmd & (LOCK_UN | LOCK_NB)) ? 0 : 1);
+	release_fl_sem();
+out_putf:
+	fput(filp);
+out:
+	return error;
 }
 
-static void lock_get_status(char* out, struct file_lock *fl, int id, char *pfx)
+/* Functions to report lock usage in /proc/locks */
+
+static void lock_get_status(char * out, struct file_lock *fl, int id, char *pfx)
 {
 	struct inode *inode;
 
@@ -1192,21 +1337,20 @@
 			     (IS_MANDLOCK(inode) &&
 			      (inode->i_mode & (S_IXGRP | S_ISGID)) == S_ISGID) ?
 			     "MANDATORY" : "ADVISORY ");
-	}
-	else {
+	} else {
 		out += sprintf(out, "FLOCK  ADVISORY  ");
 	}
 	out += sprintf(out, "%s ", (fl->fl_type == F_RDLCK) ? "READ " : "WRITE");
 	out += sprintf(out, "%d %s:%ld %Ld %Ld ",
 		     fl->fl_pid,
 		     kdevname(inode->i_dev), inode->i_ino,
-		     (long long)fl->fl_start, (long long)fl->fl_end);
+		     fl->fl_start, fl->fl_end);
 	sprintf(out, "%08lx %08lx %08lx %08lx %08lx\n",
-		(long)fl, (long)fl->fl_prevlink, (long)fl->fl_nextlink,
-		(long)fl->fl_next, (long)fl->fl_nextblock);
+		(long)fl, (long)fl->fl_link.prev, (long)fl->fl_link.next,
+		(long)fl->fl_next, (long)fl->fl_block.next);
 }
 
-static void move_lock_status(char **p, off_t* pos, off_t offset)
+static void move_lock_status(char **p, off_t *pos, off_t offset)
 {
 	int len;
 	len = strlen(*p);
@@ -1230,35 +1374,65 @@
 
 int get_locks_status(char *buffer, char **start, off_t offset, int length)
 {
-	struct file_lock *fl;
-	struct file_lock *bfl;
+	struct list_head *tmp;
 	char *q = buffer;
 	off_t pos = 0;
-	int i;
+	int i = 0;
 
-	for (fl = file_lock_table, i = 1; fl != NULL; fl = fl->fl_nextlink, i++) {
-		lock_get_status(q, fl, i, "");
+	acquire_fl_sem();
+	tmp = file_lock_list.next;
+	while (tmp != &file_lock_list) {
+		struct file_lock *fl = list_entry(tmp, struct file_lock, fl_link);
+		struct list_head *btmp = fl->fl_block.next;
+
+		lock_get_status(q, fl, ++i, "");
 		move_lock_status(&q, &pos, offset);
 
-		if(pos >= offset+length)
+		if (pos >= offset+length)
 			goto done;
 
-		if ((bfl = fl->fl_nextblock) == NULL)
-			continue;
-		do {
+		while (btmp != &fl->fl_block) {
+			struct file_lock *bfl = list_entry(btmp,
+					struct file_lock, fl_block);
 			lock_get_status(q, bfl, i, " ->");
 			move_lock_status(&q, &pos, offset);
 
 			if(pos >= offset+length)
 				goto done;
-		} while ((bfl = bfl->fl_nextblock) != fl);
+			btmp = btmp->next;
+		}
+		tmp = tmp->next;
 	}
 done:
+	release_fl_sem();
 	*start = buffer;
-	if(q-buffer < length)
+	if (q - buffer < length)
 		return (q-buffer);
 	return length;
 }
 
+/* The following two are for the benefit of lockd.
+ */
+void
+posix_block_lock(struct file_lock *blocker, struct file_lock *waiter)
+{
+	acquire_fl_sem();
+	locks_insert_block(blocker, waiter);
+	release_fl_sem();
+}
 
+void
+posix_unblock_lock(struct file_lock *waiter)
+{
+	acquire_fl_sem();
+	locks_delete_block(waiter);
+	release_fl_sem();
+}
 
+void __init filelock_init(void)
+{
+	filelock_cache = kmem_cache_create("file lock cache",
+			sizeof(struct file_lock), 0, 0, init_once, NULL);
+	if (!filelock_cache)
+		panic("cannot create file lock slab cache");
+}
diff -urNX ../exclude linux-2.3.99pre8-linus/fs/namei.c linux-2.3.99pre8+lock/fs/namei.c
--- linux-2.3.99pre8-linus/fs/namei.c	Mon May 15 07:59:25 2000
+++ linux-2.3.99pre8+lock/fs/namei.c	Sat May 20 04:42:06 2000
@@ -997,6 +1000,11 @@
 			goto exit;
 	}
 
+	/*
+	 * Ensure there are no outstanding leases on the file.
+	 */
+	get_lease(inode, flag);
+
 	if (flag & O_TRUNC) {
 		error = get_write_access(inode);
 		if (error)
diff -urNX ../exclude linux-2.3.99pre8-linus/include/asm-alpha/resource.h linux-2.3.99pre8+lock/include/asm-alpha/resource.h
--- linux-2.3.99pre8-linus/include/asm-alpha/resource.h	Thu Dec  9 16:29:05 1999
+++ linux-2.3.99pre8+lock/include/asm-alpha/resource.h	Mon May 15 08:31:52 2000
@@ -15,8 +15,9 @@
 #define RLIMIT_AS	7		/* address space limit(?) */
 #define RLIMIT_NPROC	8		/* max number of processes */
 #define RLIMIT_MEMLOCK	9		/* max locked-in-memory address space */
+#define RLIMIT_LOCKS	10		/* maximum file locks held */
 
-#define RLIM_NLIMITS	10
+#define RLIM_NLIMITS	11
 
 /*
  * SuS says limits have to be unsigned.  Fine, it's unsigned, but
@@ -39,6 +40,7 @@
     {LONG_MAX, LONG_MAX},			/* RLIMIT_AS */		\
     {LONG_MAX, LONG_MAX},			/* RLIMIT_NPROC */	\
     {LONG_MAX, LONG_MAX},			/* RLIMIT_MEMLOCK */	\
+    {     100, LONG_MAX},			/* RLIMIT_LOCKS */	\
 }
 
 #endif /* __KERNEL__ */
diff -urNX ../exclude linux-2.3.99pre8-linus/include/asm-arm/resource.h linux-2.3.99pre8+lock/include/asm-arm/resource.h
--- linux-2.3.99pre8-linus/include/asm-arm/resource.h	Thu Dec  9 16:29:05 1999
+++ linux-2.3.99pre8+lock/include/asm-arm/resource.h	Mon May 15 08:31:52 2000
@@ -15,8 +15,9 @@
 #define RLIMIT_NOFILE	7		/* max number of open files */
 #define RLIMIT_MEMLOCK	8		/* max locked-in-memory address space */
 #define RLIMIT_AS	9		/* address space limit */
+#define RLIMIT_LOCKS	10		/* maximum file locks held */
 
-#define RLIM_NLIMITS	10
+#define RLIM_NLIMITS	11
 
 /*
  * SuS says limits have to be unsigned.
@@ -38,6 +39,7 @@
 	{ INR_OPEN, INR_OPEN },				\
 	{ LONG_MAX, LONG_MAX },				\
 	{ LONG_MAX, LONG_MAX },				\
+    {     100, LONG_MAX},			/* RLIMIT_LOCKS */	\
 }
 
 #endif /* __KERNEL__ */
diff -urNX ../exclude linux-2.3.99pre8-linus/include/asm-i386/fcntl.h linux-2.3.99pre8+lock/include/asm-i386/fcntl.h
--- linux-2.3.99pre8-linus/include/asm-i386/fcntl.h	Tue Dec 14 03:53:27 1999
+++ linux-2.3.99pre8+lock/include/asm-i386/fcntl.h	Mon May 15 08:31:52 2000
@@ -34,6 +34,9 @@
 #define F_GETOWN	9	/*  for sockets. */
 #define F_SETSIG	10	/*  for sockets. */
 #define F_GETSIG	11	/*  for sockets. */
+#define F_SETLEASE	12
+#define F_GETLEASE	13
+
 
 /* for F_[GET|SET]FL */
 #define FD_CLOEXEC	1	/* actually anything with low bit set goes */
@@ -46,6 +49,9 @@
 /* for old implementation of bsd flock () */
 #define F_EXLCK		4	/* or 3 */
 #define F_SHLCK		8	/* or 4 */
+
+/* for leases */
+#define F_INPROGRESS	16
 
 /* operations for bsd flock(), also used by the kernel implementation */
 #define LOCK_SH		1	/* shared lock */
diff -urNX ../exclude linux-2.3.99pre8-linus/include/asm-i386/resource.h linux-2.3.99pre8+lock/include/asm-i386/resource.h
--- linux-2.3.99pre8-linus/include/asm-i386/resource.h	Thu Dec  9 16:29:05 1999
+++ linux-2.3.99pre8+lock/include/asm-i386/resource.h	Mon May 15 08:31:52 2000
@@ -15,8 +15,9 @@
 #define RLIMIT_NOFILE	7		/* max number of open files */
 #define RLIMIT_MEMLOCK	8		/* max locked-in-memory address space */
 #define RLIMIT_AS	9		/* address space limit */
+#define RLIMIT_LOCKS	10		/* maximum file locks held */
 
-#define RLIM_NLIMITS	10
+#define RLIM_NLIMITS	11
 
 /*
  * SuS says limits have to be unsigned.
@@ -38,6 +39,7 @@
 	{      INR_OPEN,     INR_OPEN  },		\
 	{ RLIM_INFINITY, RLIM_INFINITY },		\
 	{ RLIM_INFINITY, RLIM_INFINITY },		\
+        {           100, RLIM_INFINITY },	/* RLIMIT_LOCKS */	\
 }
 
 #endif /* __KERNEL__ */
diff -urNX ../exclude linux-2.3.99pre8-linus/include/asm-m68k/resource.h linux-2.3.99pre8+lock/include/asm-m68k/resource.h
--- linux-2.3.99pre8-linus/include/asm-m68k/resource.h	Thu Dec  9 16:29:06 1999
+++ linux-2.3.99pre8+lock/include/asm-m68k/resource.h	Mon May 15 08:31:52 2000
@@ -15,8 +15,9 @@
 #define RLIMIT_NOFILE	7		/* max number of open files */
 #define RLIMIT_MEMLOCK	8		/* max locked-in-memory address space*/
 #define RLIMIT_AS	9		/* address space limit */
+#define RLIMIT_LOCKS	10		/* maximum file locks held */
 
-#define RLIM_NLIMITS	10
+#define RLIM_NLIMITS	11
 
 /*
  * SuS says limits have to be unsigned.
@@ -38,6 +39,7 @@
   {INR_OPEN, INR_OPEN}, \
   {LONG_MAX, LONG_MAX}, \
   {LONG_MAX, LONG_MAX}  \
+  {     100, LONG_MAX},			/* RLIMIT_LOCKS */	\
 }
 
 #endif /* __KERNEL__ */
diff -urNX ../exclude linux-2.3.99pre8-linus/include/asm-mips/resource.h linux-2.3.99pre8+lock/include/asm-mips/resource.h
--- linux-2.3.99pre8-linus/include/asm-mips/resource.h	Sun Mar 12 12:03:25 2000
+++ linux-2.3.99pre8+lock/include/asm-mips/resource.h	Mon May 15 08:31:52 2000
@@ -22,8 +22,9 @@
 #define RLIMIT_RSS 7			/* max resident set size */
 #define RLIMIT_NPROC 8			/* max number of processes */
 #define RLIMIT_MEMLOCK 9		/* max locked-in-memory address space */
+#define RLIMIT_LOCKS	10		/* maximum file locks held */
 
-#define RLIM_NLIMITS 10			/* Number of limit flavors.  */
+#define RLIM_NLIMITS 11			/* Number of limit flavors.  */
 
 /*
  * SuS says limits have to be unsigned.
@@ -45,6 +46,7 @@
 	{ RLIM_INFINITY, RLIM_INFINITY },		\
 	{ 0,             0             },		\
 	{ RLIM_INFINITY, RLIM_INFINITY },		\
+	{           100, RLIM_INFINITY },		\
 }
 
 #endif /* __KERNEL__ */
diff -urNX ../exclude linux-2.3.99pre8-linus/include/asm-ppc/resource.h linux-2.3.99pre8+lock/include/asm-ppc/resource.h
--- linux-2.3.99pre8-linus/include/asm-ppc/resource.h	Mon May 15 07:59:26 2000
+++ linux-2.3.99pre8+lock/include/asm-ppc/resource.h	Mon May 15 08:31:52 2000
@@ -11,8 +11,9 @@
 #define RLIMIT_NOFILE	7		/* max number of open files */
 #define RLIMIT_MEMLOCK	8		/* max locked-in-memory address space */
 #define RLIMIT_AS	9		/* address space limit(?) */
+#define RLIMIT_LOCKS	10		/* maximum file locks held */
 
-#define RLIM_NLIMITS	10
+#define RLIM_NLIMITS	11
 
 #ifdef __KERNEL__
 
@@ -35,6 +36,7 @@
 	{      INR_OPEN,     INR_OPEN  },		\
 	{ RLIM_INFINITY, RLIM_INFINITY },		\
 	{ RLIM_INFINITY, RLIM_INFINITY },		\
+	{           100, RLIM_INFINITY},	/* RLIMIT_LOCKS */	\
 }
 
 #endif /* __KERNEL__ */
diff -urNX ../exclude linux-2.3.99pre8-linus/include/asm-sh/resource.h linux-2.3.99pre8+lock/include/asm-sh/resource.h
--- linux-2.3.99pre8-linus/include/asm-sh/resource.h	Sun Mar 12 12:03:33 2000
+++ linux-2.3.99pre8+lock/include/asm-sh/resource.h	Mon May 15 08:31:52 2000
@@ -15,8 +15,9 @@
 #define RLIMIT_NOFILE	7		/* max number of open files */
 #define RLIMIT_MEMLOCK	8		/* max locked-in-memory address space */
 #define RLIMIT_AS	9		/* address space limit */
+#define RLIMIT_LOCKS	10		/* maximum file locks held */
 
-#define RLIM_NLIMITS	10
+#define RLIM_NLIMITS	11
 
 #ifdef __KERNEL__
 
@@ -38,6 +39,7 @@
 	{      INR_OPEN,     INR_OPEN  },		\
 	{ RLIM_INFINITY, RLIM_INFINITY },		\
 	{ RLIM_INFINITY, RLIM_INFINITY },		\
+	{           100, RLIM_INFINITY },	/* RLIMIT_LOCKS */	\
 }
 
 #endif /* __KERNEL__ */
diff -urNX ../exclude linux-2.3.99pre8-linus/include/asm-sparc/resource.h linux-2.3.99pre8+lock/include/asm-sparc/resource.h
--- linux-2.3.99pre8-linus/include/asm-sparc/resource.h	Tue Dec 21 01:05:52 1999
+++ linux-2.3.99pre8+lock/include/asm-sparc/resource.h	Mon May 15 08:31:52 2000
@@ -21,8 +21,9 @@
 #define RLIMIT_NPROC	7		/* max number of processes */
 #define RLIMIT_MEMLOCK  8               /* max locked-in-memory address space */
 #define RLIMIT_AS       9               /* address space limit */
+#define RLIMIT_LOCKS	10		/* maximum file locks held */
 
-#define RLIM_NLIMITS	10
+#define RLIM_NLIMITS	11
 
 /*
  * SuS says limits have to be unsigned.
@@ -43,6 +44,7 @@
     {INR_OPEN, INR_OPEN}, {0, 0},	\
     {RLIM_INFINITY, RLIM_INFINITY},	\
     {RLIM_INFINITY, RLIM_INFINITY}	\
+    {          100, RLIM_INFINITY},	/* RLIMIT_LOCKS */	\
 }
 
 #endif /* __KERNEL__ */
diff -urNX ../exclude linux-2.3.99pre8-linus/include/asm-sparc64/resource.h linux-2.3.99pre8+lock/include/asm-sparc64/resource.h
--- linux-2.3.99pre8-linus/include/asm-sparc64/resource.h	Tue Dec 21 01:05:52 1999
+++ linux-2.3.99pre8+lock/include/asm-sparc64/resource.h	Mon May 15 08:31:52 2000
@@ -21,8 +21,9 @@
 #define RLIMIT_NPROC	7		/* max number of processes */
 #define RLIMIT_MEMLOCK  8               /* max locked-in-memory address space */
 #define RLIMIT_AS       9               /* address space limit */
+#define RLIMIT_LOCKS	10		/* maximum file locks held */
 
-#define RLIM_NLIMITS	10
+#define RLIM_NLIMITS	11
 
 /*
  * SuS says limits have to be unsigned.
@@ -42,6 +43,7 @@
     {INR_OPEN, INR_OPEN}, {0, 0},	\
     {RLIM_INFINITY, RLIM_INFINITY},	\
     {RLIM_INFINITY, RLIM_INFINITY}	\
+    {          100, RLIM_INFINITY},	/* RLIMIT_LOCKS */	\
 }
 
 #endif /* __KERNEL__ */
diff -urNX ../exclude linux-2.3.99pre8-linus/include/linux/fs.h linux-2.3.99pre8+lock/include/linux/fs.h
--- linux-2.3.99pre8-linus/include/linux/fs.h	Mon May 15 07:59:26 2000
+++ linux-2.3.99pre8+lock/include/linux/fs.h	Sat May 20 04:32:48 2000
@@ -187,6 +187,7 @@
 extern void buffer_init(unsigned long);
 extern void inode_init(unsigned long);
 extern void file_table_init(void);
+extern void filelock_init(void);
 extern void dcache_init(unsigned long);
 
 /* bh state bits */
@@ -492,6 +494,7 @@
 #define FL_BROKEN	4	/* broken flock() emulation */
 #define FL_ACCESS	8	/* for processes suspended by mandatory locking */
 #define FL_LOCKD	16	/* lock held by rpc.lockd */
+#define FL_LEASE	32	/* lease held on this file */
 
 /*
  * The POSIX file lock owner is determined by
@@ -503,19 +506,17 @@
 typedef struct files_struct *fl_owner_t;
 
 struct file_lock {
-	struct file_lock *fl_next;	/* singly linked list for this inode  */
-	struct file_lock *fl_nextlink;	/* doubly linked list of all locks */
-	struct file_lock *fl_prevlink;	/* used to simplify lock removal */
-	struct file_lock *fl_nextblock; /* circular list of blocked processes */
-	struct file_lock *fl_prevblock;
-	fl_owner_t fl_owner;
-	unsigned int fl_pid;
-	wait_queue_head_t fl_wait;
-	struct file *fl_file;
-	unsigned char fl_flags;
-	unsigned char fl_type;
-	loff_t fl_start;
-	loff_t fl_end;
+	struct file_lock *	fl_next;  /* Single list for this inode */
+	struct list_head	fl_link;  /* Circular list of all locks */
+	struct list_head	fl_block; /* Circular list of blocked locks */
+	fl_owner_t		fl_owner; /* Thread group for POSIX locks */
+	unsigned int		fl_pid;
+	wait_queue_head_t	fl_wait;  /* Blocked locks wait on this */
+	struct file *		fl_file;  /* File this lock belongs to */
+	unsigned char		fl_flags; /* See above for flag values */
+	unsigned char		fl_type;  /* POSIX or BSD lock */
+	loff_t			fl_start; /* First byte locked */
+	loff_t			fl_end;   /* Last byte locked */
 
 	void (*fl_notify)(struct file_lock *);	/* unblock callback */
 	void (*fl_insert)(struct file_lock *);	/* lock insertion callback */
@@ -532,20 +533,24 @@
 #define OFFSET_MAX	INT_LIMIT(loff_t)
 #endif
 
-extern struct file_lock			*file_lock_table;
-
 #include <linux/fcntl.h>
 
 extern int fcntl_getlk(unsigned int, struct flock *);
 extern int fcntl_setlk(unsigned int, unsigned int, struct flock *);
 
 /* fs/locks.c */
+extern struct semaphore file_lock_sem;
+extern struct list_head file_lock_list;
+
 extern void locks_remove_posix(struct file *, fl_owner_t);
 extern void locks_remove_flock(struct file *);
 extern struct file_lock *posix_test_lock(struct file *, struct file_lock *);
 extern int posix_lock_file(struct file *, struct file_lock *, unsigned int);
 extern void posix_block_lock(struct file_lock *, struct file_lock *);
 extern void posix_unblock_lock(struct file_lock *);
+extern int __get_lease(struct inode *inode, unsigned int flags);
+
+#define FASYNC_MAGIC 0x4601
 
 struct fasync_struct {
 	int	magic;
@@ -554,6 +559,16 @@
 	struct	file 		*fa_file;
 };
 
+extern void __kill_fasync(struct fasync_struct *, int, int);
+extern void kill_fasync(struct fasync_struct **, int, int);
+extern int file_fasync(int, struct file *, int);
+#define inode_send_fasync(inode) \
+	kill_fasync(&inode->i_fasync, SIGIO, POLL_MSG)
+#define tty_send_fasync(fa) \
+	kill_fasync(fa, SIGIO, POLL_IN)
+
+extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
+
 struct nameidata {
 	struct dentry *dentry;
 	struct vfsmount *mnt;
@@ -815,7 +826,7 @@
 #define MANDATORY_LOCK(inode) \
 	(IS_MANDLOCK(inode) && ((inode)->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
 
-static inline int locks_verify_locked(struct inode *inode)
+extern inline int locks_verify_locked(struct inode *inode)
 {
 	if (MANDATORY_LOCK(inode))
 		return locks_mandatory_locked(inode);
@@ -844,6 +855,12 @@
 	return 0;
 }
 
+extern inline int get_lease(struct inode *inode, unsigned int mode)
+{
+	if (inode->i_flock && (inode->i_flock->fl_flags & FL_LEASE))
+		return __get_lease(inode, mode);
+	return 0;
+}
 
 /* fs/open.c */
 
diff -urNX ../exclude linux-2.3.99pre8-linus/include/linux/sched.h linux-2.3.99pre8+lock/include/linux/sched.h
--- linux-2.3.99pre8-linus/include/linux/sched.h	Mon May 15 07:59:26 2000
+++ linux-2.3.99pre8+lock/include/linux/sched.h	Sat May 20 04:34:19 2000
@@ -325,6 +325,7 @@
 /* file system info */
 	int link_count;
 	struct tty_struct *tty; /* NULL if no tty */
+	unsigned int locks; /* How many file locks are being held */
 /* ipc stuff */
 	struct sem_undo *semundo;
 	struct sem_queue *semsleeping;
diff -urNX ../exclude linux-2.3.99pre8-linus/init/main.c linux-2.3.99pre8+lock/init/main.c
--- linux-2.3.99pre8-linus/init/main.c	Mon May 15 07:59:39 2000
+++ linux-2.3.99pre8+lock/init/main.c	Sat May 20 00:56:08 2000
@@ -577,6 +578,8 @@
 	bdev_init();
 	inode_init(mempages);
 	file_table_init();
+	filelock_init();
+	fasync_init();
 #if defined(CONFIG_SYSVIPC)
 	ipc_init();
 #endif
diff -urNX ../exclude linux-2.3.99pre8-linus/kernel/ksyms.c linux-2.3.99pre8+lock/kernel/ksyms.c
--- linux-2.3.99pre8-linus/kernel/ksyms.c	Mon May 15 07:59:26 2000
+++ linux-2.3.99pre8+lock/kernel/ksyms.c	Mon May 15 08:31:53 2000
@@ -210,7 +210,8 @@
 EXPORT_SYMBOL(generic_buffer_fdatasync);
 EXPORT_SYMBOL(page_hash_bits);
 EXPORT_SYMBOL(page_hash_table);
-EXPORT_SYMBOL(file_lock_table);
+EXPORT_SYMBOL(file_lock_list);
+EXPORT_SYMBOL(file_lock_sem);
 EXPORT_SYMBOL(posix_lock_file);
 EXPORT_SYMBOL(posix_test_lock);
 EXPORT_SYMBOL(posix_block_lock);