6 files changed, 36 insertions, 35 deletions

diff --git a/fs/lockd/clntlock.c b/fs/lockd/clntlock.c
index 92681c9e9b20..062707745162 100644
--- a/fs/lockd/clntlock.c
+++ b/fs/lockd/clntlock.c
@@ -36,7 +36,7 @@ struct nlm_wait {
         struct nlm_host *       b_host;
         struct file_lock *      b_lock;         /* local file lock */
         unsigned short          b_reclaim;      /* got to reclaim lock */
-        u32                     b_status;       /* grant callback status */
+        __be32                  b_status;       /* grant callback status */
 };
 
 static LIST_HEAD(nlm_blocked);
@@ -53,7 +53,7 @@ struct nlm_wait *nlmclnt_prepare_block(struct nlm_host *host, struct file_lock *
                 block->b_host = host;
                 block->b_lock = fl;
                 init_waitqueue_head(&block->b_wait);
-                block->b_status = NLM_LCK_BLOCKED;
+                block->b_status = nlm_lck_blocked;
                 list_add(&block->b_list, &nlm_blocked);
         }
         return block;
@@ -89,7 +89,7 @@ int nlmclnt_block(struct nlm_wait *block, struct nlm_rqst *req, long timeout)
          * nlmclnt_lock for an explanation.
          */
         ret = wait_event_interruptible_timeout(block->b_wait,
-                        block->b_status != NLM_LCK_BLOCKED,
+                        block->b_status != nlm_lck_blocked,
                         timeout);
         if (ret < 0)
                 return -ERESTARTSYS;
@@ -131,7 +131,7 @@ __be32 nlmclnt_grant(const struct sockaddr_in *addr, const struct nlm_lock *lock
                 /* Alright, we found a lock. Set the return status
                  * and wake up the caller
                  */
-                block->b_status = NLM_LCK_GRANTED;
+                block->b_status = nlm_granted;
                 wake_up(&block->b_wait);
                 res = nlm_granted;
         }
@@ -211,7 +211,7 @@ restart:
         /* Now, wake up all processes that sleep on a blocked lock */
         list_for_each_entry(block, &nlm_blocked, b_list) {
                 if (block->b_host == host) {
-                        block->b_status = NLM_LCK_DENIED_GRACE_PERIOD;
+                        block->b_status = nlm_lck_denied_grace_period;
                         wake_up(&block->b_wait);
                 }
         }
diff --git a/fs/lockd/clntproc.c b/fs/lockd/clntproc.c
index 80a1a6dccc8f..0b4acc1c5e7d 100644
--- 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 *);
 
@@ -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
@@ -411,10 +411,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 +524,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 +535,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 +556,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 +585,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 +637,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 +652,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 +720,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 +732,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 +745,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 +769,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:
diff --git a/fs/lockd/svclock.c b/fs/lockd/svclock.c
index 5c054b20fd5e..c7db0a5bccdc 100644
--- a/fs/lockd/svclock.c
+++ b/fs/lockd/svclock.c
@@ -645,7 +645,7 @@ static const struct rpc_call_ops nlmsvc_grant_ops = {
  * block.
  */
 void
-nlmsvc_grant_reply(struct nlm_cookie *cookie, u32 status)
+nlmsvc_grant_reply(struct nlm_cookie *cookie, __be32 status)
 {
         struct nlm_block        *block;
 
@@ -655,7 +655,7 @@ nlmsvc_grant_reply(struct nlm_cookie *cookie, u32 status)
                 return;
 
         if (block) {
-                if (status == NLM_LCK_DENIED_GRACE_PERIOD) {
+                if (status == nlm_lck_denied_grace_period) {
                         /* Try again in a couple of seconds */
                         nlmsvc_insert_block(block, 10 * HZ);
                 } else {
diff --git a/fs/lockd/xdr.c b/fs/lockd/xdr.c
index b7c949256e5a..34dae5d70738 100644
--- a/fs/lockd/xdr.c
+++ b/fs/lockd/xdr.c
@@ -361,7 +361,7 @@ nlmsvc_decode_res(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
 {
         if (!(p = nlm_decode_cookie(p, &resp->cookie)))
                 return 0;
-        resp->status = ntohl(*p++);
+        resp->status = *p++;
         return xdr_argsize_check(rqstp, p);
 }
 
@@ -407,8 +407,8 @@ nlmclt_decode_testres(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
 {
         if (!(p = nlm_decode_cookie(p, &resp->cookie)))
                 return -EIO;
-        resp->status = ntohl(*p++);
-        if (resp->status == NLM_LCK_DENIED) {
+        resp->status = *p++;
+        if (resp->status == nlm_lck_denied) {
                 struct file_lock        *fl = &resp->lock.fl;
                 u32                     excl;
                 s32                     start, len, end;
@@ -506,7 +506,7 @@ nlmclt_decode_res(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
 {
         if (!(p = nlm_decode_cookie(p, &resp->cookie)))
                 return -EIO;
-        resp->status = ntohl(*p++);
+        resp->status = *p++;
         return 0;
 }
 
diff --git a/fs/lockd/xdr4.c b/fs/lockd/xdr4.c
index f4c0b2b9f75a..a78240551219 100644
--- a/fs/lockd/xdr4.c
+++ b/fs/lockd/xdr4.c
@@ -367,7 +367,7 @@ nlm4svc_decode_res(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
 {
         if (!(p = nlm4_decode_cookie(p, &resp->cookie)))
                 return 0;
-        resp->status = ntohl(*p++);
+        resp->status = *p++;
         return xdr_argsize_check(rqstp, p);
 }
 
@@ -413,8 +413,8 @@ nlm4clt_decode_testres(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
 {
         if (!(p = nlm4_decode_cookie(p, &resp->cookie)))
                 return -EIO;
-        resp->status = ntohl(*p++);
-        if (resp->status == NLM_LCK_DENIED) {
+        resp->status = *p++;
+        if (resp->status == nlm_lck_denied) {
                 struct file_lock        *fl = &resp->lock.fl;
                 u32                     excl;
                 s64                     start, end, len;
@@ -512,7 +512,7 @@ nlm4clt_decode_res(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
 {
         if (!(p = nlm4_decode_cookie(p, &resp->cookie)))
                 return -EIO;
-        resp->status = ntohl(*p++);
+        resp->status = *p++;
         return 0;
 }
 
diff --git a/fs/nfsd/lockd.c b/fs/nfsd/lockd.c
index 11fdaf7721b4..221acd1f11f6 100644
--- a/fs/nfsd/lockd.c
+++ b/fs/nfsd/lockd.c
@@ -22,7 +22,7 @@
 /*
  * Note: we hold the dentry use count while the file is open.
  */
-static u32
+static __be32
 nlm_fopen(struct svc_rqst *rqstp, struct nfs_fh *f, struct file **filp)
 {
         __be32          nfserr;