1 files changed, 75 insertions, 56 deletions

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;