NFSv4: locking XDR cleanup

 Get rid of some unnecessary intermediate structures

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

3 files changed, 179 insertions, 196 deletions

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 3ecb7da220f5..857125705b6f 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -2935,43 +2935,17 @@ nfs4_set_lock_task_retry(unsigned long timeout)
         return timeout;
 }
 
-static inline int
-nfs4_lck_type(int cmd, struct file_lock *request)
-{
-        /* set lock type */
-        switch (request->fl_type) {
-                case F_RDLCK:
-                        return IS_SETLKW(cmd) ? NFS4_READW_LT : NFS4_READ_LT;
-                case F_WRLCK:
-                        return IS_SETLKW(cmd) ? NFS4_WRITEW_LT : NFS4_WRITE_LT;
-                case F_UNLCK:
-                        return NFS4_WRITE_LT; 
-        }
-        BUG();
-        return 0;
-}
-
-static inline uint64_t
-nfs4_lck_length(struct file_lock *request)
-{
-        if (request->fl_end == OFFSET_MAX)
-                return ~(uint64_t)0;
-        return request->fl_end - request->fl_start + 1;
-}
-
 static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
 {
         struct inode *inode = state->inode;
         struct nfs_server *server = NFS_SERVER(inode);
         struct nfs4_client *clp = server->nfs4_state;
-        struct nfs_lockargs arg = {
+        struct nfs_lockt_args arg = {
                 .fh = NFS_FH(inode),
-                .type = nfs4_lck_type(cmd, request),
-                .offset = request->fl_start,
-                .length = nfs4_lck_length(request),
+                .fl = request,
         };
-        struct nfs_lockres res = {
-                .server = server,
+        struct nfs_lockt_res res = {
+                .denied = request,
         };
         struct rpc_message msg = {
                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_LOCKT],
@@ -2979,36 +2953,23 @@ static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock
                 .rpc_resp       = &res,
                 .rpc_cred       = state->owner->so_cred,
         };
-        struct nfs_lowner nlo;
         struct nfs4_lock_state *lsp;
         int status;
 
         down_read(&clp->cl_sem);
-        nlo.clientid = clp->cl_clientid;
+        arg.lock_owner.clientid = clp->cl_clientid;
         status = nfs4_set_lock_state(state, request);
         if (status != 0)
                 goto out;
         lsp = request->fl_u.nfs4_fl.owner;
-        nlo.id = lsp->ls_id; 
-        arg.u.lockt = &nlo;
+        arg.lock_owner.id = lsp->ls_id; 
         status = rpc_call_sync(server->client, &msg, 0);
-        if (!status) {
-                request->fl_type = F_UNLCK;
-        } else if (status == -NFS4ERR_DENIED) {
-                int64_t len, start, end;
-                start = res.u.denied.offset;
-                len = res.u.denied.length;
-                end = start + len - 1;
-                if (end < 0 || len == 0)
-                        request->fl_end = OFFSET_MAX;
-                else
-                        request->fl_end = (loff_t)end;
-                request->fl_start = (loff_t)start;
-                request->fl_type = F_WRLCK;
-                if (res.u.denied.type & 1)
-                        request->fl_type = F_RDLCK;
-                request->fl_pid = 0;
-                status = 0;
+        switch (status) {
+                case 0:
+                        request->fl_type = F_UNLCK;
+                        break;
+                case -NFS4ERR_DENIED:
+                        status = 0;
         }
 out:
         up_read(&clp->cl_sem);
@@ -3048,17 +3009,42 @@ static int do_vfs_lock(struct file *file, struct file_lock *fl)
 }
 
 struct nfs4_unlockdata {
-        struct nfs_lockargs arg;
-        struct nfs_locku_opargs luargs;
-        struct nfs_lockres res;
+        struct nfs_locku_args arg;
+        struct nfs_locku_res res;
         struct nfs4_lock_state *lsp;
         struct nfs_open_context *ctx;
+        struct file_lock fl;
+        const struct nfs_server *server;
 };
 
+static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,
+                struct nfs_open_context *ctx,
+                struct nfs4_lock_state *lsp,
+                struct nfs_seqid *seqid)
+{
+        struct nfs4_unlockdata *p;
+        struct inode *inode = lsp->ls_state->inode;
+
+        p = kmalloc(sizeof(*p), GFP_KERNEL);
+        if (p == NULL)
+                return NULL;
+        p->arg.fh = NFS_FH(inode);
+        p->arg.fl = &p->fl;
+        p->arg.seqid = seqid;
+        p->arg.stateid = &lsp->ls_stateid;
+        p->lsp = lsp;
+        atomic_inc(&lsp->ls_count);
+        /* Ensure we don't close file until we're done freeing locks! */
+        p->ctx = get_nfs_open_context(ctx);
+        memcpy(&p->fl, fl, sizeof(p->fl));
+        p->server = NFS_SERVER(inode);
+        return p;
+}
+
 static void nfs4_locku_release_calldata(void *data)
 {
         struct nfs4_unlockdata *calldata = data;
-        nfs_free_seqid(calldata->luargs.seqid);
+        nfs_free_seqid(calldata->arg.seqid);
         nfs4_put_lock_state(calldata->lsp);
         put_nfs_open_context(calldata->ctx);
         kfree(calldata);
@@ -3070,19 +3056,19 @@ static void nfs4_locku_done(struct rpc_task *task, void *data)
 
         if (RPC_ASSASSINATED(task))
                 return;
-        nfs_increment_lock_seqid(task->tk_status, calldata->luargs.seqid);
+        nfs_increment_lock_seqid(task->tk_status, calldata->arg.seqid);
         switch (task->tk_status) {
                 case 0:
                         memcpy(calldata->lsp->ls_stateid.data,
-                                        calldata->res.u.stateid.data,
+                                        calldata->res.stateid.data,
                                         sizeof(calldata->lsp->ls_stateid.data));
                         break;
                 case -NFS4ERR_STALE_STATEID:
                 case -NFS4ERR_EXPIRED:
-                        nfs4_schedule_state_recovery(calldata->res.server->nfs4_state);
+                        nfs4_schedule_state_recovery(calldata->server->nfs4_state);
                         break;
                 default:
-                        if (nfs4_async_handle_error(task, calldata->res.server) == -EAGAIN) {
+                        if (nfs4_async_handle_error(task, calldata->server) == -EAGAIN) {
                                 rpc_restart_call(task);
                         }
         }
@@ -3097,10 +3083,8 @@ static void nfs4_locku_prepare(struct rpc_task *task, void *data)
                 .rpc_resp       = &calldata->res,
                 .rpc_cred       = calldata->lsp->ls_state->owner->so_cred,
         };
-        int status;
 
-        status = nfs_wait_on_sequence(calldata->luargs.seqid, task);
-        if (status != 0)
+        if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
                 return;
         if ((calldata->lsp->ls_flags & NFS_LOCK_INITIALIZED) == 0) {
                 /* Note: exit _without_ running nfs4_locku_done */
@@ -3121,43 +3105,32 @@ static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *
         struct nfs4_unlockdata *calldata;
         struct inode *inode = state->inode;
         struct nfs_server *server = NFS_SERVER(inode);
+        struct nfs_seqid *seqid;
         struct nfs4_lock_state *lsp;
         struct rpc_task *task;
         int status = 0;
 
         /* Is this a delegated lock? */
         if (test_bit(NFS_DELEGATED_STATE, &state->flags))
-                goto out;
+                goto out_unlock;
+        /* Is this open_owner holding any locks on the server? */
+        if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
+                goto out_unlock;
 
         status = nfs4_set_lock_state(state, request);
         if (status != 0)
-                goto out;
+                goto out_unlock;
         lsp = request->fl_u.nfs4_fl.owner;
-        /* We might have lost the locks! */
-        if ((lsp->ls_flags & NFS_LOCK_INITIALIZED) == 0)
-                goto out;
         status = -ENOMEM;
-        calldata = kmalloc(sizeof(*calldata), GFP_KERNEL);
+        seqid = nfs_alloc_seqid(&lsp->ls_seqid);
+        if (seqid == NULL)
+                goto out_unlock;
+        calldata = nfs4_alloc_unlockdata(request, request->fl_file->private_data,
+                        lsp, seqid);
         if (calldata == NULL)
-                goto out;
-        calldata->luargs.seqid = nfs_alloc_seqid(&lsp->ls_seqid);
-        if (calldata->luargs.seqid == NULL) {
-                kfree(calldata);
-                goto out;
-        }
-        calldata->luargs.stateid = &lsp->ls_stateid;
-        calldata->arg.fh = NFS_FH(inode);
-        calldata->arg.type = nfs4_lck_type(cmd, request);
-        calldata->arg.offset = request->fl_start;
-        calldata->arg.length = nfs4_lck_length(request);
-        calldata->arg.u.locku = &calldata->luargs;
-        calldata->res.server = server;
-        calldata->lsp = lsp;
-        atomic_inc(&lsp->ls_count);
-
-        /* Ensure we don't close file until we're done freeing locks! */
-        calldata->ctx = get_nfs_open_context((struct nfs_open_context*)request->fl_file->private_data);
-
+                goto out_free_seqid;
+        /* Unlock _before_ we do the RPC call */
+        do_vfs_lock(request->fl_file, request);
         task = rpc_run_task(server->client, RPC_TASK_ASYNC, &nfs4_locku_ops, calldata);
         if (!IS_ERR(task)) {
                 status = nfs4_wait_for_completion_rpc_task(task);
@@ -3166,7 +3139,10 @@ static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *
                 status = PTR_ERR(task);
                 nfs4_locku_release_calldata(calldata);
         }
-out:
+        return status;
+out_free_seqid:
+        nfs_free_seqid(seqid);
+out_unlock:
         do_vfs_lock(request->fl_file, request);
         return status;
 }
@@ -3176,27 +3152,19 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *r
         struct inode *inode = state->inode;
         struct nfs_server *server = NFS_SERVER(inode);
         struct nfs4_lock_state *lsp = request->fl_u.nfs4_fl.owner;
-        struct nfs_lock_opargs largs = {
+        struct nfs_lock_args arg = {
+                .fh = NFS_FH(inode),
+                .fl = request,
                 .lock_stateid = &lsp->ls_stateid,
                 .open_stateid = &state->stateid,
                 .lock_owner = {
                         .clientid = server->nfs4_state->cl_clientid,
                         .id = lsp->ls_id,
                 },
+                .block = (IS_SETLKW(cmd)) ? 1 : 0,
                 .reclaim = reclaim,
         };
-        struct nfs_lockargs arg = {
-                .fh = NFS_FH(inode),
-                .type = nfs4_lck_type(cmd, request),
-                .offset = request->fl_start,
-                .length = nfs4_lck_length(request),
-                .u = {
-                        .lock = &largs,
-                },
-        };
-        struct nfs_lockres res = {
-                .server = server,
-        };
+        struct nfs_lock_res res;
         struct rpc_message msg = {
                 .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_LOCK],
                 .rpc_argp       = &arg,
@@ -3205,37 +3173,37 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *r
         };
         int status = -ENOMEM;
 
-        largs.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid);
-        if (largs.lock_seqid == NULL)
+        arg.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid);
+        if (arg.lock_seqid == NULL)
                 return -ENOMEM;
         if (!(lsp->ls_seqid.flags & NFS_SEQID_CONFIRMED)) {
                 struct nfs4_state_owner *owner = state->owner;
 
-                largs.open_seqid = nfs_alloc_seqid(&owner->so_seqid);
-                if (largs.open_seqid == NULL)
+                arg.open_seqid = nfs_alloc_seqid(&owner->so_seqid);
+                if (arg.open_seqid == NULL)
                         goto out;
-                largs.new_lock_owner = 1;
+                arg.new_lock_owner = 1;
                 status = rpc_call_sync(server->client, &msg, RPC_TASK_NOINTR);
                 /* increment open seqid on success, and seqid mutating errors */
-                if (largs.new_lock_owner != 0) {
-                        nfs_increment_open_seqid(status, largs.open_seqid);
+                if (arg.new_lock_owner != 0) {
+                        nfs_increment_open_seqid(status, arg.open_seqid);
                         if (status == 0)
                                 nfs_confirm_seqid(&lsp->ls_seqid, 0);
                 }
-                nfs_free_seqid(largs.open_seqid);
+                nfs_free_seqid(arg.open_seqid);
         } else
                 status = rpc_call_sync(server->client, &msg, RPC_TASK_NOINTR);
         /* increment lock seqid on success, and seqid mutating errors*/
-        nfs_increment_lock_seqid(status, largs.lock_seqid);
+        nfs_increment_lock_seqid(status, arg.lock_seqid);
         /* save the returned stateid. */
         if (status == 0) {
-                memcpy(lsp->ls_stateid.data, res.u.stateid.data,
+                memcpy(lsp->ls_stateid.data, res.stateid.data,
                                 sizeof(lsp->ls_stateid.data));
                 lsp->ls_flags |= NFS_LOCK_INITIALIZED;
         } else if (status == -NFS4ERR_DENIED)
                 status = -EAGAIN;
 out:
-        nfs_free_seqid(largs.lock_seqid);
+        nfs_free_seqid(arg.lock_seqid);
         return status;
 }
 
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index 3100172822c9..a7b5de899c6d 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -742,69 +742,80 @@ static int encode_link(struct xdr_stream *xdr, const struct qstr *name)
         return 0;
 }
 
