Merge branch 'for-linus' of git://one.firstfloor.org/home/andi/git/linux-2.6

[sfrench/cifs-2.6.git] / fs / lockd / clntproc.c

diff --git a/fs/lockd/clntproc.c b/fs/lockd/clntproc.c
index 497c3cd59d527c64055c21579930c7ec43fcfcd5..a5c019e1a44762bb63601accb17bb6b7a2671552 100644 (file)
--- a/fs/lockd/clntproc.c
+++ b/fs/lockd/clntproc.c
@@ -27,7 +27,7 @@
 static int     nlmclnt_test(struct nlm_rqst *, struct file_lock *);
 static int     nlmclnt_lock(struct nlm_rqst *, struct file_lock *);
 static int     nlmclnt_unlock(struct nlm_rqst *, struct file_lock *);
-static int     nlm_stat_to_errno(u32 stat);
+static int     nlm_stat_to_errno(__be32 stat);
 static void    nlmclnt_locks_init_private(struct file_lock *fl, struct nlm_host *host);
 static int     nlmclnt_cancel(struct nlm_host *, int , struct file_lock *);
 
@@ -129,7 +129,7 @@ static void nlmclnt_setlockargs(struct nlm_rqst *req, struct file_lock *fl)
 
        nlmclnt_next_cookie(&argp->cookie);
        argp->state   = nsm_local_state;
-       memcpy(&lock->fh, NFS_FH(fl->fl_file->f_dentry->d_inode), sizeof(struct nfs_fh));
+       memcpy(&lock->fh, NFS_FH(fl->fl_file->f_path.dentry->d_inode), sizeof(struct nfs_fh));
        lock->caller  = utsname()->nodename;
        lock->oh.data = req->a_owner;
        lock->oh.len  = snprintf(req->a_owner, sizeof(req->a_owner), "%u@%s",
@@ -325,7 +325,7 @@ nlmclnt_call(struct nlm_rqst *req, u32 proc)
                        }
                        break;
                } else
