diff -urNX dontdiff linux-2.4.2/fs/lockd/svclock.c linux-willy/fs/lockd/svclock.c
--- linux-2.4.2/fs/lockd/svclock.c      Tue Nov  7 11:18:57 2000
+++ linux-willy/fs/lockd/svclock.c      Fri Mar  2 00:21:00 2001
@@ -237,7 +237,7 @@
       if (unlock && block->b_granted) {
               dprintk("lockd: deleting granted lock\n");
               fl->fl_type = F_UNLCK;
-               posix_lock_file(&block->b_file->f_file, fl, 0);
+               posix_lock_file(&block->b_file->f_file, fl, F_GETLK);
               block->b_granted = 0;
       } else {
               dprintk("lockd: unblocking blocked lock\n");
@@ -319,7 +319,7 @@

again:
       if (!(conflock = posix_test_lock(&file->f_file, &lock->fl))) {
-               error = posix_lock_file(&file->f_file, &lock->fl, 0);
+               error = posix_lock_file(&file->f_file, &lock->fl, F_GETLK);

               if (block)
                       nlmsvc_delete_block(block, 0);
@@ -343,32 +343,39 @@
               }
       }

-       if (!wait) {
-               up(&file->f_sema);
-               return nlm_lck_denied;
-       }
+       error = nlm_lck_denied;
+
+       if (!wait)
+               goto out;

       /* If we don't have a block, create and initialize it. Then
        * retry because we may have slept in kmalloc. */
       if (block == NULL) {
               dprintk("lockd: blocking on this lock (allocating).\n");
-               if (!(block = nlmsvc_create_block(rqstp, file, lock, cookie)))
-                       return nlm_lck_denied_nolocks;
-               goto again;
+               error = nlm_lck_denied_nolocks;
+               block = nlmsvc_create_block(rqstp, file, lock, cookie);
+               if (block)
+                       goto again;
+               goto out;
       }

       /* Append to list of blocked */
       nlmsvc_insert_block(block, NLM_NEVER);

+       error = nlm_lck_blocked;
+
       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");
-               posix_block_lock(conflock, &block->b_call.a_args.lock.fl);
+               if (posix_block_lock(conflock, &block->b_call.a_args.lock.fl))
+                       error = nlm_lck_denied;
       }

+ out:
+
       up(&file->f_sema);
-       return nlm_lck_blocked;
+       return error;
}

/*
@@ -423,7 +430,7 @@
       nlmsvc_cancel_blocked(file, lock);

       lock->fl.fl_type = F_UNLCK;
-       error = posix_lock_file(&file->f_file, &lock->fl, 0);
+       error = posix_lock_file(&file->f_file, &lock->fl, F_GETLK);

       return (error < 0)? nlm_lck_denied_nolocks : nlm_granted;
}
@@ -528,7 +535,7 @@
        * following yields an error, this is most probably due to low
        * memory. Retry the lock in a few seconds.
        */