+static inline int nfs4_lock_type(struct file_lock *fl, int block)
+{
+        if ((fl->fl_type & (F_RDLCK|F_WRLCK|F_UNLCK)) == F_RDLCK)
+                return block ? NFS4_READW_LT : NFS4_READ_LT;
+        return block ? NFS4_WRITEW_LT : NFS4_WRITE_LT;
+}
+
+static inline uint64_t nfs4_lock_length(struct file_lock *fl)
+{
+        if (fl->fl_end == OFFSET_MAX)
+                return ~(uint64_t)0;
+        return fl->fl_end - fl->fl_start + 1;
+}
+
 /*
  * opcode,type,reclaim,offset,length,new_lock_owner = 32
  * open_seqid,open_stateid,lock_seqid,lock_owner.clientid, lock_owner.id = 40
  */
-static int encode_lock(struct xdr_stream *xdr, const struct nfs_lockargs *arg)
+static int encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args)
 {
         uint32_t *p;
-        struct nfs_lock_opargs *opargs = arg->u.lock;
 
         RESERVE_SPACE(32);
         WRITE32(OP_LOCK);
-        WRITE32(arg->type); 
-        WRITE32(opargs->reclaim);
-        WRITE64(arg->offset);
-        WRITE64(arg->length);
-        WRITE32(opargs->new_lock_owner);
-        if (opargs->new_lock_owner){
+        WRITE32(nfs4_lock_type(args->fl, args->block));
+        WRITE32(args->reclaim);
+        WRITE64(args->fl->fl_start);
+        WRITE64(nfs4_lock_length(args->fl));
+        WRITE32(args->new_lock_owner);
+        if (args->new_lock_owner){
                 RESERVE_SPACE(40);
-                WRITE32(opargs->open_seqid->sequence->counter);
-                WRITEMEM(opargs->open_stateid->data, sizeof(opargs->open_stateid->data));
-                WRITE32(opargs->lock_seqid->sequence->counter);
-                WRITE64(opargs->lock_owner.clientid);
+                WRITE32(args->open_seqid->sequence->counter);
+                WRITEMEM(args->open_stateid->data, sizeof(args->open_stateid->data));
+                WRITE32(args->lock_seqid->sequence->counter);
+                WRITE64(args->lock_owner.clientid);
                 WRITE32(4);
-                WRITE32(opargs->lock_owner.id);
+                WRITE32(args->lock_owner.id);
         }
         else {
                 RESERVE_SPACE(20);
-                WRITEMEM(opargs->lock_stateid->data, sizeof(opargs->lock_stateid->data));
-                WRITE32(opargs->lock_seqid->sequence->counter);
+                WRITEMEM(args->lock_stateid->data, sizeof(args->lock_stateid->data));
+                WRITE32(args->lock_seqid->sequence->counter);
         }
 
         return 0;
 }
 
-static int encode_lockt(struct xdr_stream *xdr, const struct nfs_lockargs *arg)
+static int encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *args)
 {
         uint32_t *p;
-        struct nfs_lowner *opargs = arg->u.lockt;
 
         RESERVE_SPACE(40);
         WRITE32(OP_LOCKT);
-        WRITE32(arg->type);
-        WRITE64(arg->offset);
-        WRITE64(arg->length);
-        WRITE64(opargs->clientid);
+        WRITE32(nfs4_lock_type(args->fl, 0));
+        WRITE64(args->fl->fl_start);
+        WRITE64(nfs4_lock_length(args->fl));
+        WRITE64(args->lock_owner.clientid);
         WRITE32(4);
-        WRITE32(opargs->id);
+        WRITE32(args->lock_owner.id);
 
         return 0;
 }
 
