1 files changed, 93 insertions, 114 deletions

diff --git a/fs/lockd/svclock.c b/fs/lockd/svclock.c
index 93c00ee7189d..7e219b938552 100644
--- a/fs/lockd/svclock.c
+++ b/fs/lockd/svclock.c
@@ -40,7 +40,7 @@
 
 static void nlmsvc_release_block(struct nlm_block *block);
 static void     nlmsvc_insert_block(struct nlm_block *block, unsigned long);
-static int      nlmsvc_remove_block(struct nlm_block *block);
+static void     nlmsvc_remove_block(struct nlm_block *block);
 
 static int nlmsvc_setgrantargs(struct nlm_rqst *call, struct nlm_lock *lock);
 static void nlmsvc_freegrantargs(struct nlm_rqst *call);
@@ -49,7 +49,7 @@ static const struct rpc_call_ops nlmsvc_grant_ops;
 /*
  * The list of blocked locks to retry
  */
-static struct nlm_block *       nlm_blocked;
+static LIST_HEAD(nlm_blocked);
 
 /*
  * Insert a blocked lock into the global list
@@ -57,48 +57,44 @@ static struct nlm_block *	nlm_blocked;
 static void
 nlmsvc_insert_block(struct nlm_block *block, unsigned long when)
 {
-        struct nlm_block **bp, *b;
+        struct nlm_block *b;
+        struct list_head *pos;
 
         dprintk("lockd: nlmsvc_insert_block(%p, %ld)\n", block, when);
-        kref_get(&block->b_count);
-        if (block->b_queued)
-                nlmsvc_remove_block(block);
-        bp = &nlm_blocked;
+        if (list_empty(&block->b_list)) {
+                kref_get(&block->b_count);
+        } else {
+                list_del_init(&block->b_list);
+        }
+
+        pos = &nlm_blocked;
         if (when != NLM_NEVER) {
                 if ((when += jiffies) == NLM_NEVER)
                         when ++;
-                while ((b = *bp) && time_before_eq(b->b_when,when) && b->b_when != NLM_NEVER)
-                        bp = &b->b_next;
-        } else
-                while ((b = *bp) != 0)
-                        bp = &b->b_next;
+                list_for_each(pos, &nlm_blocked) {
+                        b = list_entry(pos, struct nlm_block, b_list);
+                        if (time_after(b->b_when,when) || b->b_when == NLM_NEVER)
+                                break;
+                }
+                /* On normal exit from the loop, pos == &nlm_blocked,
+                 * so we will be adding to the end of the list - good
+                 */
+        }
 
-        block->b_queued = 1;
+        list_add_tail(&block->b_list, pos);
         block->b_when = when;
-        block->b_next = b;
-        *bp = block;
 }
 
 /*
  * Remove a block from the global list
  */
