NLM: Simplify client locks

Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>

2 files changed, 32 insertions, 50 deletions

diff --git a/fs/lockd/clntlock.c b/fs/lockd/clntlock.c
index 7cf41c1e1a88..bce744468708 100644
--- a/fs/lockd/clntlock.c
+++ b/fs/lockd/clntlock.c
@@ -44,32 +44,25 @@ static LIST_HEAD(nlm_blocked);
 /*
  * Queue up a lock for blocking so that the GRANTED request can see it
  */
-int nlmclnt_prepare_block(struct nlm_rqst *req, struct nlm_host *host, struct file_lock *fl)
+struct nlm_wait *nlmclnt_prepare_block(struct nlm_host *host, struct file_lock *fl)
 {
         struct nlm_wait *block;
 
-        BUG_ON(req->a_block != NULL);
         block = kmalloc(sizeof(*block), GFP_KERNEL);
-        if (block == NULL)
-                return -ENOMEM;
-        block->b_host = host;
-        block->b_lock = fl;
-        init_waitqueue_head(&block->b_wait);
-        block->b_status = NLM_LCK_BLOCKED;
-
-        list_add(&block->b_list, &nlm_blocked);
-        req->a_block = block;
-
-        return 0;
+        if (block != NULL) {
+                block->b_host = host;
+                block->b_lock = fl;
+                init_waitqueue_head(&block->b_wait);
+                block->b_status = NLM_LCK_BLOCKED;
+                list_add(&block->b_list, &nlm_blocked);
+        }
+        return block;
 }
 
-void nlmclnt_finish_block(struct nlm_rqst *req)
+void nlmclnt_finish_block(struct nlm_wait *block)
 {
-        struct nlm_wait *block = req->a_block;
-
         if (block == NULL)
                 return;
-        req->a_block = NULL;
         list_del(&block->b_list);
         kfree(block);
 }
@@ -77,15 +70,14 @@ void nlmclnt_finish_block(struct nlm_rqst *req)
 /*
  * Block on a lock
  */
-long nlmclnt_block(struct nlm_rqst *req, long timeout)
+int nlmclnt_block(struct nlm_wait *block, struct nlm_rqst *req, long timeout)
 {
-        struct nlm_wait *block = req->a_block;
         long ret;
 
         /* A borken server might ask us to block even if we didn't
          * request it. Just say no!
          */
-        if (!req->a_args.block)
+        if (block == NULL)
                 return -EAGAIN;
 
         /* Go to sleep waiting for GRANT callback. Some servers seem
@@ -99,13 +91,10 @@ long nlmclnt_block(struct nlm_rqst *req, long timeout)
         ret = wait_event_interruptible_timeout(block->b_wait,
                         block->b_status != NLM_LCK_BLOCKED,
                         timeout);
-
-        if (block->b_status != NLM_LCK_BLOCKED) {
-                req->a_res.status = block->b_status;
-                block->b_status = NLM_LCK_BLOCKED;
-        }
-
-        return ret;
+        if (ret < 0)
+                return -ERESTARTSYS;
+        req->a_res.status = block->b_status;
+        return 0;
 }
 
 /*
diff --git a/fs/lockd/clntproc.c b/fs/lockd/clntproc.c
index c25044f3b660..8af017105854 100644
--- a/fs/lockd/clntproc.c
+++ b/fs/lockd/clntproc.c
@@ -136,15 +136,14 @@ static void nlmclnt_setlockargs(struct nlm_rqst *req, struct file_lock *fl)
                                 (unsigned int)fl->fl_u.nfs_fl.owner->pid,
                                 system_utsname.nodename);
         lock->svid = fl->fl_u.nfs_fl.owner->pid;
-        locks_copy_lock(&lock->fl, fl);
+        lock->fl.fl_start = fl->fl_start;
+        lock->fl.fl_end = fl->fl_end;
+        lock->fl.fl_type = fl->fl_type;
 }
 
 static void nlmclnt_release_lockargs(struct nlm_rqst *req)
 {
-        struct file_lock *fl = &req->a_args.lock.fl;
-
-        if (fl->fl_ops && fl->fl_ops->fl_release_private)
-                fl->fl_ops->fl_release_private(fl);
+        BUG_ON(req->a_args.lock.fl.fl_ops != NULL);
 }
 
 /*
@@ -455,7 +454,6 @@ static void nlmclnt_locks_release_private(struct file_lock *fl)
 {
         list_del(&fl->fl_u.nfs_fl.list);
         nlm_put_lockowner(fl->fl_u.nfs_fl.owner);
-        fl->fl_ops = NULL;
 }
 
 static struct file_lock_operations nlmclnt_lock_ops = {
@@ -515,41 +513,36 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl)
 {
         struct nlm_host *host = req->a_host;
         struct nlm_res  *resp = &req->a_res;
-        long timeout;
-        int status;
+        struct nlm_wait *block = NULL;
+        int status = -ENOLCK;
 
         if (!host->h_monitored && nsm_monitor(host) < 0) {
                 printk(KERN_NOTICE "lockd: failed to monitor %s\n",
                                         host->h_name);
-                status = -ENOLCK;
                 goto out;
         }
 
-        if (req->a_args.block) {
-                status = nlmclnt_prepare_block(req, host, fl);
-                if (status < 0)
-                        goto out;
-        }
+        block = nlmclnt_prepare_block(host, fl);
         for(;;) {
                 status = nlmclnt_call(req, NLMPROC_LOCK);
                 if (status < 0)
                         goto out_unblock;
-                if (resp->status != NLM_LCK_BLOCKED)
+                if (!req->a_args.block)
                         break;
-                /* Wait on an NLM blocking lock */
-                timeout = nlmclnt_block(req, NLMCLNT_POLL_TIMEOUT);
                 /* Did a reclaimer thread notify us of a server reboot? */
                 if (resp->status ==  NLM_LCK_DENIED_GRACE_PERIOD)
                         continue;
                 if (resp->status != NLM_LCK_BLOCKED)
                         break;
-                if (timeout >= 0)
-                        continue;
-                /* We were interrupted. Send a CANCEL request to the server
+                /* Wait on an NLM blocking lock */
+                status = nlmclnt_block(block, req, NLMCLNT_POLL_TIMEOUT);
+                /* if we were interrupted. Send a CANCEL request to the server
                  * and exit
                  */
-                status = (int)timeout;
-                goto out_unblock;
+                if (status < 0)
+                        goto out_unblock;
+                if (resp->status != NLM_LCK_BLOCKED)
+                        break;
         }
 
         if (resp->status == NLM_LCK_GRANTED) {
@@ -560,7 +553,7 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl)
         }
         status = nlm_stat_to_errno(resp->status);
 out_unblock:
-        nlmclnt_finish_block(req);
+        nlmclnt_finish_block(block);
         /* Cancel the blocked request if it is still pending */
         if (resp->status == NLM_LCK_BLOCKED)
                 nlmclnt_cancel(host, req->a_args.block, fl);