-static int encode_locku(struct xdr_stream *xdr, const struct nfs_lockargs *arg)
+static int encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *args)
 {
         uint32_t *p;
-        struct nfs_locku_opargs *opargs = arg->u.locku;
 
         RESERVE_SPACE(44);
         WRITE32(OP_LOCKU);
-        WRITE32(arg->type);
-        WRITE32(opargs->seqid->sequence->counter);
-        WRITEMEM(opargs->stateid->data, sizeof(opargs->stateid->data));
-        WRITE64(arg->offset);
-        WRITE64(arg->length);
+        WRITE32(nfs4_lock_type(args->fl, 0));
+        WRITE32(args->seqid->sequence->counter);
+        WRITEMEM(args->stateid->data, sizeof(args->stateid->data));
+        WRITE64(args->fl->fl_start);
+        WRITE64(nfs4_lock_length(args->fl));
 
         return 0;
 }
@@ -1596,21 +1607,20 @@ out:
 /*
  * Encode a LOCK request
  */
-static int nfs4_xdr_enc_lock(struct rpc_rqst *req, uint32_t *p, struct nfs_lockargs *args)
+static int nfs4_xdr_enc_lock(struct rpc_rqst *req, uint32_t *p, struct nfs_lock_args *args)
 {
         struct xdr_stream xdr;
         struct compound_hdr hdr = {
                 .nops   = 2,
         };
-        struct nfs_lock_opargs *opargs = args->u.lock;
         int status;
 
-        status = nfs_wait_on_sequence(opargs->lock_seqid, req->rq_task);
+        status = nfs_wait_on_sequence(args->lock_seqid, req->rq_task);
         if (status != 0)
                 goto out;
         /* Do we need to do an open_to_lock_owner? */
-        if (opargs->lock_seqid->sequence->flags & NFS_SEQID_CONFIRMED)
-                opargs->new_lock_owner = 0;
+        if (args->lock_seqid->sequence->flags & NFS_SEQID_CONFIRMED)
+                args->new_lock_owner = 0;
         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
         encode_compound_hdr(&xdr, &hdr);
         status = encode_putfh(&xdr, args->fh);
@@ -1624,7 +1634,7 @@ out:
 /*
  * Encode a LOCKT request
  */
-static int nfs4_xdr_enc_lockt(struct rpc_rqst *req, uint32_t *p, struct nfs_lockargs *args)
+static int nfs4_xdr_enc_lockt(struct rpc_rqst *req, uint32_t *p, struct nfs_lockt_args *args)
 {
         struct xdr_stream xdr;
         struct compound_hdr hdr = {
@@ -1645,7 +1655,7 @@ out:
 /*
  * Encode a LOCKU request
  */
-static int nfs4_xdr_enc_locku(struct rpc_rqst *req, uint32_t *p, struct nfs_lockargs *args)
+static int nfs4_xdr_enc_locku(struct rpc_rqst *req, uint32_t *p, struct nfs_locku_args *args)
 {
         struct xdr_stream xdr;
         struct compound_hdr hdr = {
@@ -2949,55 +2959,64 @@ static int decode_link(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
 /*
  * We create the owner, so we know a proper owner.id length is 4.
  */
-static int decode_lock_denied (struct xdr_stream *xdr, struct nfs_lock_denied *denied)
+static int decode_lock_denied (struct xdr_stream *xdr, struct file_lock *fl)
 {
+        uint64_t offset, length, clientid;
         uint32_t *p;
-        uint32_t namelen;
+        uint32_t namelen, type;
 
         READ_BUF(32);
-        READ64(denied->offset);
-        READ64(denied->length);
-        READ32(denied->type);
-        READ64(denied->owner.clientid);
+        READ64(offset);
+        READ64(length);
+        READ32(type);
+        if (fl != NULL) {
+                fl->fl_start = (loff_t)offset;
+                fl->fl_end = fl->fl_start + (loff_t)length - 1;
+                if (length == ~(uint64_t)0)
+                        fl->fl_end = OFFSET_MAX;
+                fl->fl_type = F_WRLCK;
+                if (type & 1)
+                        fl->fl_type = F_RDLCK;
+                fl->fl_pid = 0;
+        }
+        READ64(clientid);
         READ32(namelen);
         READ_BUF(namelen);
-        if (namelen == 4)
-                READ32(denied->owner.id);
         return -NFS4ERR_DENIED;
 }
 
-static int decode_lock(struct xdr_stream *xdr, struct nfs_lockres *res)
+static int decode_lock(struct xdr_stream *xdr, struct nfs_lock_res *res)
 {
         uint32_t *p;
         int status;
 
         status = decode_op_hdr(xdr, OP_LOCK);
         if (status == 0) {
-                READ_BUF(sizeof(res->u.stateid.data));
-                COPYMEM(res->u.stateid.data, sizeof(res->u.stateid.data));
+                READ_BUF(sizeof(res->stateid.data));
+                COPYMEM(res->stateid.data, sizeof(res->stateid.data));
         } else if (status == -NFS4ERR_DENIED)
-                return decode_lock_denied(xdr, &res->u.denied);
+                return decode_lock_denied(xdr, NULL);
         return status;
 }
 
-static int decode_lockt(struct xdr_stream *xdr, struct nfs_lockres *res)
+static int decode_lockt(struct xdr_stream *xdr, struct nfs_lockt_res *res)
 {
         int status;
         status = decode_op_hdr(xdr, OP_LOCKT);
         if (status == -NFS4ERR_DENIED)
-                return decode_lock_denied(xdr, &res->u.denied);
+                return decode_lock_denied(xdr, res->denied);
         return status;
 }
 
-static int decode_locku(struct xdr_stream *xdr, struct nfs_lockres *res)
+static int decode_locku(struct xdr_stream *xdr, struct nfs_locku_res *res)
 {
         uint32_t *p;
         int status;
 
         status = decode_op_hdr(xdr, OP_LOCKU);
         if (status == 0) {
-                READ_BUF(sizeof(res->u.stateid.data));
-                COPYMEM(res->u.stateid.data, sizeof(res->u.stateid.data));
+                READ_BUF(sizeof(res->stateid.data));
+                COPYMEM(res->stateid.data, sizeof(res->stateid.data));
         }
         return status;
 }
@@ -3861,7 +3880,7 @@ out:
 /*
  * Decode LOCK response
  */
-static int nfs4_xdr_dec_lock(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_lockres *res)
+static int nfs4_xdr_dec_lock(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_lock_res *res)
 {
         struct xdr_stream xdr;
         struct compound_hdr hdr;
@@ -3882,7 +3901,7 @@ out:
 /*
  * Decode LOCKT response
  */
-static int nfs4_xdr_dec_lockt(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_lockres *res)
+static int nfs4_xdr_dec_lockt(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_lockt_res *res)
 {
         struct xdr_stream xdr;
         struct compound_hdr hdr;
@@ -3903,7 +3922,7 @@ out:
 /*
  * Decode LOCKU response
  */
-static int nfs4_xdr_dec_locku(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_lockres *res)
+static int nfs4_xdr_dec_locku(struct rpc_rqst *rqstp, uint32_t *p, struct nfs_locku_res *res)
 {
         struct xdr_stream xdr;
         struct compound_hdr hdr;
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 518cfa5cd024..b8b0eed98ec9 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -165,50 +165,46 @@ struct nfs_closeres {
  *  * Arguments to the lock,lockt, and locku call.
  *   */
 struct nfs_lowner {
-        __u64           clientid;
-        u32                     id;
+        __u64                   clientid;
+        u32                     id;
 };
 
-struct nfs_lock_opargs {
+struct nfs_lock_args {
+        struct nfs_fh *         fh;
+        struct file_lock *      fl;
         struct nfs_seqid *      lock_seqid;
         nfs4_stateid *          lock_stateid;
         struct nfs_seqid *      open_seqid;
         nfs4_stateid *          open_stateid;
-        struct nfs_lowner       lock_owner;
-        __u32                   reclaim;
-        __u32                   new_lock_owner;
+        struct nfs_lowner       lock_owner;
+        unsigned char           block : 1;
+        unsigned char           reclaim : 1;
+        unsigned char           new_lock_owner : 1;
+};
+
+struct nfs_lock_res {
+        nfs4_stateid                    stateid;
 };
 
-struct nfs_locku_opargs {
+struct nfs_locku_args {
+        struct nfs_fh *         fh;
+        struct file_lock *      fl;
         struct nfs_seqid *      seqid;
         nfs4_stateid *          stateid;
 };
 
-struct nfs_lockargs {
-        struct nfs_fh *         fh;
-        __u32                   type;
-        __u64                   offset; 
-        __u64                   length; 
-        union {
-                struct nfs_lock_opargs  *lock;    /* LOCK  */
-                struct nfs_lowner       *lockt;  /* LOCKT */
-                struct nfs_locku_opargs *locku;  /* LOCKU */
-        } u;
+struct nfs_locku_res {
+        nfs4_stateid                    stateid;
 };
 
-struct nfs_lock_denied {
-        __u64                   offset;
-        __u64                   length;
-        __u32                   type;
-        struct nfs_lowner       owner;
+struct nfs_lockt_args {
+        struct nfs_fh *         fh;
+        struct file_lock *      fl;
+        struct nfs_lowner       lock_owner;
 };
 
-struct nfs_lockres {
-        union {
-                nfs4_stateid            stateid;/* LOCK success, LOCKU */
-                struct nfs_lock_denied  denied; /* LOCK failed, LOCKT success */
-        } u;
-        const struct nfs_server *       server;
+struct nfs_lockt_res {
+        struct file_lock *      denied; /* LOCK, LOCKT failed */
 };
 
 struct nfs4_delegreturnargs {