-       if ((error = posix_lock_file(&file->f_file, &lock->fl, 0)) < 0) {
+       if ((error = posix_lock_file(&file->f_file, &lock->fl, F_GETLK)) < 0) {
               printk(KERN_WARNING "lockd: unexpected error %d in %s!\n",
                               -error, __FUNCTION__);
               nlmsvc_insert_block(block, 10 * HZ);
diff -urNX dontdiff linux-2.4.2/fs/lockd/svcsubs.c linux-willy/fs/lockd/svcsubs.c
--- linux-2.4.2/fs/lockd/svcsubs.c      Fri Jun 23 22:12:53 2000
+++ linux-willy/fs/lockd/svcsubs.c      Fri Mar  2 00:20:25 2001
@@ -176,7 +176,7 @@
                       lock.fl_type  = F_UNLCK;
                       lock.fl_start = 0;
                       lock.fl_end   = OFFSET_MAX;
-                       if (posix_lock_file(&file->f_file, &lock, 0) < 0) {
+                       if (posix_lock_file(&file->f_file, &lock, F_GETLK) < 0) {
                               printk("lockd: unlock failure in %s:%d\n",
                                               __FILE__, __LINE__);
                               return 1;
diff -urNX dontdiff linux-2.4.2/fs/locks.c linux-willy/fs/locks.c
--- linux-2.4.2/fs/locks.c      Fri Feb  9 12:29:44 2001
+++ linux-willy/fs/locks.c      Fri Mar  2 00:30:48 2001
@@ -618,6 +618,21 @@
{
       struct file_lock *cfl;

+       if (filp->f_op && filp->f_op->lock) {
+               int error = filp->f_op->lock(filp, F_GETLK, fl);
+               if (error < 0) {
+                       return ERR_PTR(error);
+               } else if (error == LOCK_USE_CLNT) {
+                       /* NFS with no locking - 2.0 compatibility.  Drop
+                        * out and use client-side locking instead.
+                        */
+               } else if (fl->fl_type == F_UNLCK) {
+                       return NULL;
+               } else {
+                       return fl;
+               }
+       }
+
       lock_kernel();
       for (cfl = filp->f_dentry->d_inode->i_flock; cfl; cfl = cfl->fl_next) {
               if (!(cfl->fl_flags & FL_POSIX))
@@ -627,7 +642,7 @@
       }
       unlock_kernel();

-       return (cfl);
+       return cfl;
}

/* This function tests for deadlock condition before putting a process to
@@ -839,7 +854,7 @@
 */

int posix_lock_file(struct file *filp, struct file_lock *caller,
-                          unsigned int wait)
+                          unsigned int cmd)
{
       struct file_lock *fl;
       struct file_lock *new_fl, *new_fl2;
@@ -848,6 +863,7 @@
       struct file_lock **before;
       struct inode * inode = filp->f_dentry->d_inode;
       int error, added = 0;
+       int wait = (cmd == F_SETLKW) || (cmd == F_SETLKW64);

       /*
        * We may need two file_lock structures for this operation,
@@ -859,6 +875,13 @@
       if (!(new_fl && new_fl2))
               goto out;

+       /* Check the underlying filesystem will allow us to lock */
+       if (filp->f_op && filp->f_op->lock != NULL) {
+               error = filp->f_op->lock(filp, cmd, caller);
+               if (error < 0)
+                       goto out;
+       }
+
       lock_kernel();
       if (caller->fl_type != F_UNLCK) {
  repeat:
@@ -1356,17 +1379,10 @@
       if (!flock_to_posix_lock(filp, &file_lock, &flock))
               goto out_putf;

-       if (filp->f_op && filp->f_op->lock) {
-               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);
-       } else {
-               fl = posix_test_lock(filp, &file_lock);
+       fl = posix_test_lock(filp, &file_lock);
+       if (IS_ERR(fl)) {
+               error = PTR_ERR(fl);
+               goto out_putf;
       }

       flock.l_type = F_UNLCK;
@@ -1480,12 +1496,7 @@
               goto out_putf;
       }

-       if (filp->f_op && filp->f_op->lock != NULL) {
-               error = filp->f_op->lock(filp, cmd, file_lock);
-               if (error < 0)
-                       goto out_putf;
-       }
-       error = posix_lock_file(filp, file_lock, cmd == F_SETLKW);
+       error = posix_lock_file(filp, file_lock, cmd);

out_putf:
       fput(filp);
@@ -1521,17 +1532,10 @@
       if (!flock64_to_posix_lock(filp, &file_lock, &flock))
               goto out_putf;

-       if (filp->f_op && filp->f_op->lock) {
-               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);
-       } else {
-               fl = posix_test_lock(filp, &file_lock);
+       fl = posix_test_lock(filp, &file_lock);
+       if (IS_ERR(fl)) {
+               error = PTR_ERR(fl);
+               goto out_putf;
       }

       flock.l_type = F_UNLCK;
@@ -1618,12 +1622,7 @@
               goto out_putf;
       }

-       if (filp->f_op && filp->f_op->lock != NULL) {
-               error = filp->f_op->lock(filp, cmd, file_lock);
-               if (error < 0)
-                       goto out_putf;
-       }
-       error = posix_lock_file(filp, file_lock, cmd == F_SETLKW64);
+       error = posix_lock_file(filp, file_lock, cmd);

out_putf:
       fput(filp);
@@ -1695,15 +1694,21 @@

/**
 *     posix_block_lock - blocks waiting for a file lock
- *     @blocker: the lock which is blocking
- *     @waiter: the lock which conflicts and has to wait
+ *     @blocker: the existing lock which has been granted
+ *     @waiter: the new lock which must sleep
 *
- * lockd needs to block waiting for locks.
+ * This routine is for the use of lockd alone.  It allows lockd to block
+ * waiting for locks by putting the lock in the list of blocking locks
+ * without actually going to sleep itself.
 */
-void
+int
posix_block_lock(struct file_lock *blocker, struct file_lock *waiter)
{
-       locks_insert_block(blocker, waiter);
+       int error;
+       error = posix_locks_deadlock(waiter, blocker);
+       if (!error)
+               locks_insert_block(blocker, waiter);
+       return error;
}

/**
diff -urNX dontdiff linux-2.4.2/include/linux/fs.h linux-willy/include/linux/fs.h
--- linux-2.4.2/include/linux/fs.h      Wed Feb 21 17:09:58 2001
+++ linux-willy/include/linux/fs.h      Thu Mar  1 23:57:06 2001
@@ -568,7 +568,7 @@
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 int 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);
extern time_t lease_get_mtime(struct inode *);

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.