NLM: Simplify client locks

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

diff --git a/fs/lockd/clntlock.c b/fs/lockd/clntlock.c
index 7cf41c1e1a8812f72b24a4d4b535dc5146621c8f..bce7444687082032394a8f3ff55cba41b0de51eb 100644 (file)
--- 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 c25044f3b660fc65b2f418143ac40a2c92a9f6b2..8af0171058543bb5ada7038e63ef9e1ce558548e 100644 (file)
--- 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);

diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h
index b0f63b6ab0d48202f2d1fb055d6fee13c74d739f..cb9933d040911101ec9428f6d384673953ed575d 100644 (file)
--- a/include/linux/lockd/lockd.h
+++ b/include/linux/lockd/lockd.h
@@ -86,7 +86,6 @@ struct nlm_rqst {
        struct nlm_host *       a_host;         /* host handle */
        struct nlm_args         a_args;         /* arguments */
        struct nlm_res          a_res;          /* result */
-       struct nlm_wait *       a_block;
        unsigned int            a_retries;      /* Retry count */
        char                    a_owner[NLMCLNT_OHSIZE];
 };
@@ -149,9 +148,9 @@ extern unsigned long                nlmsvc_timeout;
  * Lockd client functions
  */
 struct nlm_rqst * nlmclnt_alloc_call(void);
-int              nlmclnt_prepare_block(struct nlm_rqst *req, struct nlm_host *host, struct file_lock *fl);
-void             nlmclnt_finish_block(struct nlm_rqst *req);
-long             nlmclnt_block(struct nlm_rqst *req, long timeout);
+struct nlm_wait * nlmclnt_prepare_block(struct nlm_host *host, struct file_lock *fl);
+void             nlmclnt_finish_block(struct nlm_wait *block);
+int              nlmclnt_block(struct nlm_wait *block, struct nlm_rqst *req, long timeout);
 u32              nlmclnt_grant(const struct sockaddr_in *addr, const struct nlm_lock *);
 void             nlmclnt_recovery(struct nlm_host *, u32);
 int              nlmclnt_reclaim(struct nlm_host *, struct file_lock *);