-static int
+static inline void
 nlmsvc_remove_block(struct nlm_block *block)
 {
-        struct nlm_block **bp, *b;
-
-        if (!block->b_queued)
-                return 1;
-        for (bp = &nlm_blocked; (b = *bp) != 0; bp = &b->b_next) {
-                if (b == block) {
-                        *bp = block->b_next;
-                        block->b_queued = 0;
-                        nlmsvc_release_block(block);
-                        return 1;
-                }
+        if (!list_empty(&block->b_list)) {
+                list_del_init(&block->b_list);
+                nlmsvc_release_block(block);
         }
-
-        return 0;
 }
 
 /*
@@ -107,14 +103,14 @@ nlmsvc_remove_block(struct nlm_block *block)
 static struct nlm_block *
 nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock)
 {
-        struct nlm_block        **head, *block;
+        struct nlm_block        *block;
         struct file_lock        *fl;
 
         dprintk("lockd: nlmsvc_lookup_block f=%p pd=%d %Ld-%Ld ty=%d\n",
                                 file, lock->fl.fl_pid,
                                 (long long)lock->fl.fl_start,
                                 (long long)lock->fl.fl_end, lock->fl.fl_type);
-        for (head = &nlm_blocked; (block = *head) != 0; head = &block->b_next) {
+        list_for_each_entry(block, &nlm_blocked, b_list) {
                 fl = &block->b_call->a_args.lock.fl;
                 dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%s\n",
                                 block->b_file, fl->fl_pid,
@@ -143,20 +139,20 @@ static inline int nlm_cookie_match(struct nlm_cookie *a, struct nlm_cookie *b)
  * Find a block with a given NLM cookie.
  */
 static inline struct nlm_block *
-nlmsvc_find_block(struct nlm_cookie *cookie,  struct sockaddr_in *sin)
+nlmsvc_find_block(struct nlm_cookie *cookie)
 {
         struct nlm_block *block;
 
-        for (block = nlm_blocked; block; block = block->b_next) {
-                dprintk("cookie: head of blocked queue %p, block %p\n", 
-                        nlm_blocked, block);
-                if (nlm_cookie_match(&block->b_call->a_args.cookie,cookie)
-                                && nlm_cmp_addr(sin, &block->b_host->h_addr))
-                        break;
+        list_for_each_entry(block, &nlm_blocked, b_list) {
+                if (nlm_cookie_match(&block->b_call->a_args.cookie,cookie))
+                        goto found;
         }
 
-        if (block != NULL)
-                kref_get(&block->b_count);
+        return NULL;
+
+found:
+        dprintk("nlmsvc_find_block(%s): block=%p\n", nlmdbg_cookie2a(cookie), block);
+        kref_get(&block->b_count);
         return block;
 }
 
@@ -169,6 +165,11 @@ nlmsvc_find_block(struct nlm_cookie *cookie,  struct sockaddr_in *sin)
  * request, but (as I found out later) that's because some implementations
  * do just this. Never mind the standards comittees, they support our
  * logging industries.
+ *
+ * 10 years later: I hope we can safely ignore these old and broken
+ * clients by now. Let's fix this so we can uniquely identify an incoming
+ * GRANTED_RES message by cookie, without having to rely on the client's IP
+ * address. --okir
  */
 static inline struct nlm_block *
 nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_file *file,
@@ -179,7 +180,7 @@ nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_file *file,
         struct nlm_rqst         *call = NULL;
 
         /* Create host handle for callback */
-        host = nlmsvc_lookup_host(rqstp);
+        host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len);
         if (host == NULL)
                 return NULL;
 
@@ -192,6 +193,8 @@ nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_file *file,
         if (block == NULL)
                 goto failed;
         kref_init(&block->b_count);
+        INIT_LIST_HEAD(&block->b_list);
+        INIT_LIST_HEAD(&block->b_flist);
 
         if (!nlmsvc_setgrantargs(call, lock))
                 goto failed_free;
@@ -199,7 +202,7 @@ nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_file *file,
         /* Set notifier function for VFS, and init args */
         call->a_args.lock.fl.fl_flags |= FL_SLEEP;
         call->a_args.lock.fl.fl_lmops = &nlmsvc_lock_operations;
-        call->a_args.cookie = *cookie;  /* see above */
+        nlmclnt_next_cookie(&call->a_args.cookie);
 
         dprintk("lockd: created block %p...\n", block);
 
@@ -210,8 +213,7 @@ nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_file *file,
         file->f_count++;
 
         /* Add to file's list of blocks */
-        block->b_fnext  = file->f_blocks;
-        file->f_blocks  = block;
+        list_add(&block->b_flist, &file->f_blocks);
 
         /* Set up RPC arguments for callback */
         block->b_call = call;
@@ -248,19 +250,13 @@ static void nlmsvc_free_block(struct kref *kref)
 {
         struct nlm_block *block = container_of(kref, struct nlm_block, b_count);
         struct nlm_file         *file = block->b_file;
-        struct nlm_block        **bp;
 
         dprintk("lockd: freeing block %p...\n", block);
 
-        down(&file->f_sema);
         /* Remove block from file's list of blocks */
-        for (bp = &file->f_blocks; *bp; bp = &(*bp)->b_fnext) {
-                if (*bp == block) {
-                        *bp = block->b_fnext;
-                        break;
-                }
-        }
-        up(&file->f_sema);
+        mutex_lock(&file->f_mutex);
+        list_del_init(&block->b_flist);
+        mutex_unlock(&file->f_mutex);
 
         nlmsvc_freegrantargs(block->b_call);
         nlm_release_call(block->b_call);
@@ -274,47 +270,32 @@ static void nlmsvc_release_block(struct nlm_block *block)
                 kref_put(&block->b_count, nlmsvc_free_block);
 }
 
-static void nlmsvc_act_mark(struct nlm_host *host, struct nlm_file *file)
-{
-        struct nlm_block *block;
-
-        down(&file->f_sema);
-        for (block = file->f_blocks; block != NULL; block = block->b_fnext)
-                block->b_host->h_inuse = 1;
-        up(&file->f_sema);
-}
-
-static void nlmsvc_act_unlock(struct nlm_host *host, struct nlm_file *file)
+/*
+ * Loop over all blocks and delete blocks held by
+ * a matching host.
+ */
+void nlmsvc_traverse_blocks(struct nlm_host *host,
+                        struct nlm_file *file,
+                        nlm_host_match_fn_t match)
 {
-        struct nlm_block *block;
+        struct nlm_block *block, *next;
 
 restart:
-        down(&file->f_sema);
-        for (block = file->f_blocks; block != NULL; block = block->b_fnext) {
-                if (host != NULL && host != block->b_host)
+        mutex_lock(&file->f_mutex);
+        list_for_each_entry_safe(block, next, &file->f_blocks, b_flist) {
+                if (!match(block->b_host, host))
                         continue;
-                if (!block->b_queued)
+                /* Do not destroy blocks that are not on
+                 * the global retry list - why? */
+                if (list_empty(&block->b_list))
                         continue;
                 kref_get(&block->b_count);
-                up(&file->f_sema);
+                mutex_unlock(&file->f_mutex);
                 nlmsvc_unlink_block(block);
                 nlmsvc_release_block(block);
                 goto restart;
         }
-        up(&file->f_sema);
-}
-
-/*
- * Loop over all blocks and perform the action specified.
- * (NLM_ACT_CHECK handled by nlmsvc_inspect_file).
- */
-void
-nlmsvc_traverse_blocks(struct nlm_host *host, struct nlm_file *file, int action)
-{
-        if (action == NLM_ACT_MARK)
-                nlmsvc_act_mark(host, file);
-        else
-                nlmsvc_act_unlock(host, file);
+        mutex_unlock(&file->f_mutex);
 }
 
 /*
@@ -353,13 +334,13 @@ static void nlmsvc_freegrantargs(struct nlm_rqst *call)
  * Attempt to establish a lock, and if it can't be granted, block it
  * if required.
  */
-u32
+__be32
 nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
                         struct nlm_lock *lock, int wait, struct nlm_cookie *cookie)
 {
         struct nlm_block        *block, *newblock = NULL;
         int                     error;
-        u32                     ret;
+        __be32                  ret;
 
         dprintk("lockd: nlmsvc_lock(%s/%ld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
                                 file->f_file->f_dentry->d_inode->i_sb->s_id,
@@ -373,7 +354,7 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
         lock->fl.fl_flags &= ~FL_SLEEP;
 again:
         /* Lock file against concurrent access */
-        down(&file->f_sema);
+        mutex_lock(&file->f_mutex);
         /* Get existing block (in case client is busy-waiting) */
         block = nlmsvc_lookup_block(file, lock);
         if (block == NULL) {
@@ -411,10 +392,10 @@ again:
 
         /* If we don't have a block, create and initialize it. Then
          * retry because we may have slept in kmalloc. */
-        /* We have to release f_sema as nlmsvc_create_block may try to
+        /* We have to release f_mutex as nlmsvc_create_block may try to
          * to claim it while doing host garbage collection */
         if (newblock == NULL) {
-                up(&file->f_sema);
+                mutex_unlock(&file->f_mutex);
                 dprintk("lockd: blocking on this lock (allocating).\n");
                 if (!(newblock = nlmsvc_create_block(rqstp, file, lock, cookie)))
                         return nlm_lck_denied_nolocks;
@@ -424,7 +405,7 @@ again:
         /* Append to list of blocked */
         nlmsvc_insert_block(newblock, NLM_NEVER);
 out:
-        up(&file->f_sema);
+        mutex_unlock(&file->f_mutex);
         nlmsvc_release_block(newblock);
         nlmsvc_release_block(block);
         dprintk("lockd: nlmsvc_lock returned %u\n", ret);
@@ -434,7 +415,7 @@ out:
 /*
  * Test for presence of a conflicting lock.
  */
-u32
+__be32
 nlmsvc_testlock(struct nlm_file *file, struct nlm_lock *lock,
                                        struct nlm_lock *conflock)
 {
@@ -451,6 +432,7 @@ nlmsvc_testlock(struct nlm_file *file, struct nlm_lock *lock,
                                 (long long)conflock->fl.fl_start,
                                 (long long)conflock->fl.fl_end);
                 conflock->caller = "somehost";  /* FIXME */
+                conflock->len = strlen(conflock->caller);
                 conflock->oh.len = 0;           /* don't return OH info */
                 conflock->svid = conflock->fl.fl_pid;
                 return nlm_lck_denied;
@@ -466,7 +448,7 @@ nlmsvc_testlock(struct nlm_file *file, struct nlm_lock *lock,
  * afterwards. In this case the block will still be there, and hence
  * must be removed.
  */
-u32
+__be32
 nlmsvc_unlock(struct nlm_file *file, struct nlm_lock *lock)
 {
         int     error;
@@ -494,7 +476,7 @@ nlmsvc_unlock(struct nlm_file *file, struct nlm_lock *lock)
  * be in progress.
  * The calling procedure must check whether the file can be closed.
  */
-u32
+__be32
 nlmsvc_cancel_blocked(struct nlm_file *file, struct nlm_lock *lock)
 {
         struct nlm_block        *block;
@@ -507,9 +489,9 @@ nlmsvc_cancel_blocked(struct nlm_file *file, struct nlm_lock *lock)
                                 (long long)lock->fl.fl_start,
                                 (long long)lock->fl.fl_end);
 
-        down(&file->f_sema);
+        mutex_lock(&file->f_mutex);
         block = nlmsvc_lookup_block(file, lock);
-        up(&file->f_sema);
+        mutex_unlock(&file->f_mutex);
         if (block != NULL) {
                 status = nlmsvc_unlink_block(block);
                 nlmsvc_release_block(block);
@@ -527,10 +509,10 @@ nlmsvc_cancel_blocked(struct nlm_file *file, struct nlm_lock *lock)
 static void
 nlmsvc_notify_blocked(struct file_lock *fl)
 {
-        struct nlm_block        **bp, *block;
+        struct nlm_block        *block;
 
         dprintk("lockd: VFS unblock notification for block %p\n", fl);
-        for (bp = &nlm_blocked; (block = *bp) != 0; bp = &block->b_next) {
+        list_for_each_entry(block, &nlm_blocked, b_list) {
                 if (nlm_compare_locks(&block->b_call->a_args.lock.fl, fl)) {
                         nlmsvc_insert_block(block, 0);
                         svc_wake_up(block->b_daemon);
@@ -663,17 +645,14 @@ static const struct rpc_call_ops nlmsvc_grant_ops = {
  * block.
  */
 void
-nlmsvc_grant_reply(struct svc_rqst *rqstp, struct nlm_cookie *cookie, u32 status)
+nlmsvc_grant_reply(struct nlm_cookie *cookie, u32 status)
 {
         struct nlm_block        *block;
-        struct nlm_file         *file;
 
-        dprintk("grant_reply: looking for cookie %x, host (%08x), s=%d \n", 
-                *(unsigned int *)(cookie->data), 
-                ntohl(rqstp->rq_addr.sin_addr.s_addr), status);
-        if (!(block = nlmsvc_find_block(cookie, &rqstp->rq_addr)))
+        dprintk("grant_reply: looking for cookie %x, s=%d \n",
+                *(unsigned int *)(cookie->data), status);
+        if (!(block = nlmsvc_find_block(cookie)))
                 return;
-        file = block->b_file;
 
         if (block) {
                 if (status == NLM_LCK_DENIED_GRACE_PERIOD) {
@@ -696,16 +675,19 @@ nlmsvc_grant_reply(struct svc_rqst *rqstp, struct nlm_cookie *cookie, u32 status
 unsigned long
 nlmsvc_retry_blocked(void)
 {
-        struct nlm_block        *block;
+        unsigned long   timeout = MAX_SCHEDULE_TIMEOUT;
+        struct nlm_block *block;
+
+        while (!list_empty(&nlm_blocked)) {
+                block = list_entry(nlm_blocked.next, struct nlm_block, b_list);
 
-        dprintk("nlmsvc_retry_blocked(%p, when=%ld)\n",
-                        nlm_blocked,
-                        nlm_blocked? nlm_blocked->b_when : 0);
-        while ((block = nlm_blocked) != 0) {
                 if (block->b_when == NLM_NEVER)
                         break;
-                if (time_after(block->b_when,jiffies))
+                if (time_after(block->b_when,jiffies)) {
+                        timeout = block->b_when - jiffies;
                         break;
+                }
+
                 dprintk("nlmsvc_retry_blocked(%p, when=%ld)\n",
                         block, block->b_when);
                 kref_get(&block->b_count);
@@ -713,8 +695,5 @@ nlmsvc_retry_blocked(void)
                 nlmsvc_release_block(block);
         }
 
-        if ((block = nlm_blocked) && block->b_when != NLM_NEVER)
-                return (block->b_when - jiffies);
-
-        return MAX_SCHEDULE_TIMEOUT;
+        return timeout;
 }