-               if (resp->status == NLM_LCK_DENIED_GRACE_PERIOD) {
+               if (resp->status == nlm_lck_denied_grace_period) {
                        dprintk("lockd: server in grace period\n");
                        if (argp->reclaim) {
                                printk(KERN_WARNING
@@ -361,7 +361,6 @@ static int __nlm_async_call(struct nlm_rqst *req, u32 proc, struct rpc_message *
 {
        struct nlm_host *host = req->a_host;
        struct rpc_clnt *clnt;
-       int status = -ENOLCK;
 
        dprintk("lockd: call procedure %d on %s (async)\n",
                        (int)proc, host->h_name);
@@ -373,12 +372,10 @@ static int __nlm_async_call(struct nlm_rqst *req, u32 proc, struct rpc_message *
        msg->rpc_proc = &clnt->cl_procinfo[proc];
 
         /* bootstrap and kick off the async RPC call */
-        status = rpc_call_async(clnt, msg, RPC_TASK_ASYNC, tk_ops, req);
-       if (status == 0)
-               return 0;
+        return rpc_call_async(clnt, msg, RPC_TASK_ASYNC, tk_ops, req);
 out_err:
-       nlm_release_call(req);
-       return status;
+       tk_ops->rpc_release(req);
+       return -ENOLCK;
 }
 
 int nlm_async_call(struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops)
@@ -411,10 +408,10 @@ nlmclnt_test(struct nlm_rqst *req, struct file_lock *fl)
                goto out;
 
        switch (req->a_res.status) {
-               case NLM_LCK_GRANTED:
+               case nlm_granted:
                        fl->fl_type = F_UNLCK;
                        break;
-               case NLM_LCK_DENIED:
+               case nlm_lck_denied:
                        /*
                         * Report the conflicting lock back to the application.
                         */
@@ -524,9 +521,9 @@ again:
                if (!req->a_args.block)
                        break;
                /* Did a reclaimer thread notify us of a server reboot? */
-               if (resp->status ==  NLM_LCK_DENIED_GRACE_PERIOD)
+               if (resp->status ==  nlm_lck_denied_grace_period)
                        continue;
-               if (resp->status != NLM_LCK_BLOCKED)
+               if (resp->status != nlm_lck_blocked)
                        break;
                /* Wait on an NLM blocking lock */
                status = nlmclnt_block(block, req, NLMCLNT_POLL_TIMEOUT);
@@ -535,11 +532,11 @@ again:
                 */
                if (status < 0)
                        goto out_unblock;
-               if (resp->status != NLM_LCK_BLOCKED)
+               if (resp->status != nlm_lck_blocked)
                        break;
        }
 
-       if (resp->status == NLM_LCK_GRANTED) {
+       if (resp->status == nlm_granted) {
                down_read(&host->h_rwsem);
                /* Check whether or not the server has rebooted */
                if (fl->fl_u.nfs_fl.state != host->h_state) {
@@ -556,7 +553,7 @@ again:
 out_unblock:
        nlmclnt_finish_block(block);
        /* Cancel the blocked request if it is still pending */
-       if (resp->status == NLM_LCK_BLOCKED)
+       if (resp->status == nlm_lck_blocked)
                nlmclnt_cancel(host, req->a_args.block, fl);
 out:
        nlm_release_call(req);
@@ -585,12 +582,12 @@ nlmclnt_reclaim(struct nlm_host *host, struct file_lock *fl)
        req->a_args.reclaim = 1;
 
        if ((status = nlmclnt_call(req, NLMPROC_LOCK)) >= 0
-        && req->a_res.status == NLM_LCK_GRANTED)
+        && req->a_res.status == nlm_granted)
                return 0;
 
        printk(KERN_WARNING "lockd: failed to reclaim lock for pid %d "
                                "(errno %d, status %d)\n", fl->fl_pid,
-                               status, req->a_res.status);
+                               status, ntohl(req->a_res.status));
 
        /*
         * FIXME: This is a serious failure. We can
@@ -637,10 +634,10 @@ nlmclnt_unlock(struct nlm_rqst *req, struct file_lock *fl)
        if (status < 0)
                goto out;
 
-       if (resp->status == NLM_LCK_GRANTED)
+       if (resp->status == nlm_granted)
                goto out;
 
-       if (resp->status != NLM_LCK_DENIED_NOLOCKS)
+       if (resp->status != nlm_lck_denied_nolocks)
                printk("lockd: unexpected unlock status: %d\n", resp->status);
        /* What to do now? I'm out of my depth... */
        status = -ENOLCK;
@@ -652,7 +649,7 @@ out:
 static void nlmclnt_unlock_callback(struct rpc_task *task, void *data)
 {
        struct nlm_rqst *req = data;
-       int             status = req->a_res.status;
+       u32 status = ntohl(req->a_res.status);
 
        if (RPC_ASSASSINATED(task))
                goto die;
@@ -720,6 +717,7 @@ static int nlmclnt_cancel(struct nlm_host *host, int block, struct file_lock *fl
 static void nlmclnt_cancel_callback(struct rpc_task *task, void *data)
 {
        struct nlm_rqst *req = data;
+       u32 status = ntohl(req->a_res.status);
 
        if (RPC_ASSASSINATED(task))
                goto die;
@@ -731,9 +729,9 @@ static void nlmclnt_cancel_callback(struct rpc_task *task, void *data)
        }
 
        dprintk("lockd: cancel status %u (task %u)\n",
-                       req->a_res.status, task->tk_pid);
+                       status, task->tk_pid);
 
-       switch (req->a_res.status) {
+       switch (status) {
        case NLM_LCK_GRANTED:
        case NLM_LCK_DENIED_GRACE_PERIOD:
        case NLM_LCK_DENIED:
@@ -744,7 +742,7 @@ static void nlmclnt_cancel_callback(struct rpc_task *task, void *data)
                goto retry_cancel;
        default:
                printk(KERN_NOTICE "lockd: weird return %d for CANCEL call\n",
-                       req->a_res.status);
+                       status);
        }
 
 die:
@@ -768,9 +766,9 @@ static const struct rpc_call_ops nlmclnt_cancel_ops = {
  * Convert an NLM status code to a generic kernel errno
  */
 static int
-nlm_stat_to_errno(u32 status)
+nlm_stat_to_errno(__be32 status)
 {
-       switch(status) {
+       switch(ntohl(status)) {
        case NLM_LCK_GRANTED:
                return 0;
        case NLM_LCK_DENIED: