nfs41 client patches for review

index ac2386b..69b5a56 100644
@@ -4423,8 +4423,6 @@ static int nfs4_xdr_dec_fsinfo(struct rpc_rqst *req, __be32 *p, struct nfs_fsinf
 		status = decode_putfh(&xdr);
 	if (!status)
 		status = decode_fsinfo(&xdr, fsinfo);
-	if (!status)
-		status = nfs4_stat_to_errno(hdr.status);
 	return status;
 }
 

@@ -4513,8 +4511,6 @@ static int nfs4_xdr_dec_setclientid(struct rpc_rqst *req, __be32 *p,
 	status = decode_compound_hdr(&xdr, &hdr);
 	if (!status)
 		status = decode_setclientid(&xdr, clp);
-	if (!status)
-		status = nfs4_stat_to_errno(hdr.status);
 	return status;
 }
 

@@ -4535,8 +4531,6 @@ static int nfs4_xdr_dec_setclientid_confirm(struct rpc_rqst *req, __be32 *p, str
 		status = decode_putrootfh(&xdr);
 	if (!status)
 		status = decode_fsinfo(&xdr, fsinfo);
-	if (!status)
-		status = nfs4_stat_to_errno(hdr.status);
 	return status;
 }
 

index 69b5a56..c1ff9c9 100644
@@ -578,9 +578,10 @@ static void encode_string(struct xdr_stream *xdr, unsigned int len, const char *
 	xdr_encode_opaque(p, str, len);
 }
 
-static int encode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr)
+static __u32 *
+encode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr)
 {
-	__be32 *p;
+	__be32 *p, *nops;
 
 	dprintk("encode_compound: tag=%.*s\n", (int)hdr->taglen, hdr->tag);
 	BUG_ON(hdr->taglen > NFS4_MAXTAGLEN);

@@ -588,8 +589,14 @@ static int encode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr)
 	WRITE32(hdr->taglen);
 	WRITEMEM(hdr->tag, hdr->taglen);
 	WRITE32(NFS4_MINOR_VERSION);
+	nops = p;
 	WRITE32(hdr->nops);
-	return 0;
+	return nops;
+}
+
+static inline void encode_nops(__be32 *nops, struct compound_hdr *hdr)
+{
+	*nops = htonl(hdr->nops);
 }
 
 static void encode_nfs4_verifier(struct xdr_stream *xdr, const nfs4_verifier *verf)

@@ -728,18 +735,22 @@ static int encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const s
 	return status;
 }
 
-static int encode_access(struct xdr_stream *xdr, u32 access)
+static int
+encode_access(struct xdr_stream *xdr, u32 access, struct compound_hdr *hdr)
 {
 	__be32 *p;
 
 	RESERVE_SPACE(8);
 	WRITE32(OP_ACCESS);
 	WRITE32(access);
-	
+	hdr->nops++;
+
 	return 0;
 }
 
-static int encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg)
+static int
+encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg,
+	     struct compound_hdr *hdr)
 {
 	__be32 *p;
 

@@ -747,23 +758,29 @@ static int encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg)
 	WRITE32(OP_CLOSE);
 	WRITE32(arg->seqid->sequence->counter);
 	WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
+	hdr->nops++;
 	
 	return 0;
 }
 
-static int encode_commit(struct xdr_stream *xdr, const struct nfs_writeargs *args)
+static int
+encode_commit(struct xdr_stream *xdr, const struct nfs_writeargs *args,
+	      struct compound_hdr *hdr)
 {
 	__be32 *p;
         
-        RESERVE_SPACE(16);
-        WRITE32(OP_COMMIT);
-        WRITE64(args->offset);
-        WRITE32(args->count);
+	RESERVE_SPACE(16);
+	WRITE32(OP_COMMIT);
+	WRITE64(args->offset);
+	WRITE32(args->count);
+	hdr->nops++;
 
-        return 0;
+	return 0;
 }
 
-static int encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *create)
+static int
+encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *create,
+	      struct compound_hdr *hdr)
 {
 	__be32 *p;
 	

@@ -791,11 +808,14 @@ static int encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *c
 	RESERVE_SPACE(4 + create->name->len);
 	WRITE32(create->name->len);
 	WRITEMEM(create->name->name, create->name->len);
+	hdr->nops++;
 
 	return encode_attrs(xdr, create->attrs, create->server);
 }
 
-static int encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap)
+static int
+encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap,
+		   struct compound_hdr *hdr)
 {
         __be32 *p;
 

@@ -803,10 +823,13 @@ static int encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap)
         WRITE32(OP_GETATTR);
         WRITE32(1);
         WRITE32(bitmap);
+	hdr->nops++;
         return 0;
 }
 
-static int encode_getattr_two(struct xdr_stream *xdr, uint32_t bm0, uint32_t bm1)
+static int
+encode_getattr_two(struct xdr_stream *xdr, uint32_t bm0, uint32_t bm1,
+		   struct compound_hdr *hdr)
 {
         __be32 *p;
 

@@ -815,40 +838,51 @@ static int encode_getattr_two(struct xdr_stream *xdr, uint32_t bm0, uint32_t bm1
         WRITE32(2);
         WRITE32(bm0);
         WRITE32(bm1);
+	hdr->nops++;
         return 0;
 }
 
-static int encode_getfattr(struct xdr_stream *xdr, const u32* bitmask)
+static int
+encode_getfattr(struct xdr_stream *xdr, const u32 *bitmask,
+		struct compound_hdr *hdr)
 {
 	return encode_getattr_two(xdr,
 			bitmask[0] & nfs4_fattr_bitmap[0],
-			bitmask[1] & nfs4_fattr_bitmap[1]);
+			bitmask[1] & nfs4_fattr_bitmap[1], hdr);
 }
 
-static int encode_fsinfo(struct xdr_stream *xdr, const u32* bitmask)
+static int
+encode_fsinfo(struct xdr_stream *xdr, const u32 *bitmask,
+	      struct compound_hdr *hdr)
 {
 	return encode_getattr_two(xdr, bitmask[0] & nfs4_fsinfo_bitmap[0],
-			bitmask[1] & nfs4_fsinfo_bitmap[1]);
+			bitmask[1] & nfs4_fsinfo_bitmap[1], hdr);
 }
 
-static int encode_fs_locations(struct xdr_stream *xdr, const u32* bitmask)
+static int
+encode_fs_locations(struct xdr_stream *xdr, const u32 *bitmask,
+		    struct compound_hdr *hdr)
 {
 	return encode_getattr_two(xdr,
 				  bitmask[0] & nfs4_fs_locations_bitmap[0],
-				  bitmask[1] & nfs4_fs_locations_bitmap[1]);
+				  bitmask[1] & nfs4_fs_locations_bitmap[1],
+				  hdr);
 }
 
-static int encode_getfh(struct xdr_stream *xdr)
+static int encode_getfh(struct xdr_stream *xdr, struct compound_hdr *hdr)
 {
 	__be32 *p;
 
 	RESERVE_SPACE(4);
 	WRITE32(OP_GETFH);
+	hdr->nops++;
 
 	return 0;
 }
 
-static int encode_link(struct xdr_stream *xdr, const struct qstr *name)
+static int
+encode_link(struct xdr_stream *xdr, const struct qstr *name,
+	    struct compound_hdr *hdr)
 {
 	__be32 *p;
 

@@ -856,6 +890,7 @@ static int encode_link(struct xdr_stream *xdr, const struct qstr *name)
 	WRITE32(OP_LINK);
 	WRITE32(name->len);
 	WRITEMEM(name->name, name->len);
+	hdr->nops++;
 	
 	return 0;
 }

@@ -878,7 +913,9 @@ static inline uint64_t nfs4_lock_length(struct file_lock *fl)
  * 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_lock_args *args)
+static int
+encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args,
+	    struct compound_hdr *hdr)
 {
 	__be32 *p;
 

@@ -904,11 +941,14 @@ static int encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args)
 		WRITEMEM(args->lock_stateid->data, NFS4_STATEID_SIZE);
 		WRITE32(args->lock_seqid->sequence->counter);
 	}
+	hdr->nops++;
 
 	return 0;
 }
 
-static int encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *args)
+static int
+encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *args,
+	     struct compound_hdr *hdr)
 {
 	__be32 *p;
 

@@ -921,11 +961,14 @@ static int encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *arg
 	WRITE32(16);
 	WRITEMEM("lock id:", 8);
 	WRITE64(args->lock_owner.id);
+	hdr->nops++;
 
 	return 0;
 }
 
-static int encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *args)
+static int
+encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *args,
+	     struct compound_hdr *hdr)
 {
 	__be32 *p;
 

@@ -936,11 +979,14 @@ static int encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *arg
 	WRITEMEM(args->stateid->data, NFS4_STATEID_SIZE);
 	WRITE64(args->fl->fl_start);
 	WRITE64(nfs4_lock_length(args->fl));
+	hdr->nops++;
 
 	return 0;
 }
 
-static int encode_lookup(struct xdr_stream *xdr, const struct qstr *name)
+static int
+encode_lookup(struct xdr_stream *xdr, const struct qstr *name,
+	      struct compound_hdr *hdr)
 {
 	int len = name->len;
 	__be32 *p;

@@ -949,6 +995,7 @@ static int encode_lookup(struct xdr_stream *xdr, const struct qstr *name)
 	WRITE32(OP_LOOKUP);
 	WRITE32(len);
 	WRITEMEM(name->name, len);
+	hdr->nops++;
 
 	return 0;
 }

@@ -1072,7 +1119,9 @@ static inline void encode_claim_delegate_cur(struct xdr_stream *xdr, const struc
 	encode_string(xdr, name->len, name->name);
 }
 
-static int encode_open(struct xdr_stream *xdr, const struct nfs_openargs *arg)
+static int
+encode_open(struct xdr_stream *xdr, const struct nfs_openargs *arg,
+	    struct compound_hdr *hdr)
 {
 	encode_openhdr(xdr, arg);
 	encode_opentype(xdr, arg);

@@ -1089,10 +1138,14 @@ static int encode_open(struct xdr_stream *xdr, const struct nfs_openargs *arg)
 		default:
 			BUG();
 	}
+	hdr->nops++;
 	return 0;
 }
 
-static int encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_confirmargs *arg)
+static int
+encode_open_confirm(struct xdr_stream *xdr,
+		    const struct nfs_open_confirmargs *arg,
+		    struct compound_hdr *hdr)
 {
 	__be32 *p;
 

@@ -1100,11 +1153,14 @@ static int encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_con
 	WRITE32(OP_OPEN_CONFIRM);
 	WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
 	WRITE32(arg->seqid->sequence->counter);
+	hdr->nops++;
 
 	return 0;
 }
 
-static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closeargs *arg)
+static int
+encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closeargs *arg,
+		      struct compound_hdr *hdr)
 {
 	__be32 *p;
 

@@ -1113,11 +1169,13 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea
 	WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
 	WRITE32(arg->seqid->sequence->counter);
 	encode_share_access(xdr, arg->open_flags);
+	hdr->nops++;
 	return 0;
 }
 
 static int
-encode_putfh(struct xdr_stream *xdr, const struct nfs_fh *fh)
+encode_putfh(struct xdr_stream *xdr, const struct nfs_fh *fh,
+	     struct compound_hdr *hdr)
 {
 	int len = fh->size;
 	__be32 *p;

@@ -1126,21 +1184,24 @@ encode_putfh(struct xdr_stream *xdr, const struct nfs_fh *fh)
 	WRITE32(OP_PUTFH);
 	WRITE32(len);
 	WRITEMEM(fh->data, len);
+	hdr->nops++;
 
 	return 0;
 }
 
-static int encode_putrootfh(struct xdr_stream *xdr)
+static int encode_putrootfh(struct xdr_stream *xdr, struct compound_hdr *hdr)
 {
         __be32 *p;
         
         RESERVE_SPACE(4);
         WRITE32(OP_PUTROOTFH);
+	hdr->nops++;
 
         return 0;
 }
 
-static void encode_stateid(struct xdr_stream *xdr, const struct nfs_open_context *ctx)
+static void
+encode_stateid(struct xdr_stream *xdr, const struct nfs_open_context *ctx)
 {
 	nfs4_stateid stateid;
 	__be32 *p;

@@ -1153,7 +1214,9 @@ static void encode_stateid(struct xdr_stream *xdr, const struct nfs_open_context
 		WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE);
 }
 
-static int encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args)
+static int
+encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args,
+	    struct compound_hdr *hdr)
 {
 	__be32 *p;
 

@@ -1165,11 +1228,14 @@ static int encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args)
 	RESERVE_SPACE(12);
 	WRITE64(args->offset);
 	WRITE32(args->count);
+	hdr->nops++;
 
 	return 0;
 }
 
-static int encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg *readdir, struct rpc_rqst *req)
+static int
+encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg *readdir,
+	       struct rpc_rqst *req, struct compound_hdr *hdr)
 {
 	uint32_t attrs[2] = {
 		FATTR4_WORD0_RDATTR_ERROR|FATTR4_WORD0_FILEID,

@@ -1191,6 +1257,7 @@ static int encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg
 		attrs[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
 	WRITE32(attrs[0] & readdir->bitmask[0]);
 	WRITE32(attrs[1] & readdir->bitmask[1]);
+	hdr->nops++;
 	dprintk("%s: cookie = %Lu, verifier = %08x:%08x, bitmap = %08x:%08x\n",
 			__func__,
 			(unsigned long long)readdir->cookie,

@@ -1202,17 +1269,22 @@ static int encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg
 	return 0;
 }
 
-static int encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *readlink, struct rpc_rqst *req)
+static int
+encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *readlink,
+		struct rpc_rqst *req, struct compound_hdr *hdr)
 {
 	__be32 *p;
 
 	RESERVE_SPACE(4);
 	WRITE32(OP_READLINK);
+	hdr->nops++;
 
 	return 0;
 }
 
-static int encode_remove(struct xdr_stream *xdr, const struct qstr *name)
+static int
+encode_remove(struct xdr_stream *xdr, const struct qstr *name,
+	      struct compound_hdr *hdr)
 {
 	__be32 *p;
 

@@ -1220,11 +1292,14 @@ static int encode_remove(struct xdr_stream *xdr, const struct qstr *name)
 	WRITE32(OP_REMOVE);
 	WRITE32(name->len);
 	WRITEMEM(name->name, name->len);
+	hdr->nops++;
 
 	return 0;
 }
 
-static int encode_rename(struct xdr_stream *xdr, const struct qstr *oldname, const struct qstr *newname)
+static int
+encode_rename(struct xdr_stream *xdr, const struct qstr *oldname,
+	      const struct qstr *newname, struct compound_hdr *hdr)
 {
 	__be32 *p;
 

@@ -1236,34 +1311,40 @@ static int encode_rename(struct xdr_stream *xdr, const struct qstr *oldname, con
 	RESERVE_SPACE(4 + newname->len);
 	WRITE32(newname->len);
 	WRITEMEM(newname->name, newname->len);
+	hdr->nops++;
 
 	return 0;
 }
 
-static int encode_renew(struct xdr_stream *xdr, const struct nfs_client *client_stateid)
+static int
+encode_renew(struct xdr_stream *xdr, const struct nfs_client *client_stateid,
+	     struct compound_hdr *hdr)
 {
 	__be32 *p;
 
 	RESERVE_SPACE(12);
 	WRITE32(OP_RENEW);
 	WRITE64(client_stateid->cl_clientid);
+	hdr->nops++;
 
 	return 0;
 }
 
 static int
-encode_restorefh(struct xdr_stream *xdr)
+encode_restorefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
 {
 	__be32 *p;
 
 	RESERVE_SPACE(4);
 	WRITE32(OP_RESTOREFH);
+	hdr->nops++;
 
 	return 0;
 }
 
 static int
-encode_setacl(struct xdr_stream *xdr, struct nfs_setaclargs *arg)
+encode_setacl(struct xdr_stream *xdr, struct nfs_setaclargs *arg,
+	      struct compound_hdr *hdr)
 {
 	__be32 *p;
 

@@ -1278,21 +1359,25 @@ encode_setacl(struct xdr_stream *xdr, struct nfs_setaclargs *arg)
 	RESERVE_SPACE(4);
 	WRITE32(arg->acl_len);
 	xdr_write_pages(xdr, arg->acl_pages, arg->acl_pgbase, arg->acl_len);
+	hdr->nops++;
 	return 0;
 }
 
 static int
-encode_savefh(struct xdr_stream *xdr)
+encode_savefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
 {
 	__be32 *p;
 
 	RESERVE_SPACE(4);
 	WRITE32(OP_SAVEFH);
+	hdr->nops++;
 
 	return 0;
 }
 
-static int encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs *arg, const struct nfs_server *server)
+static int
+encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs *arg,
+	       const struct nfs_server *server, struct compound_hdr *hdr)
 {
 	int status;
 	__be32 *p;

@@ -1300,6 +1385,7 @@ static int encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs *
         RESERVE_SPACE(4+NFS4_STATEID_SIZE);
         WRITE32(OP_SETATTR);
 	WRITEMEM(arg->stateid.data, NFS4_STATEID_SIZE);
+	hdr->nops++;
 
         if ((status = encode_attrs(xdr, arg->iap, server)))
 		return status;

@@ -1307,7 +1393,10 @@ static int encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs *
         return 0;
 }
 
-static int encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclientid *setclientid)
+static int
+encode_setclientid(struct xdr_stream *xdr,
+		   const struct nfs4_setclientid *setclientid,
+		   struct compound_hdr *hdr)
 {
 	__be32 *p;
 

@@ -1322,11 +1411,15 @@ static int encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclien
 	encode_string(xdr, setclientid->sc_uaddr_len, setclientid->sc_uaddr);
 	RESERVE_SPACE(4);
 	WRITE32(setclientid->sc_cb_ident);
+	hdr->nops++;
 
 	return 0;
 }
 
-static int encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs_client *client_state)
+static int
+encode_setclientid_confirm(struct xdr_stream *xdr,
+			   const struct nfs_client *client_state,
+			   struct compound_hdr *hdr)
 {
         __be32 *p;
 

@@ -1334,11 +1427,14 @@ static int encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs_c
         WRITE32(OP_SETCLIENTID_CONFIRM);
         WRITE64(client_state->cl_clientid);
         WRITEMEM(client_state->cl_confirm.data, NFS4_VERIFIER_SIZE);
+	hdr->nops++;
 
         return 0;
 }
 
-static int encode_write(struct xdr_stream *xdr, const struct nfs_writeargs *args)
+static int
+encode_write(struct xdr_stream *xdr, const struct nfs_writeargs *args,
+	     struct compound_hdr *hdr)
 {
 	__be32 *p;
 

@@ -1353,11 +1449,14 @@ static int encode_write(struct xdr_stream *xdr, const struct nfs_writeargs *args
 	WRITE32(args->count);
 
 	xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
+	hdr->nops++;
 
 	return 0;
 }
 
-static int encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *stateid)
+static int
+encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *stateid,
+		   struct compound_hdr *hdr)
 {
 	__be32 *p;
 

@@ -1365,6 +1464,7 @@ static int encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *statei
 
 	WRITE32(OP_DELEGRETURN);
 	WRITEMEM(stateid->data, NFS4_STATEID_SIZE);
+	hdr->nops++;
 	return 0;
 
 }

@@ -1379,20 +1479,22 @@ static int nfs4_xdr_enc_access(struct rpc_rqst *req, __be32 *p, const struct nfs
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 3,
+		.nops = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if (status != 0)
 		goto out;
-	status = encode_access(&xdr, args->access);
+	status = encode_access(&xdr, args->access, &hdr);
 	if (status != 0)
 		goto out;
-	status = encode_getfattr(&xdr, args->bitmask);
+	status = encode_getfattr(&xdr, args->bitmask, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1403,20 +1505,22 @@ static int nfs4_xdr_enc_lookup(struct rpc_rqst *req, __be32 *p, const struct nfs
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 4,
+		.nops = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	if ((status = encode_putfh(&xdr, args->dir_fh)) != 0)
+	nops = encode_compound_hdr(&xdr, &hdr);
+	if ((status = encode_putfh(&xdr, args->dir_fh, &hdr)) != 0)
 		goto out;
-	if ((status = encode_lookup(&xdr, args->name)) != 0)
+	if ((status = encode_lookup(&xdr, args->name, &hdr)) != 0)
 		goto out;
-	if ((status = encode_getfh(&xdr)) != 0)
+	if ((status = encode_getfh(&xdr, &hdr)) != 0)
 		goto out;
-	status = encode_getfattr(&xdr, args->bitmask);
+	status = encode_getfattr(&xdr, args->bitmask, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1427,17 +1531,19 @@ static int nfs4_xdr_enc_lookup_root(struct rpc_rqst *req, __be32 *p, const struc
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 3,
+		.nops = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	if ((status = encode_putrootfh(&xdr)) != 0)
+	nops = encode_compound_hdr(&xdr, &hdr);
+	if ((status = encode_putrootfh(&xdr, &hdr)) != 0)
 		goto out;
-	if ((status = encode_getfh(&xdr)) == 0)
-		status = encode_getfattr(&xdr, args->bitmask);
+	if ((status = encode_getfh(&xdr, &hdr)) == 0)
+		status = encode_getfattr(&xdr, args->bitmask, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1448,18 +1554,20 @@ static int nfs4_xdr_enc_remove(struct rpc_rqst *req, __be32 *p, const struct nfs
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 3,
+		.nops = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	if ((status = encode_putfh(&xdr, args->fh)) != 0)
+	nops = encode_compound_hdr(&xdr, &hdr);
+	if ((status = encode_putfh(&xdr, args->fh, &hdr)) != 0)
 		goto out;
-	if ((status = encode_remove(&xdr, &args->name)) != 0)
+	if ((status = encode_remove(&xdr, &args->name, &hdr)) != 0)
 		goto out;
-	status = encode_getfattr(&xdr, args->bitmask);
+	status = encode_getfattr(&xdr, args->bitmask, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1470,26 +1578,29 @@ static int nfs4_xdr_enc_rename(struct rpc_rqst *req, __be32 *p, const struct nfs
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 7,
+		.nops = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	if ((status = encode_putfh(&xdr, args->old_dir)) != 0)
+	nops = encode_compound_hdr(&xdr, &hdr);
+	if ((status = encode_putfh(&xdr, args->old_dir, &hdr)) != 0)
 		goto out;
-	if ((status = encode_savefh(&xdr)) != 0)
+	if ((status = encode_savefh(&xdr, &hdr)) != 0)
 		goto out;
-	if ((status = encode_putfh(&xdr, args->new_dir)) != 0)
+	if ((status = encode_putfh(&xdr, args->new_dir, &hdr)) != 0)
 		goto out;
-	if ((status = encode_rename(&xdr, args->old_name, args->new_name)) != 0)
+	if ((status = encode_rename(&xdr, args->old_name, args->new_name,
+				    &hdr)) != 0)
 		goto out;
-	if ((status = encode_getfattr(&xdr, args->bitmask)) != 0)
+	if ((status = encode_getfattr(&xdr, args->bitmask, &hdr)) != 0)
 		goto out;
-	if ((status = encode_restorefh(&xdr)) != 0)
+	if ((status = encode_restorefh(&xdr, &hdr)) != 0)
 		goto out;
-	status = encode_getfattr(&xdr, args->bitmask);
+	status = encode_getfattr(&xdr, args->bitmask, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1500,26 +1611,28 @@ static int nfs4_xdr_enc_link(struct rpc_rqst *req, __be32 *p, const struct nfs4_
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 7,
+		.nops = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	if ((status = encode_putfh(&xdr, args->fh)) != 0)
+	nops = encode_compound_hdr(&xdr, &hdr);
+	if ((status = encode_putfh(&xdr, args->fh, &hdr)) != 0)
 		goto out;
-	if ((status = encode_savefh(&xdr)) != 0)
+	if ((status = encode_savefh(&xdr, &hdr)) != 0)
 		goto out;
-	if ((status = encode_putfh(&xdr, args->dir_fh)) != 0)
+	if ((status = encode_putfh(&xdr, args->dir_fh, &hdr)) != 0)
 		goto out;
-	if ((status = encode_link(&xdr, args->name)) != 0)
+	if ((status = encode_link(&xdr, args->name, &hdr)) != 0)
 		goto out;
-	if ((status = encode_getfattr(&xdr, args->bitmask)) != 0)
+	if ((status = encode_getfattr(&xdr, args->bitmask, &hdr)) != 0)
 		goto out;
-	if ((status = encode_restorefh(&xdr)) != 0)
+	if ((status = encode_restorefh(&xdr, &hdr)) != 0)
 		goto out;
-	status = encode_getfattr(&xdr, args->bitmask);
+	status = encode_getfattr(&xdr, args->bitmask, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1530,26 +1643,28 @@ static int nfs4_xdr_enc_create(struct rpc_rqst *req, __be32 *p, const struct nfs
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 7,
+		.nops = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	if ((status = encode_putfh(&xdr, args->dir_fh)) != 0)
+	nops = encode_compound_hdr(&xdr, &hdr);
+	if ((status = encode_putfh(&xdr, args->dir_fh, &hdr)) != 0)
 		goto out;
-	if ((status = encode_savefh(&xdr)) != 0)
+	if ((status = encode_savefh(&xdr, &hdr)) != 0)
 		goto out;
-	if ((status = encode_create(&xdr, args)) != 0)
+	if ((status = encode_create(&xdr, args, &hdr)) != 0)
 		goto out;
-	if ((status = encode_getfh(&xdr)) != 0)
+	if ((status = encode_getfh(&xdr, &hdr)) != 0)
 		goto out;
-	if ((status = encode_getfattr(&xdr, args->bitmask)) != 0)
+	if ((status = encode_getfattr(&xdr, args->bitmask, &hdr)) != 0)
 		goto out;
-	if ((status = encode_restorefh(&xdr)) != 0)
+	if ((status = encode_restorefh(&xdr, &hdr)) != 0)
 		goto out;
-	status = encode_getfattr(&xdr, args->bitmask);
+	status = encode_getfattr(&xdr, args->bitmask, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1568,14 +1683,16 @@ static int nfs4_xdr_enc_getattr(struct rpc_rqst *req, __be32 *p, const struct nf
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 2,
+		.nops = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	if ((status = encode_putfh(&xdr, args->fh)) == 0)
-		status = encode_getfattr(&xdr, args->bitmask);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	if ((status = encode_putfh(&xdr, args->fh, &hdr)) == 0)
+		status = encode_getfattr(&xdr, args->bitmask, &hdr);
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1586,20 +1703,22 @@ static int nfs4_xdr_enc_close(struct rpc_rqst *req, __be32 *p, struct nfs_closea
 {
         struct xdr_stream xdr;
         struct compound_hdr hdr = {
-                .nops   = 3,
+		.nops   = 0,
         };
         int status;
+	__be32 *nops;
 
         xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-        encode_compound_hdr(&xdr, &hdr);
-        status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
         if(status)
                 goto out;
-        status = encode_close(&xdr, args);
+	status = encode_close(&xdr, args, &hdr);
 	if (status != 0)
 		goto out;
-	status = encode_getfattr(&xdr, args->bitmask);
+	status = encode_getfattr(&xdr, args->bitmask, &hdr);
 out:
+	encode_nops(nops, &hdr);
         return status;
 }
 

@@ -1610,32 +1729,34 @@ static int nfs4_xdr_enc_open(struct rpc_rqst *req, __be32 *p, struct nfs_openarg
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 7,
+		.nops = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if (status)
 		goto out;
-	status = encode_savefh(&xdr);
+	status = encode_savefh(&xdr, &hdr);
 	if (status)
 		goto out;
-	status = encode_open(&xdr, args);
+	status = encode_open(&xdr, args, &hdr);
 	if (status)
 		goto out;
-	status = encode_getfh(&xdr);
+	status = encode_getfh(&xdr, &hdr);
 	if (status)
 		goto out;
-	status = encode_getfattr(&xdr, args->bitmask);
+	status = encode_getfattr(&xdr, args->bitmask, &hdr);
 	if (status)
 		goto out;
-	status = encode_restorefh(&xdr);
+	status = encode_restorefh(&xdr, &hdr);
 	if (status)
 		goto out;
-	status = encode_getfattr(&xdr, args->bitmask);
+	status = encode_getfattr(&xdr, args->bitmask, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1646,17 +1767,19 @@ static int nfs4_xdr_enc_open_confirm(struct rpc_rqst *req, __be32 *p, struct nfs
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops   = 2,
+		.nops   = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if(status)
 		goto out;
-	status = encode_open_confirm(&xdr, args);
+	status = encode_open_confirm(&xdr, args, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1667,20 +1790,22 @@ static int nfs4_xdr_enc_open_noattr(struct rpc_rqst *req, __be32 *p, struct nfs_
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops   = 3,
+		.nops   = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if (status)
 		goto out;
-	status = encode_open(&xdr, args);
+	status = encode_open(&xdr, args, &hdr);
 	if (status)
 		goto out;
-	status = encode_getfattr(&xdr, args->bitmask);
+	status = encode_getfattr(&xdr, args->bitmask, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1691,20 +1816,22 @@ static int nfs4_xdr_enc_open_downgrade(struct rpc_rqst *req, __be32 *p, struct n
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops	= 3,
+		.nops	= 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if (status)
 		goto out;
-	status = encode_open_downgrade(&xdr, args);
+	status = encode_open_downgrade(&xdr, args, &hdr);
 	if (status != 0)
 		goto out;
-	status = encode_getfattr(&xdr, args->bitmask);
+	status = encode_getfattr(&xdr, args->bitmask, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1715,17 +1842,19 @@ static int nfs4_xdr_enc_lock(struct rpc_rqst *req, __be32 *p, struct nfs_lock_ar
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops   = 2,
+		.nops   = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if(status)
 		goto out;
-	status = encode_lock(&xdr, args);
+	status = encode_lock(&xdr, args, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1736,17 +1865,19 @@ static int nfs4_xdr_enc_lockt(struct rpc_rqst *req, __be32 *p, struct nfs_lockt_
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops   = 2,
+		.nops   = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if(status)
 		goto out;
-	status = encode_lockt(&xdr, args);
+	status = encode_lockt(&xdr, args, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1757,17 +1888,19 @@ static int nfs4_xdr_enc_locku(struct rpc_rqst *req, __be32 *p, struct nfs_locku_
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops   = 2,
+		.nops   = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if(status)
 		goto out;
-	status = encode_locku(&xdr, args);
+	status = encode_locku(&xdr, args, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1778,18 +1911,19 @@ static int nfs4_xdr_enc_readlink(struct rpc_rqst *req, __be32 *p, const struct n
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 2,
+		.nops = 0,
 	};
 	struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
 	unsigned int replen;
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if(status)
 		goto out;
-	status = encode_readlink(&xdr, args, req);
+	status = encode_readlink(&xdr, args, req, &hdr);
 
 	/* set up reply kvec
 	 *    toplevel_status + taglen + rescount + OP_PUTFH + status

@@ -1800,6 +1934,7 @@ static int nfs4_xdr_enc_readlink(struct rpc_rqst *req, __be32 *p, const struct n
 			args->pgbase, args->pglen);
 
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1810,18 +1945,19 @@ static int nfs4_xdr_enc_readdir(struct rpc_rqst *req, __be32 *p, const struct nf
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 2,
+		.nops = 0,
 	};
 	struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
 	int replen;
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if(status)
 		goto out;
-	status = encode_readdir(&xdr, args, req);
+	status = encode_readdir(&xdr, args, req, &hdr);
 
 	/* set up reply kvec
 	 *    toplevel_status + taglen + rescount + OP_PUTFH + status

@@ -1835,6 +1971,7 @@ static int nfs4_xdr_enc_readdir(struct rpc_rqst *req, __be32 *p, const struct nf
 			args->pgbase, args->count);
 
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1846,16 +1983,17 @@ static int nfs4_xdr_enc_read(struct rpc_rqst *req, __be32 *p, struct nfs_readarg
 	struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 2,
+		.nops = 0,
 	};
 	int replen, status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if (status)
 		goto out;
-	status = encode_read(&xdr, args);
+	status = encode_read(&xdr, args, &hdr);
 	if (status)
 		goto out;
 

@@ -1868,6 +2006,7 @@ static int nfs4_xdr_enc_read(struct rpc_rqst *req, __be32 *p, struct nfs_readarg
 			 args->pages, args->pgbase, args->count);
 	req->rq_rcv_buf.flags |= XDRBUF_READ;
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1877,23 +2016,25 @@ out:
 static int nfs4_xdr_enc_setattr(struct rpc_rqst *req, __be32 *p, struct nfs_setattrargs *args)
 
 {
-        struct xdr_stream xdr;
-        struct compound_hdr hdr = {
-                .nops   = 3,
-        };
-        int status;
+	struct xdr_stream xdr;
+	struct compound_hdr hdr = {
+		.nops   = 0,
+	};
+	int status;
+	__be32 *nops;
 
-        xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-        encode_compound_hdr(&xdr, &hdr);
-        status = encode_putfh(&xdr, args->fh);
-        if(status)
-                goto out;
-        status = encode_setattr(&xdr, args, args->server);
-        if(status)
-                goto out;
-	status = encode_getfattr(&xdr, args->bitmask);
+	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
+	if (status)
+		goto out;
+	status = encode_setattr(&xdr, args, args->server, &hdr);
+	if (status)
+		goto out;
+	status = encode_getfattr(&xdr, args->bitmask, &hdr);
 out:
-        return status;
+	encode_nops(nops, &hdr);
+	return status;
 }
 
 /*

@@ -1906,21 +2047,23 @@ nfs4_xdr_enc_getacl(struct rpc_rqst *req, __be32 *p,
 	struct xdr_stream xdr;
 	struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
 	struct compound_hdr hdr = {
-		.nops   = 2,
+		.nops   = 0,
 	};
 	int replen, status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if (status)
 		goto out;
-	status = encode_getattr_two(&xdr, FATTR4_WORD0_ACL, 0);
+	status = encode_getattr_two(&xdr, FATTR4_WORD0_ACL, 0, &hdr);
 	/* set up reply buffer: */
 	replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS4_dec_getacl_sz) << 2;
 	xdr_inline_pages(&req->rq_rcv_buf, replen,
 		args->acl_pages, args->acl_pgbase, args->acl_len);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1931,21 +2074,23 @@ static int nfs4_xdr_enc_write(struct rpc_rqst *req, __be32 *p, struct nfs_writea
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 3,
+		.nops = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if (status)
 		goto out;
-	status = encode_write(&xdr, args);
+	status = encode_write(&xdr, args, &hdr);
 	if (status)
 		goto out;
 	req->rq_snd_buf.flags |= XDRBUF_WRITE;
-	status = encode_getfattr(&xdr, args->bitmask);
+	status = encode_getfattr(&xdr, args->bitmask, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1956,20 +2101,22 @@ static int nfs4_xdr_enc_commit(struct rpc_rqst *req, __be32 *p, struct nfs_write
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 3,
+		.nops = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if (status)
 		goto out;
-	status = encode_commit(&xdr, args);
+	status = encode_commit(&xdr, args, &hdr);
 	if (status)
 		goto out;
-	status = encode_getfattr(&xdr, args->bitmask);
+	status = encode_getfattr(&xdr, args->bitmask, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1980,15 +2127,17 @@ static int nfs4_xdr_enc_fsinfo(struct rpc_rqst *req, __be32 *p, struct nfs4_fsin
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops	= 2,
+		.nops	= 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if (!status)
-		status = encode_fsinfo(&xdr, args->bitmask);
+		status = encode_fsinfo(&xdr, args->bitmask, &hdr);
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -1999,16 +2148,19 @@ static int nfs4_xdr_enc_pathconf(struct rpc_rqst *req, __be32 *p, const struct n
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 2,
+		.nops = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if (!status)
 		status = encode_getattr_one(&xdr,
-				args->bitmask[0] & nfs4_pathconf_bitmap[0]);
+				args->bitmask[0] & nfs4_pathconf_bitmap[0],
+				&hdr);
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -2019,17 +2171,19 @@ static int nfs4_xdr_enc_statfs(struct rpc_rqst *req, __be32 *p, const struct nfs
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 2,
+		.nops = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fh);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
 	if (status == 0)
 		status = encode_getattr_two(&xdr,
 				args->bitmask[0] & nfs4_statfs_bitmap[0],
-				args->bitmask[1] & nfs4_statfs_bitmap[1]);
+				args->bitmask[1] & nfs4_statfs_bitmap[1], &hdr);
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -2040,18 +2194,20 @@ static int nfs4_xdr_enc_server_caps(struct rpc_rqst *req, __be32 *p, const struc
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 2,
+		.nops = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, fhandle);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, fhandle, &hdr);
 	if (status == 0)
 		status = encode_getattr_one(&xdr, FATTR4_WORD0_SUPPORTED_ATTRS|
 				FATTR4_WORD0_LINK_SUPPORT|
 				FATTR4_WORD0_SYMLINK_SUPPORT|
-				FATTR4_WORD0_ACLSUPPORT);
+				FATTR4_WORD0_ACLSUPPORT, &hdr);
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -2062,12 +2218,16 @@ static int nfs4_xdr_enc_renew(struct rpc_rqst *req, __be32 *p, struct nfs_client
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops	= 1,
+		.nops	= 0,
 	};
+	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	return encode_renew(&xdr, clp);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_renew(&xdr, clp, &hdr);
+	encode_nops(nops, &hdr);
+	return status;
 }
 
 /*

@@ -2077,12 +2237,16 @@ static int nfs4_xdr_enc_setclientid(struct rpc_rqst *req, __be32 *p, struct nfs4
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops	= 1,
+		.nops	= 0,
 	};
+	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	return encode_setclientid(&xdr, sc);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_setclientid(&xdr, sc, &hdr);
+	encode_nops(nops, &hdr);
+	return status;
 }
 
 /*

@@ -2092,18 +2256,20 @@ static int nfs4_xdr_enc_setclientid_confirm(struct rpc_rqst *req, __be32 *p, str
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops	= 3,
+		.nops	= 0,
 	};
 	const u32 lease_bitmap[2] = { FATTR4_WORD0_LEASE_TIME, 0 };
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_setclientid_confirm(&xdr, clp);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_setclientid_confirm(&xdr, clp, &hdr);
 	if (!status)
-		status = encode_putrootfh(&xdr);
+		status = encode_putrootfh(&xdr, &hdr);
 	if (!status)
-		status = encode_fsinfo(&xdr, lease_bitmap);
+		status = encode_fsinfo(&xdr, lease_bitmap, &hdr);
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -2114,20 +2280,22 @@ static int nfs4_xdr_enc_delegreturn(struct rpc_rqst *req, __be32 *p, const struc
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 3,
+		.nops = 0,
 	};
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	status = encode_putfh(&xdr, args->fhandle);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fhandle, &hdr);
 	if (status != 0)
 		goto out;
-	status = encode_delegreturn(&xdr, args->stateid);
+	status = encode_delegreturn(&xdr, args->stateid, &hdr);
 	if (status != 0)
 		goto out;
-	status = encode_getfattr(&xdr, args->bitmask);
+	status = encode_getfattr(&xdr, args->bitmask, &hdr);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -2138,19 +2306,20 @@ static int nfs4_xdr_enc_fs_locations(struct rpc_rqst *req, __be32 *p, struct nfs
 {
 	struct xdr_stream xdr;
 	struct compound_hdr hdr = {
-		.nops = 3,
+		.nops = 0,
 	};
 	struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
 	int replen;
 	int status;
+	__be32 *nops;
 
 	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-	encode_compound_hdr(&xdr, &hdr);
-	if ((status = encode_putfh(&xdr, args->dir_fh)) != 0)
+	nops = encode_compound_hdr(&xdr, &hdr);
+	if ((status = encode_putfh(&xdr, args->dir_fh, &hdr)) != 0)
 		goto out;
-	if ((status = encode_lookup(&xdr, args->name)) != 0)
+	if ((status = encode_lookup(&xdr, args->name, &hdr)) != 0)
 		goto out;
-	if ((status = encode_fs_locations(&xdr, args->bitmask)) != 0)
+	if ((status = encode_fs_locations(&xdr, args->bitmask, &hdr)) != 0)
 		goto out;
 	/* set up reply
 	 *   toplevel_status + OP_PUTFH + status

@@ -2160,6 +2329,7 @@ static int nfs4_xdr_enc_fs_locations(struct rpc_rqst *req, __be32 *p, struct nfs
 	xdr_inline_pages(&req->rq_rcv_buf, replen, &args->page,
 			0, PAGE_SIZE);
 out:
+	encode_nops(nops, &hdr);
 	return status;
 }
 

@@ -4036,20 +4206,22 @@ out:
 static int
 nfs4_xdr_enc_setacl(struct rpc_rqst *req, __be32 *p, struct nfs_setaclargs *args)
 {
-        struct xdr_stream xdr;
-        struct compound_hdr hdr = {
-                .nops   = 2,
-        };
-        int status;
+	struct xdr_stream xdr;
+	struct compound_hdr hdr = {
+		.nops   = 0,
+	};
+	int status;
+	__be32 *nops;
 
-        xdr_init_encode(&xdr, &req->rq_snd_buf, p);
-        encode_compound_hdr(&xdr, &hdr);
-        status = encode_putfh(&xdr, args->fh);
-        if (status)
-                goto out;
-        status = encode_setacl(&xdr, args);
+	xdr_init_encode(&xdr, &req->rq_snd_buf, p);
+	nops = encode_compound_hdr(&xdr, &hdr);
+	status = encode_putfh(&xdr, args->fh, &hdr);
+	if (status)
+		goto out;
+	status = encode_setacl(&xdr, args, &hdr);
 out:
-        return status;
+	encode_nops(nops, &hdr);
+	return status;
 }
 /*
  * Decode SETACL response

index 54af92c..4dd83f2 100644
@@ -109,7 +109,24 @@
 	NFSERR_FILE_OPEN = 10046,      /*       v4 */
 	NFSERR_ADMIN_REVOKED = 10047,  /*       v4 */
 	NFSERR_CB_PATH_DOWN = 10048,   /*       v4 */
-	NFSERR_REPLAY_ME = 10049	/*       v4 */
+	NFSERR_BADIOMODE = 10049,		/* v4.1 */
+	NFSERR_BADLAYOUT = 10050,		/* v4.1 */
+	NFSERR_BAD_SESSION_DIGEST = 10051,	/* v4.1 */
+	NFSERR_BADSESSION = 10052,		/* v4.1 */
+	NFSERR_BADSLOT = 10053,			/* v4.1 */
+	NFSERR_COMPLETE_ALREADY = 10054,	/* v4.1 */
+	NFSERR_CONN_NOT_BOUND_TO_SESSION = 10055,/* v4.1 */
+	NFSERR_DELEG_ALREADY_WANTED = 10056,	/* v4.1 */
+	NFSERR_DIRDELEG_UNAVAIL = 10057,	/* v4.1 */
+	NFSERR_LAYOUTTRYLATER = 10058,		/* v4.1 */
+	NFSERR_LAYOUTUNAVAILABLE = 10059,	/* v4.1 */
+	NFSERR_NOMATCHING_LAYOUT = 10060,	/* v4.1 */
+	NFSERR_RECALLCONFLICT = 10061,		/* v4.1 */
+	NFSERR_UNKNOWN_LAYOUTTYPE = 10062,	/* v4.1 */
+	NFSERR_SEQ_MISORDERED = 10063,		/* v4.1 */
+	NFSERR_SEQUENCE_POS = 10064,		/* v4.1 */
+
+	NFSERR_REPLAY_ME = 11001,	/* linux internal */
 };
 
 /* NFSv2 file types - beware, these are not the same in NFSv3 */

161 lines not on this page · raw message

index bdcd316..a69bbfa 100644
@@ -435,6 +435,13 @@ enum lock_type4 {
 #define NFSPROC4_NULL 0
 #define NFSPROC4_COMPOUND 1
 #define NFS4_MINOR_VERSION 1
+
+#if defined(CONFIG_NFS_V4_1)
+#define NFS4_MAX_MINOR_VERSION 1
+#else
+#define NFS4_MAX_MINOR_VERSION 0
+#endif /* CONFIG_NFS_V4_1 */
+
 #define NFS4_DEBUG 1
 
 /* Index of predefined Linux client operations */

index c1c31ac..a8a0953 100644
@@ -113,6 +113,43 @@ struct nfs4_change_info {
 };
 
 struct nfs_seqid;
+
+/* Opaque session ID */
+struct sessionid4 {
+	char	data[NFS4_MAX_SESSIONID_LEN];
+};
+
+struct nfs41_sequence_args {
+	/* stub */
+};
+
+#define SEQ4_STATUS_CB_PATH_DOWN		0x00000001
+#define SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING	0x00000002
+#define SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED	0x00000004
+#define SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED	0x00000008
+#define SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED	0x00000010
+#define SEQ4_STATUS_ADMIN_STATE_REVOKED		0x00000020
+#define SEQ4_STATUS_RECALLABLE_STATE_REVOKED	0x00000040
+#define SEQ4_STATUS_LEASE_MOVED			0x00000080
+#define SEQ4_STATUS_RESTART_RECLAIM_NEEDED	0x00000100
+
+struct nfs41_sequence_res {
+	/* stub */
+};
+
+#if defined(CONFIG_NFS_V4_1)
+
+struct nfs4_get_lease_time_args {
+	struct nfs41_sequence_args	la_seq_args;
+};
+
+struct nfs4_get_lease_time_res {
+	struct nfs_fsinfo	       *lr_fsinfo;
+	struct nfs41_sequence_res	lr_seq_res;
+};
+
+#endif	/* CONFIG_NFS_V4_1 */
+
 /*
  * Arguments to the open call.
  */

@@ -132,6 +169,7 @@ struct nfs_openargs {
 	const struct nfs_server *server;	 /* Needed for ID mapping */
 	const u32 *		bitmask;
 	__u32			claim;
+	struct nfs41_sequence_args	seq_args;
 };
 
 struct nfs_openres {

@@ -148,6 +186,7 @@ struct nfs_openres {
 	__u32			do_recall;
 	__u64			maxsize;
 	__u32			attrset[NFS4_BITMAP_SIZE];
+	struct nfs41_sequence_res	seq_res;
 };
 
 /*

@@ -173,6 +212,7 @@ struct nfs_closeargs {
 	struct nfs_seqid *	seqid;
 	int			open_flags;
 	const u32 *		bitmask;
+	struct nfs41_sequence_args	seq_args;
 };
 
 struct nfs_closeres {

@@ -180,6 +220,7 @@ struct nfs_closeres {
 	struct nfs_fattr *	fattr;
 	struct nfs_seqid *	seqid;
 	const struct nfs_server *server;
+	struct nfs41_sequence_res	seq_res;
 };
 /*
  *  * Arguments to the lock,lockt, and locku call.

@@ -200,12 +241,14 @@ struct nfs_lock_args {
 	unsigned char		block : 1;
 	unsigned char		reclaim : 1;
 	unsigned char		new_lock_owner : 1;
+	struct nfs41_sequence_args	seq_args;
 };
 
 struct nfs_lock_res {
 	nfs4_stateid		stateid;
 	struct nfs_seqid *	lock_seqid;
 	struct nfs_seqid *	open_seqid;
+	struct nfs41_sequence_res	seq_res;
 };
 
 struct nfs_locku_args {

@@ -213,32 +256,38 @@ struct nfs_locku_args {
 	struct file_lock *	fl;
 	struct nfs_seqid *	seqid;
 	nfs4_stateid *		stateid;
+	struct nfs41_sequence_args	seq_args;
 };
 
 struct nfs_locku_res {
 	nfs4_stateid		stateid;
 	struct nfs_seqid *	seqid;
+	struct nfs41_sequence_res	seq_res;
 };
 
 struct nfs_lockt_args {
 	struct nfs_fh *		fh;
 	struct file_lock *	fl;
 	struct nfs_lowner	lock_owner;
+	struct nfs41_sequence_args	seq_args;
 };
 
 struct nfs_lockt_res {
 	struct file_lock *	denied; /* LOCK, LOCKT failed */
+	struct nfs41_sequence_res	seq_res;
 };
 
 struct nfs4_delegreturnargs {
 	const struct nfs_fh *fhandle;
 	const nfs4_stateid *stateid;
 	const u32 * bitmask;
+	struct nfs41_sequence_args	seq_args;
 };
 
 struct nfs4_delegreturnres {
 	struct nfs_fattr * fattr;
 	const struct nfs_server *server;
+	struct nfs41_sequence_res	seq_res;
 };
 
 /*

@@ -251,12 +300,14 @@ struct nfs_readargs {
 	__u32			count;
 	unsigned int		pgbase;
 	struct page **		pages;
+	struct nfs41_sequence_args	seq_args;
 };
 
 struct nfs_readres {
 	struct nfs_fattr *	fattr;
 	__u32			count;
 	int                     eof;
+	struct nfs41_sequence_res	seq_res;
 };
 
 /*

@@ -271,6 +322,7 @@ struct nfs_writeargs {
 	unsigned int		pgbase;
 	struct page **		pages;
 	const u32 *		bitmask;
+	struct nfs41_sequence_args	seq_args;
 };
 
 struct nfs_writeverf {

@@ -283,6 +335,7 @@ struct nfs_writeres {
 	struct nfs_writeverf *	verf;
 	__u32			count;
 	const struct nfs_server *server;
+	struct nfs41_sequence_res	seq_res;
 };
 
 /*

@@ -292,12 +345,14 @@ struct nfs_removeargs {
 	const struct nfs_fh	*fh;
 	struct qstr		name;
 	const u32 *		bitmask;
+	struct nfs41_sequence_args	seq_args;
 };
 
 struct nfs_removeres {
 	const struct nfs_server *server;
 	struct nfs4_change_info	cinfo;
 	struct nfs_fattr	dir_attr;
+	struct nfs41_sequence_res 	seq_res;
 };
 
 /*

@@ -350,6 +405,7 @@ struct nfs_setattrargs {
 	struct iattr *                  iap;
 	const struct nfs_server *	server; /* Needed for name mapping */
 	const u32 *			bitmask;
+	struct nfs41_sequence_args 	seq_args;
 };
 
 struct nfs_setaclargs {

@@ -357,6 +413,11 @@ struct nfs_setaclargs {
 	size_t				acl_len;
 	unsigned int			acl_pgbase;
 	struct page **			acl_pages;
+	struct nfs41_sequence_args	seq_args;
+};
+
+struct nfs_setaclres {
+	struct nfs41_sequence_res	seq_res;
 };
 
 struct nfs_getaclargs {

@@ -364,11 +425,18 @@ struct nfs_getaclargs {
 	size_t				acl_len;
 	unsigned int			acl_pgbase;
 	struct page **			acl_pages;
+	struct nfs41_sequence_args 	seq_args;
+};
+
+struct nfs_getaclres {
+	size_t				*acl_len;
+	struct nfs41_sequence_res	seq_res;
 };
 
 struct nfs_setattrres {
 	struct nfs_fattr *              fattr;
 	const struct nfs_server *	server;
+	struct nfs41_sequence_res	seq_res;
 };
 
 struct nfs_linkargs {

@@ -548,6 +616,7 @@ struct nfs4_accessargs {
 	const struct nfs_fh *		fh;
 	const u32 *			bitmask;
 	u32				access;
+	struct nfs41_sequence_args	seq_args;
 };
 
 struct nfs4_accessres {

@@ -555,6 +624,7 @@ struct nfs4_accessres {
 	struct nfs_fattr *		fattr;
 	u32				supported;
 	u32				access;
+	struct nfs41_sequence_res	seq_res;
 };
 
 struct nfs4_create_arg {

@@ -574,6 +644,7 @@ struct nfs4_create_arg {
 	const struct iattr *		attrs;
 	const struct nfs_fh *		dir_fh;
 	const u32 *			bitmask;
+	struct nfs41_sequence_args 	seq_args;
 };
 
 struct nfs4_create_res {

@@ -582,21 +653,30 @@ struct nfs4_create_res {
 	struct nfs_fattr *		fattr;
 	struct nfs4_change_info		dir_cinfo;
 	struct nfs_fattr *		dir_fattr;
+	struct nfs41_sequence_res	seq_res;
 };
 
 struct nfs4_fsinfo_arg {
 	const struct nfs_fh *		fh;
 	const u32 *			bitmask;
+	struct nfs41_sequence_args	seq_args;
+};
+
+struct nfs4_fsinfo_res {
+	struct nfs_fsinfo	       *fsinfo;
+	struct nfs41_sequence_res	seq_res;
 };
 
 struct nfs4_getattr_arg {
 	const struct nfs_fh *		fh;
 	const u32 *			bitmask;
+	struct nfs41_sequence_args	seq_args;
 };
 
 struct nfs4_getattr_res {
 	const struct nfs_server *	server;
 	struct nfs_fattr *		fattr;
+	struct nfs41_sequence_res	seq_res;
 };
 
 struct nfs4_link_arg {

@@ -604,6 +684,7 @@ struct nfs4_link_arg {
 	const struct nfs_fh *		dir_fh;
 	const struct qstr *		name;
 	const u32 *			bitmask;
+	struct nfs41_sequence_args 	seq_args;
 };
 
 struct nfs4_link_res {

@@ -611,6 +692,7 @@ struct nfs4_link_res {
 	struct nfs_fattr *		fattr;
 	struct nfs4_change_info		cinfo;
 	struct nfs_fattr *		dir_attr;
+	struct nfs41_sequence_res	seq_res;
 };
 
 

@@ -618,21 +700,30 @@ struct nfs4_lookup_arg {
 	const struct nfs_fh *		dir_fh;
 	const struct qstr *		name;
 	const u32 *			bitmask;
+	struct nfs41_sequence_args	seq_args;
 };
 
 struct nfs4_lookup_res {
 	const struct nfs_server *	server;
 	struct nfs_fattr *		fattr;
 	struct nfs_fh *			fh;
+	struct nfs41_sequence_res	seq_res;
 };
 
 struct nfs4_lookup_root_arg {
 	const u32 *			bitmask;
+	struct nfs41_sequence_args	seq_args;
 };
 
 struct nfs4_pathconf_arg {
 	const struct nfs_fh *		fh;
 	const u32 *			bitmask;
+	struct nfs41_sequence_args	seq_args;
+};
+
+struct nfs4_pathconf_res {
+	struct nfs_pathconf	       *pathconf;
+	struct nfs41_sequence_res	seq_res;
 };
 
 struct nfs4_readdir_arg {

@@ -643,11 +734,13 @@ struct nfs4_readdir_arg {
 	struct page **			pages;	/* zero-copy data */
 	unsigned int			pgbase;	/* zero-copy data */
 	const u32 *			bitmask;
+	struct nfs41_sequence_args	seq_args;
 };
 
 struct nfs4_readdir_res {
 	nfs4_verifier			verifier;
 	unsigned int			pgbase;
+	struct nfs41_sequence_res	seq_res;
 };
 
 struct nfs4_readlink {

@@ -655,6 +748,11 @@ struct nfs4_readlink {
 	unsigned int			pgbase;
 	unsigned int			pglen;   /* zero-copy data */
 	struct page **			pages;   /* zero-copy data */
+	struct nfs41_sequence_args	seq_args;
+};
+
+struct nfs4_readlink_res {
+	struct nfs41_sequence_res	seq_res;
 };
 
 struct nfs4_rename_arg {

@@ -663,6 +761,7 @@ struct nfs4_rename_arg {
 	const struct qstr *		old_name;
 	const struct qstr *		new_name;
 	const u32 *			bitmask;
+	struct nfs41_sequence_args	seq_args;
 };
 
 struct nfs4_rename_res {

@@ -671,6 +770,7 @@ struct nfs4_rename_res {
 	struct nfs_fattr *		old_fattr;
 	struct nfs4_change_info		new_cinfo;
 	struct nfs_fattr *		new_fattr;
+	struct nfs41_sequence_res	seq_res;
 };
 
 #define NFS4_SETCLIENTID_NAMELEN	(127)

@@ -689,6 +789,17 @@ struct nfs4_setclientid {
 struct nfs4_statfs_arg {
 	const struct nfs_fh *		fh;
 	const u32 *			bitmask;
+	struct nfs41_sequence_args	seq_args;
+};
+
+struct nfs4_statfs_res {
+	struct nfs_fsstat	       *fsstat;
+	struct nfs41_sequence_res	seq_res;
+};
+
+struct nfs4_server_caps_arg {
+	struct nfs_fh		       *fhandle;
+	struct nfs41_sequence_args	seq_args;
 };
 
 struct nfs4_server_caps_res {

@@ -696,6 +807,7 @@ struct nfs4_server_caps_res {
 	u32				acl_bitmask;
 	u32				has_links;
 	u32				has_symlinks;
+	struct nfs41_sequence_res	seq_res;
 };
 
 struct nfs4_string {

@@ -730,6 +842,12 @@ struct nfs4_fs_locations_arg {
 	const struct qstr *name;
 	struct page *page;
 	const u32 *bitmask;
+	struct nfs41_sequence_args	seq_args;
+};
+
+struct nfs4_fs_locations_res {
+	struct nfs4_fs_locations       *fs_locations;
+	struct nfs41_sequence_res	seq_res;
 };
 
 #endif /* CONFIG_NFS_V4 */

index d212ee4..b423422 100644
@@ -41,6 +41,7 @@ struct nfs_parsed_mount_data {
 	unsigned int		auth_flavor_len;
 	rpc_authflavor_t	auth_flavors[1];
 	char			*client_address;
+	unsigned int		minorversion;
 
 	struct {
 		struct sockaddr_storage	address;

index f48db67..03f143d 100644
@@ -87,6 +87,7 @@ enum {
 	Opt_mountport,
 	Opt_mountvers,
 	Opt_nfsvers,
+	Opt_minorversion,
 
 	/* Mount options that take string arguments */
 	Opt_sec, Opt_proto, Opt_mountproto, Opt_mounthost,

@@ -146,6 +147,7 @@ static const match_table_t nfs_mount_option_tokens = {
 	{ Opt_mountvers, "mountvers=%u" },
 	{ Opt_nfsvers, "nfsvers=%u" },
 	{ Opt_nfsvers, "vers=%u" },
+	{ Opt_minorversion, "minorversion=%u" },
 
 	{ Opt_sec, "sec=%s" },
 	{ Opt_proto, "proto=%s" },

@@ -1160,6 +1162,13 @@ static int nfs_parse_mount_options(char *raw,
 				nfs_parse_invalid_value("nfsvers");
 			}
 			break;
+		case Opt_minorversion:
+			if (match_int(args, &option))
+				return 0;
+			if (option < 0 || option > NFS4_MAX_MINOR_VERSION)
+				return 0;
+			mnt->minorversion = option;
+			break;
 
 		/*
 		 * options that take text values

@@ -2208,6 +2217,7 @@ static int nfs4_validate_mount_data(void *options,
 	args->nfs_server.port	= NFS_PORT; /* 2049 unless user set port= */
 	args->auth_flavors[0]	= RPC_AUTH_UNIX;
 	args->auth_flavor_len	= 0;
+	args->minorversion	= NFS4_MAX_MINOR_VERSION;
 
 	switch (data->version) {
 	case 1:

index 7547600..fe0bac9 100644
@@ -1112,6 +1112,8 @@ struct nfs_server *nfs4_create_server(const struct nfs_parsed_mount_data *data,
 	if (!server)
 		return ERR_PTR(-ENOMEM);
 
+	server->minorversion = data->minorversion;
+
 	/* set up the general RPC client */
 	error = nfs4_init_server(server, data);
 	if (error < 0)

index 4e477ae..bfc83cc 100644
@@ -115,6 +115,7 @@ struct nfs_server {
 	u32			acl_bitmask;	/* V4 bitmask representing the ACEs
 						   that are supported on this
 						   filesystem */
+	u32			minorversion;
 #endif
 	void (*destroy)(struct nfs_server *);
 

index fe0bac9..c6e9b4e 100644
@@ -1030,6 +1030,7 @@ static int nfs4_set_client(struct nfs_server *server,
 		error = PTR_ERR(clp);
 		goto error;
 	}
+	clp->cl_minorversion = server->minorversion;
 	error = nfs4_init_client(clp, timeparms, ip_addr, authflavour);
 	if (error < 0)
 		goto error_put;

index bfc83cc..8379dd5 100644
@@ -69,7 +69,8 @@ struct nfs_client {
 	 */
 	char			cl_ipaddr[48];
 	unsigned char		cl_id_uniquifier;
-#endif
+	u32			cl_minorversion;
+#endif /* CONFIG_NFS_V4 */
 };
 
 /*

index c6e9b4e..7bc150b 100644
@@ -359,7 +359,8 @@ static struct nfs_client *nfs_get_client(const struct nfs_client_initdata *cl_in
 	int error;
 
 	dprintk("--> nfs_get_client(%s,v%u)\n",
-		cl_init->hostname ?: "", cl_init->rpc_ops->version);
+		cl_init->hostname ?: "",
+		cl_init->rpc_ops ? cl_init->rpc_ops->version : 0);
 
 	/* see if the client already exists */
 	do {

@@ -976,7 +977,7 @@ static int nfs4_init_client(struct nfs_client *clp,
 	}
 
 	/* Check NFS protocol revision and initialize RPC op vector */
-	clp->rpc_ops = &nfs_v4_clientops;
+	clp->rpc_ops = nfsv4_minorversion_clientops[clp->cl_minorversion];
 
 	error = nfs_create_rpc_client(clp, timeparms, authflavour,
 					RPC_CLNT_CREATE_DISCRTRY);

@@ -1016,7 +1017,6 @@ static int nfs4_set_client(struct nfs_server *server,
 		.hostname = hostname,
 		.addr = addr,
 		.addrlen = addrlen,
-		.rpc_ops = &nfs_v4_clientops,
 		.proto = proto,
 	};
 	struct nfs_client *clp;

61 lines not on this page · raw message

index a8a0953..1d6f09a 100644
@@ -966,6 +966,9 @@ struct nfs_rpc_ops {
 extern const struct nfs_rpc_ops	nfs_v2_clientops;
 extern const struct nfs_rpc_ops	nfs_v3_clientops;
 extern const struct nfs_rpc_ops	nfs_v4_clientops;
+extern const struct nfs_rpc_ops	nfs_v40_clientops;
+extern const struct nfs_rpc_ops	nfs_v41_clientops;
+extern const struct nfs_rpc_ops	*nfsv4_minorversion_clientops[];
 extern struct rpc_version	nfs_version2;
 extern struct rpc_version	nfs_version3;
 extern struct rpc_version	nfs_version4;

index b423422..8386e99 100644
@@ -134,11 +134,6 @@ extern __be32 *nfs3_decode_dirent(__be32 *, struct nfs_entry *, int);
 extern __be32 *nfs4_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus);
 #endif
 
-/* nfs4proc.c */
-#ifdef CONFIG_NFS_V4
-extern struct rpc_procinfo nfs4_procedures[];
-#endif
-
 /* dir.c */
 extern int nfs_access_cache_shrinker(int nr_to_scan, gfp_t gfp_mask);
 

index ea79064..5fb7382 100644
@@ -226,7 +226,6 @@ extern const nfs4_stateid zero_stateid;
 
 /* nfs4xdr.c */
 extern __be32 *nfs4_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus);
-extern struct rpc_procinfo nfs4_procedures[];
 
 struct nfs4_mount_data;
 

320 lines not on this page · raw message

index c1ff9c9..30addf4 100644
@@ -4922,11 +4922,25 @@ struct rpc_procinfo	nfs4_procedures[] = {
   PROC(FS_LOCATIONS,	enc_fs_locations, dec_fs_locations),
 };
 
-struct rpc_version		nfs_version4 = {
-	.number			= 4,
-	.nrprocs		= ARRAY_SIZE(nfs4_procedures),
-	.procs			= nfs4_procedures
+#if defined(CONFIG_NFS_V4_1)
+struct rpc_procinfo	nfs41_procedures[] = {
 };
+#endif /* CONFIG_NFS_V4_1 */
+
+struct rpc_version      nfs_version4 = {
+	.number                 = 4,
+	.nrprocs                = ARRAY_SIZE(nfs4_procedures),
+	.procs                  = nfs4_procedures
+};
+
+#ifdef CONFIG_NFS_V4_1
+struct rpc_version      nfs_version41 = {
+	.number                 = 4,
+	.nrprocs                = ARRAY_SIZE(nfs41_procedures),
+	.procs                  = nfs41_procedures
+};
+
+#endif /* CONFIG_NFS_V4_1 */
 
 /*
  * Local variables:

index 8379dd5..c5cb574 100644
@@ -73,6 +73,15 @@ struct nfs_client {
 #endif /* CONFIG_NFS_V4 */
 };
 
+#ifdef CONFIG_NFS_V4
+static inline struct rpc_procinfo *
+nfs4_proc(struct nfs_client *clp, int idx)
+{
+	struct rpc_procinfo *procs = clp->cl_rpcclient->cl_procinfo;
+	return &procs[idx];
+}
+#endif /* CONFIG_NFS_V4 */
+
 /*
  * NFS client parameters stored in the superblock.
  */

index 1d6f09a..743b5ac 100644
@@ -969,6 +969,9 @@ extern const struct nfs_rpc_ops	nfs_v4_clientops;
 extern const struct nfs_rpc_ops	nfs_v40_clientops;
 extern const struct nfs_rpc_ops	nfs_v41_clientops;
 extern const struct nfs_rpc_ops	*nfsv4_minorversion_clientops[];
+extern struct rpc_version *nfs4_minorversions[];
+extern struct rpc_procinfo *nfs4_minorversion_procedures[];
+
 extern struct rpc_version	nfs_version2;
 extern struct rpc_version	nfs_version3;
 extern struct rpc_version	nfs_version4;

index 7bc150b..4e8c641 100644
@@ -56,7 +56,10 @@ static DECLARE_WAIT_QUEUE_HEAD(nfs_client_active_wq);
 /*
  * RPC cruft for NFS
  */
-static struct rpc_version *nfs_version[5] = {
+#define NFS_MAXVERSION	4
+
+static struct rpc_version *nfs_version[(NFS_MAXVERSION + 1) *
+				       (NFS4_MAX_MINOR_VERSION + 1)] = {
 	[2]			= &nfs_version2,
 #ifdef CONFIG_NFS_V3
 	[3]			= &nfs_version3,

@@ -64,12 +67,16 @@ static struct rpc_version *nfs_version[5] = {
 #ifdef CONFIG_NFS_V4
 	[4]			= &nfs_version4,
 #endif
+#ifdef CONFIG_NFS_V4_1
+	[(NFS_MAXVERSION + 1) + 4] = &nfs_version41,
+#endif /* CONFIG_NFS_V4_1 */
 };
 
 struct rpc_program nfs_program = {
 	.name			= "nfs",
 	.number			= NFS_PROGRAM,
-	.nrvers			= ARRAY_SIZE(nfs_version),
+	.nrvers			= NFS_MAXVERSION + 1,
+	.nrminorvers		= NFS4_MAX_MINOR_VERSION + 1,
 	.version		= nfs_version,
 	.stats			= &nfs_rpcstat,
 	.pipe_dir_name		= "/nfs",

@@ -482,6 +489,9 @@ static int nfs_create_rpc_client(struct nfs_client *clp,
 		.servername	= clp->cl_hostname,
 		.program	= &nfs_program,
 		.version	= clp->rpc_ops->version,
+#ifdef CONFIG_NFS_V4
+		.minorversion	= clp->cl_minorversion,
+#endif /* CONFIG_NFS_V4 */
 		.authflavor	= flavor,
 		.flags		= flags,
 	};

@@ -550,7 +560,7 @@ static void nfs_init_server_aclclient(struct nfs_server *server)
 	if (server->flags & NFS_MOUNT_NOACL)
 		goto out_noacl;
 
-	server->client_acl = rpc_bind_new_program(server->client, &nfsacl_program, 3);
+	server->client_acl = rpc_bind_new_program(server->client, &nfsacl_program, 3, 0);
 	if (IS_ERR(server->client_acl))
 		goto out_noacl;
 

@@ -970,6 +980,7 @@ static int nfs4_init_client(struct nfs_client *clp,
 {
 	int error;
 
+	dprintk("--> nfs4_init_client minorversion %u\n", clp->cl_minorversion);
 	if (clp->cl_cons_state == NFS_CS_READY) {
 		/* the client is initialised already */
 		dprintk("<-- nfs4_init_client() = 0 [already %p]\n", clp);

index 743b5ac..b401477 100644
@@ -975,6 +975,9 @@ extern struct rpc_procinfo *nfs4_minorversion_procedures[];
 extern struct rpc_version	nfs_version2;
 extern struct rpc_version	nfs_version3;
 extern struct rpc_version	nfs_version4;
+#if defined(CONFIG_NFS_V4_1)
+extern struct rpc_version	nfs_version41;
+#endif /* CONFIG_NFS_V4_1 */
 
 extern struct rpc_version	nfsacl_version3;
 extern struct rpc_program	nfsacl_program;

index 6f0ee1b..99d4f9e 100644
@@ -68,11 +68,18 @@ struct rpc_program {
 	char *			name;		/* protocol name */
 	u32			number;		/* program number */
 	unsigned int		nrvers;		/* number of versions */
+	unsigned int		nrminorvers;	/* number of minor versions */
 	struct rpc_version **	version;	/* version array */
 	struct rpc_stat *	stats;		/* statistics */
 	char *			pipe_dir_name;	/* path to rpc_pipefs dir */
 };
 
+static inline struct rpc_version *
+get_rpc_version(struct rpc_program *prog, u32 vers, int minorvers)
+{
+	return prog->version[minorvers * prog->nrvers + vers];
+}
+
 struct rpc_version {
 	u32			number;		/* version number */
 	unsigned int		nrprocs;	/* number of procs */

@@ -106,6 +113,7 @@ struct rpc_create_args {
 	struct rpc_program	*program;
 	u32			prognumber;	/* overrides program->number */
 	u32			version;
+	unsigned char		minorversion;
 	rpc_authflavor_t	authflavor;
 	unsigned long		flags;
 };

@@ -120,7 +128,7 @@ struct rpc_create_args {
 
 struct rpc_clnt *rpc_create(struct rpc_create_args *args);
 struct rpc_clnt	*rpc_bind_new_program(struct rpc_clnt *,
-				struct rpc_program *, u32);
+				struct rpc_program *, u32, int minorversion);
 struct rpc_clnt *rpc_clone_client(struct rpc_clnt *);
 void		rpc_shutdown_client(struct rpc_clnt *);
 void		rpc_release_client(struct rpc_clnt *);

index 4895c34..44f251d 100644
@@ -148,9 +148,10 @@ static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args, stru
 	if (!xprt)
 		goto out_no_xprt;
 
-	if (args->version >= program->nrvers)
+	if (args->version >= program->nrvers ||
+	    (args->minorversion && args->minorversion >= program->nrminorvers))
 		goto out_err;
-	version = program->version[args->version];
+	version = get_rpc_version(program, args->version, args->minorversion);
 	if (version == NULL)
 		goto out_err;
 

@@ -472,14 +473,16 @@ rpc_release_client(struct rpc_clnt *clnt)
  */
 struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *old,
 				      struct rpc_program *program,
-				      u32 vers)
+				      u32 vers, int minorversion)
 {
 	struct rpc_clnt *clnt;
 	struct rpc_version *version;
 	int err;
 
-	BUG_ON(vers >= program->nrvers || !program->version[vers]);
-	version = program->version[vers];
+	BUG_ON(vers >= program->nrvers ||
+	       (minorversion && minorversion >= program->nrminorvers) ||
+	       !get_rpc_version(program, vers, minorversion));
+	version = get_rpc_version(program, vers, minorversion);
 	clnt = rpc_clone_client(old);
 	if (IS_ERR(clnt))
 		goto out;

index 4e8c641..11c845d 100644
@@ -1028,6 +1028,8 @@ static int nfs4_set_client(struct nfs_server *server,
 		.hostname = hostname,
 		.addr = addr,
 		.addrlen = addrlen,
+		.rpc_ops =
+			nfsv4_minorversion_clientops[server->minorversion],
 		.proto = proto,
 	};
 	struct nfs_client *clp;

index ef3370f..f87d4de 100644
@@ -2802,6 +2802,8 @@ static int nfs4_wait_clnt_recover(struct rpc_clnt *clnt, struct nfs_client *clp)
 
 	res = wait_on_bit(&clp->cl_state, NFS4CLNT_STATE_RECOVER,
 			nfs4_wait_bit_killable, TASK_KILLABLE);
+	if (!res)
+		res = clp->cl_recovery_status;
 
 	rwsem_release(&clp->cl_sem.dep_map, 1, _RET_IP_);
 	return res;

index c391caf..09ca7b1 100644
@@ -814,8 +814,10 @@ void nfs4_schedule_state_recovery(struct nfs_client *clp)
 {
 	if (!clp)
 		return;
-	if (test_and_set_bit(NFS4CLNT_STATE_RECOVER, &clp->cl_state) == 0)
+	if (test_and_set_bit(NFS4CLNT_STATE_RECOVER, &clp->cl_state) == 0) {
+		clp->cl_recovery_status = 0;
 		nfs4_recover_state(clp);
+	}
 }
 
 static int nfs4_reclaim_locks(struct nfs4_state_recovery_ops *ops, struct nfs4_state *state)

@@ -1018,6 +1020,7 @@ out:
 out_error:
 	printk(KERN_WARNING "Error: state recovery failed on NFSv4 server %s"
 			" with error %d\n", clp->cl_hostname, -status);
+	clp->cl_recovery_status = status;
 	set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
 	goto out;
 }

index c5cb574..80e0fc3 100644
@@ -38,6 +38,7 @@ struct nfs_client {
 	u64			cl_clientid;	/* constant */
 	nfs4_verifier		cl_confirm;
 	unsigned long		cl_state;
+	int			cl_recovery_status;
 
 	struct rb_root		cl_openowner_id;
 	struct rb_root		cl_lockowner_id;

index 11c845d..0a8a082 100644
@@ -1118,15 +1118,17 @@ struct nfs_server *nfs4_create_server(const struct nfs_parsed_mount_data *data,
 {
 	struct nfs_fattr fattr;
 	struct nfs_server *server;
+	int minorvers = data->minorversion;
 	int error;
 
 	dprintk("--> nfs4_create_server()\n");
 
+retry:
 	server = nfs_alloc_server();
 	if (!server)
 		return ERR_PTR(-ENOMEM);
 
-	server->minorversion = data->minorversion;
+	server->minorversion = minorvers;
 
 	/* set up the general RPC client */
 	error = nfs4_init_server(server, data);

@@ -1168,7 +1170,15 @@ struct nfs_server *nfs4_create_server(const struct nfs_parsed_mount_data *data,
 	return server;
 
 error:
+	if (server->nfs_client && server->nfs_client->cl_recovery_status)
+		error = server->nfs_client->cl_recovery_status;
 	nfs_free_server(server);
+	if (minorvers > 0 && error == -NFS4ERR_MINOR_VERS_MISMATCH) {
+		minorvers--;
+		dprintk("%s: error %d retrying with minorvers=%d\n",
+			__func__, error, minorvers);
+		goto retry;
+	}
 	dprintk("<-- nfs4_create_server() = error %d\n", error);
 	return ERR_PTR(error);
 }

index 0a8a082..80091dc 100644
@@ -37,6 +37,9 @@
 #include <linux/in6.h>
 #include <net/ipv6.h>
 #include <linux/nfs_xdr.h>
+#if defined(CONFIG_NFS_V4_1)
+#include <linux/nfs4_session.h>
+#endif /* CONFIG_NFS_V4_1 */
 
 #include <asm/system.h>
 

@@ -884,6 +887,11 @@ void nfs_free_server(struct nfs_server *server)
 	list_del(&server->master_link);
 	spin_unlock(&nfs_client_lock);
 
+#ifdef CONFIG_NFS_V4_1
+	if (server->nfs_client->cl_session != NULL)
+		nfs4_put_session(&server->nfs_client->cl_session);
+#endif /* CONFIG_NFS_V4_1 */
+
 	if (server->destroy != NULL)
 		server->destroy(server);
 

@@ -1110,6 +1118,34 @@ error:
 }
 
 /*
+ * Allocate and initialize a session if required
+ */
+int nfs4_init_session(struct nfs_client *clp, struct rpc_clnt *clnt)
+{
+	int error = 0;
+
+#if defined(CONFIG_NFS_V4_1)
+	if (clp->cl_minorversion) {
+		struct nfs4_session *session = NULL;
+		/*
+		 * Create the session and mark it expired.
+		 * When a SEQUENCE operation encounters the expired session
+		 * it will do session recovery to initialize it.
+		 */
+		session = nfs4_alloc_session();
+		if (!session)
+			error = -ENOMEM;
+		else {
+			session->clnt = clnt;
+			session->clp = clp;
+		}
+		clp->cl_session = session;
+	}
+#endif /* CONFIG_NFS_V4_1 */
+	return error;
+}
+
+/*
  * Create a version 4 volume record
  * - keyed on server and FSID
  */

@@ -1139,6 +1175,10 @@ retry:
 	BUG_ON(!server->nfs_client->rpc_ops);
 	BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
 
+	error = nfs4_init_session(server->nfs_client, server->client);
+	if (error)
+		goto error;
+
 	/* Probe the root fh to retrieve its FSID */
 	error = nfs4_path_walk(server, mntfh, data->nfs_server.export_path);
 	if (error < 0)

index 8386e99..9b2228f 100644
@@ -82,6 +82,7 @@ extern void nfs_free_server(struct nfs_server *server);
 extern struct nfs_server *nfs_clone_server(struct nfs_server *,
 					   struct nfs_fh *,
 					   struct nfs_fattr *);
+extern int nfs4_init_session(struct nfs_client *clp, struct rpc_clnt *clnt);
 #ifdef CONFIG_PROC_FS
 extern int __init nfs_fs_proc_init(void);
 extern void nfs_fs_proc_exit(void);

index 5fb7382..4b13945 100644
@@ -188,6 +188,10 @@ extern int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name,
 
 extern struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops;
 extern struct nfs4_state_recovery_ops nfs4_network_partition_recovery_ops;
+#if defined(CONFIG_NFS_V4_1)
+extern void nfs4_put_session(struct nfs4_session **session);
+extern struct nfs4_session *nfs4_alloc_session(void);
+#endif /* CONFIG_NFS_V4_1 */
 
 extern const u32 nfs4_fattr_bitmap[2];
 extern const u32 nfs4_statfs_bitmap[2];

index f87d4de..8e373e9 100644
@@ -53,6 +53,9 @@
 #include "delegation.h"
 #include "internal.h"
 #include "iostat.h"
+#if defined(CONFIG_NFS_V4_1)
+#include <linux/nfs4_session.h>
+#endif /* CONFIG_NFS_V4_1 */
 
 #define NFSDBG_FACILITY		NFSDBG_PROC
 

@@ -3679,6 +3682,38 @@ int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name,
 	return status;
 }
 
+#ifdef CONFIG_NFS_V4_1
+struct nfs4_session *nfs4_alloc_session(void)
+{
+	struct nfs4_session *session;
+
+	session = kzalloc(sizeof(struct nfs4_session), GFP_ATOMIC);
+	if (!session)
+		return NULL;
+
+	atomic_set(&session->ref_count, 1);
+
+	return session;
+}
+
+static void nfs4_free_session(struct nfs4_session *session)
+{
+	dprintk("%s: freeing session %p\n", __func__, session);
+	kfree(session);
+}
+
+void nfs4_put_session(struct nfs4_session **session)
+{
+	dprintk("--> nfs4_put_session()\n");
+	if (atomic_dec_and_test(&((*session)->ref_count))) {
+		nfs4_free_session(*session);
+		*session = NULL;
+	}
+	dprintk("<-- nfs4_put_session()\n");
+}
+
+#endif /* CONFIG_NFS_V4_1 */
+
 struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops = {
 	.recover_open	= nfs4_open_reclaim,
 	.recover_lock	= nfs4_lock_reclaim,

45 lines not on this page · raw message

index 80e0fc3..15c0aa5 100644
@@ -7,6 +7,7 @@
 
 #include <asm/atomic.h>
 
+struct nfs4_session;
 struct nfs_iostats;
 struct nlm_host;
 

@@ -72,6 +73,10 @@ struct nfs_client {
 	unsigned char		cl_id_uniquifier;
 	u32			cl_minorversion;
 #endif /* CONFIG_NFS_V4 */
+
+#ifdef CONFIG_NFS_V4_1
+	struct nfs4_session	*cl_session; 	/* sharred session */
+#endif /* CONFIG_NFS_V4_1 */
 };
 
 #ifdef CONFIG_NFS_V4

index 80091dc..62bdf31 100644
@@ -1336,6 +1336,10 @@ struct nfs_server *nfs_clone_server(struct nfs_server *source,
 	if (!IS_ERR(source->client_acl))
 		nfs_init_server_aclclient(server);
 
+#ifdef CONFIG_NFS_V4_1
+	nfs4_get_session(server->nfs_client);
+#endif /* CONFIG_NFS_V4_1 */
+
 	/* probe the filesystem info for this server filesystem */
 	error = nfs_probe_fsinfo(server, fh, &fattr_fsinfo);
 	if (error < 0)

index 4b13945..a28427f 100644
@@ -190,6 +190,7 @@ extern struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops;
 extern struct nfs4_state_recovery_ops nfs4_network_partition_recovery_ops;
 #if defined(CONFIG_NFS_V4_1)
 extern void nfs4_put_session(struct nfs4_session **session);
+extern void nfs4_get_session(struct nfs_client *clp);
 extern struct nfs4_session *nfs4_alloc_session(void);
 #endif /* CONFIG_NFS_V4_1 */
 

index 8e373e9..d0b6ca1 100644
@@ -3712,6 +3712,11 @@ void nfs4_put_session(struct nfs4_session **session)
 	dprintk("<-- nfs4_put_session()\n");
 }
 
+void nfs4_get_session(struct nfs_client *clp)
+{
+	if (clp->cl_minorversion == 1)
+		atomic_inc(&clp->cl_session->ref_count);
+}
 #endif /* CONFIG_NFS_V4_1 */
 
 struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops = {

index d0b6ca1..08e7129 100644
@@ -3683,6 +3683,92 @@ int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name,
 }
 
 #ifdef CONFIG_NFS_V4_1
+/*
+ * Initialize slot table
+ *
+ * Note: the "used" bitmap points to _used_slots id max_slots <= BITS_PER_LONG.
+ * Otherwise, we dynamically allocate enough ulongs to hold max_slots bits.
+ */
+static int nfs4_init_slot_table(struct nfs4_channel *channel)
+{
+	struct nfs4_slot_table *tbl = &channel->slot_table;
+	int i, max_slots = channel->chan_attrs.max_reqs;
+	struct nfs4_slot *slot;
+	unsigned long *used;
+	int ret = -ENOMEM;
+
+	dprintk("--> %s: max_reqs=%u\n", __func__,
+		channel->chan_attrs.max_reqs);
+	slot = kzalloc(max_slots * sizeof(struct nfs4_slot), GFP_ATOMIC);
+	if (!slot)
+		goto out;
+	for (i = 0; i < max_slots; ++i)
+		slot[i].seq_nr = 1;
+
+	if (max_slots <= BITS_PER_LONG)
+		used = &tbl->_used_slots;	/* use word in tbl */
+	else {
+		/* allocate enough unsigned longs for max_slots bits */
+		used = kzalloc(sizeof(unsigned long) *
+				DIV_ROUND_UP(max_slots, BITS_PER_LONG),
+			       GFP_ATOMIC);
+		if (!used)
+			goto out_free;
+	}
+	ret = 0;
+
+	spin_lock(&tbl->slot_tbl_lock);
+	if (tbl->slots != NULL) {
+		spin_unlock(&tbl->slot_tbl_lock);
+		dprintk("%s: slot table already initialized. tbl=%p slots=%p\n",
+			__func__, tbl, tbl->slots);
+		WARN_ON(1);
+		goto out_free;
+	}
+	tbl->max_slots = max_slots;
+	tbl->slots = slot;
+	tbl->used_slots = used;
+	tbl->lowest_free_slotid = 0;	/* first slot is free */
+	tbl->highest_used_slotid = -1;	/* no slot is currently used */
+	spin_unlock(&tbl->slot_tbl_lock);
+	dprintk("%s: tbl=%p slots=%p max_slots=%d\n", __func__,
+		tbl, tbl->slots, tbl->max_slots);
+out:
+	dprintk("<-- %s: return %d\n", __func__, ret);
+	return ret;
+out_free:
+	kfree(slot);
+	if (used != &tbl->_used_slots)
+		kfree(used);
+	goto out;
+}
+
+/* Destroy the slot table */
+static void nfs4_destroy_slot_table(struct nfs4_channel *channel)
+{
+	if (channel->slot_table.slots == NULL)
+		return;
+	kfree(channel->slot_table.slots);
+	channel->slot_table.slots = NULL;
+	/* Was the "used" bitmap dynamically allocated? */
+	if (channel->slot_table.used_slots != &channel->slot_table._used_slots)
+		kfree(channel->slot_table.used_slots);
+
+	return;
+}
+
+static int nfs4_init_channel(struct nfs4_channel *channel)
+{
+	struct nfs4_slot_table *tbl;
+
+	tbl = &channel->slot_table;
+
+	spin_lock_init(&tbl->slot_tbl_lock);
+	rpc_init_wait_queue(&tbl->slot_tbl_waitq, "Slot table");
+
+	return 0;
+}
+
 struct nfs4_session *nfs4_alloc_session(void)
 {
 	struct nfs4_session *session;

@@ -3693,6 +3779,7 @@ struct nfs4_session *nfs4_alloc_session(void)
 
 	atomic_set(&session->ref_count, 1);
 
+	nfs4_init_channel(&session->fore_channel);
 	return session;
 }
 

@@ -3706,6 +3793,7 @@ void nfs4_put_session(struct nfs4_session **session)
 {
 	dprintk("--> nfs4_put_session()\n");
 	if (atomic_dec_and_test(&((*session)->ref_count))) {
+		nfs4_destroy_slot_table(&((*session)->fore_channel));
 		nfs4_free_session(*session);
 		*session = NULL;
 	}

index 36c0f94..d534269 100644
@@ -17,9 +17,26 @@ struct nfs4_channel_attrs {
 	u32			rdma_attrs;
 };
 
+struct nfs4_slot {
+	u32		 	seq_nr;
+};
+
+struct nfs4_slot_table {
+	struct nfs4_slot *slots;		/* seqid per slot */
+	unsigned long	*used_slots;		/* used/unused bitmap */
+	unsigned long	_used_slots;		/* used when max_slots fits */
+	spinlock_t	slot_tbl_lock;
+	struct rpc_wait_queue	slot_tbl_waitq;	/* allocators may wait here */
+	int		max_slots;		/* # slots in table */
+	int		lowest_free_slotid;	/* lower bound hint */
+	int		highest_used_slotid;	/* sent to server on each SEQ.
+						 * op for dynamic resizing */
+};
+
 struct nfs4_channel {
 	struct nfs4_channel_attrs 	chan_attrs;
 	struct rpc_clnt 		*rpc_client;
+	struct nfs4_slot_table		slot_table;
 };
 
 /*

index 08e7129..4ded3a5 100644
@@ -207,6 +207,94 @@ static void renew_lease(const struct nfs_server *server, unsigned long timestamp
 	spin_unlock(&clp->cl_lock);
 }
 
+#if defined(CONFIG_NFS_V4_1)
+
+/*
+ * idx2bmp - return pointer to bitmap word holding index "idx".
+ *
+ * inputs:
+ * @base	points to bitmap.
+ * @idx		slot index.
+ *
+ * output:
+ * @bit		optional, *bit set to bit index of "idx" in the returned
+ *		bitmap word.
+ */
+static inline unsigned long *idx2bmp(unsigned long *base, int idx, int *bit)
+{
+	base += idx / BITS_PER_LONG;
+	if (bit)
+		*bit = idx & (BITS_PER_LONG - 1);
+	return base;
+}
+
+/*
+ * bmp2idx - return absolute index of bmp:bit in bitmap.
+ *
+ * inputs:
+ * @base	points to bitmap.
+ * @bmp		points to bitmap word.
+ * @bit		bit index in bitmap word.
+ */
+static inline int bmp2idx(unsigned long *base, unsigned long *bmp,
+			  int bit)
+{
+	return ((bmp - base) * BITS_PER_LONG) + bit;
+}
+
+/*
+ * nfs4_find_slot - efficiently look for a free slot
+ *
+ * nfs4_find_slot uses the ffz cpu-optimized function to look for an unset
+ * bit in each word in the bitmap.
+ * Scan starts at lowest_free_slotid, which is a hint for the free slot,
+ * as all lower-numbered slots are known to be used.
+ * If found, we mark the slot as used, update the highest_used_slotid,
+ * and respectively set up the sequence operation args.
+ * The lowest_free_slotid is always set to the successive slotid.
+ * A pointer to the slot's seqid is returned if found, or NULL otherwise.
+ */
+static struct nfs4_slot *
+nfs4_find_slot(struct nfs4_slot_table *tbl, struct rpc_task *task)
+{
+	int bit, slotid;
+	struct nfs4_slot *slot = NULL;
+	unsigned long *used, u;
+
+	spin_lock(&tbl->slot_tbl_lock);
+	slotid = tbl->lowest_free_slotid;
+	while (slotid < tbl->max_slots) {
+		used = idx2bmp(tbl->used_slots, slotid, NULL);
+		u = *used;
+		if (u == ~0UL) {
+			/* all slots marked used in this word */
+			slotid += BITS_PER_LONG;
+			continue;
+		}
+		/* find first slot marked free in word */
+		bit = ffz(u);
+		slotid = bmp2idx(tbl->used_slots, used, bit);
+		/* mark slot used.  note that we don't do that if
+		 * slotid >= tbl->max_slots so not to confuse
+		 * highest_used_slotid algorithm */
+		if (slotid < tbl->max_slots) {
+			*used |= (1 << bit);
+			if (slotid > tbl->highest_used_slotid)
+				tbl->highest_used_slotid = slotid;
+			slot = tbl->slots + slotid;
+			slotid++;	/* for updating lowest_free_slot */
+		}
+		break;
+	}
+	tbl->lowest_free_slotid = slotid;
+	spin_unlock(&tbl->slot_tbl_lock);
+	dprintk("<-- %s slot %p slotid %d\n", __func__,
+		slot, slot ? slot_idx(tbl, slot) : -1);
+	return slot;
+}
+
+#endif /* CONFIG_NFS_V4_1 */
+
 static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo)
 {
 	struct nfs_inode *nfsi = NFS_I(dir);

index d534269..2960ba9 100644
@@ -33,6 +33,11 @@ struct nfs4_slot_table {
 						 * op for dynamic resizing */
 };
 
+static inline int slot_idx(struct nfs4_slot_table *tbl, struct nfs4_slot *sp)
+{
+	return sp - tbl->slots;
+}
+
 struct nfs4_channel {
 	struct nfs4_channel_attrs 	chan_attrs;
 	struct rpc_clnt 		*rpc_client;

index 4ded3a5..d26f61d 100644
@@ -243,6 +243,60 @@ static inline int bmp2idx(unsigned long *base, unsigned long *bmp,
 }
 
 /*
+ * nfs4_find_slot - free a slot and efficiently update slot table.
+ *
+ * freeing a slot is trivially done by clearing its respective bit
+ * in the bitmap.
+ * The lowest_free_slotid is updated if the freed slotid is lower than that.
+ * If the freed slotid equals highest_used_slotid we want to update it
+ * so that the server would be able to size down the slot table if needed,
+ * otherwise we know that the highest_used_slotid is still in use.
+ * When updating highest_used_slotid there may be "holes" in the bitmap
+ * so we need to scan down from highest_used_slotid to 0 looking for the now
+ * highest slotid in use.
+ * We use the fls cpu-optimized function to look for the last set bit in each
+ * word in the bitmap.
+ * If none found, highest_used_slotid is set to -1.
+ */
+static void
+nfs41_free_slot(struct nfs4_slot_table *tbl, struct nfs4_slot *slot)
+{
+	int slotid = slot_idx(tbl, slot);
+	unsigned long *used, u;
+	int bit;
+
+	spin_lock(&tbl->slot_tbl_lock);
+	/* clear used bit in bitmap */
+	used = idx2bmp(tbl->used_slots, slotid, &bit);
+	*used &= ~(1 << bit);
+
+	if (slotid < tbl->lowest_free_slotid)
+		tbl->lowest_free_slotid = slotid;
+
+	/* update highest_used_slotid when it is freed */
+	if (slotid == tbl->highest_used_slotid) {
+		tbl->highest_used_slotid = -1;
+		slotid--;
+		/* scan down for the highest used slotid */
+		while (slotid >= 0) {
+			used = idx2bmp(tbl->used_slots, slotid, NULL);
+			u = *used;
+			if (!u) {
+				/* all slots marked free in this word */
+				slotid -= BITS_PER_LONG;
+				continue;
+			}
+			bit = __fls(u);
+			tbl->highest_used_slotid = bmp2idx(tbl->used_slots,
+							   used, bit);
+			break;
+		}
+	}
+	spin_unlock(&tbl->slot_tbl_lock);
+	rpc_wake_up_next(&tbl->slot_tbl_waitq);
+}
+
+/*
  * nfs4_find_slot - efficiently look for a free slot
  *
  * nfs4_find_slot uses the ffz cpu-optimized function to look for an unset

index 30addf4..d3da7a5 100644
@@ -240,43 +240,63 @@ static int nfs4_stat_to_errno(int);
 				(encode_getattr_maxsz)
 #define decode_fs_locations_maxsz \
 				(0)
+
+#if defined(CONFIG_NFS_V4_1)
+#define encode_sequence_maxsz	0 /* stub */
+#define decode_sequence_maxsz	0 /* stub */
+#else /* CONFIG_NFS_V4_1 */
+#define encode_sequence_maxsz	0
+#define decode_sequence_maxsz	0
+#endif /* CONFIG_NFS_V4_1 */
+
 #define NFS4_enc_compound_sz	(1024)  /* XXX: large enough? */
 #define NFS4_dec_compound_sz	(1024)  /* XXX: large enough? */
 #define NFS4_enc_read_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_read_maxsz)
 #define NFS4_dec_read_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_read_maxsz)
 #define NFS4_enc_readlink_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_readlink_maxsz)
 #define NFS4_dec_readlink_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_readlink_maxsz)
 #define NFS4_enc_readdir_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_readdir_maxsz)
 #define NFS4_dec_readdir_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_readdir_maxsz)
 #define NFS4_enc_write_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_write_maxsz + \
 				encode_getattr_maxsz)
 #define NFS4_dec_write_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_write_maxsz + \
 				decode_getattr_maxsz)
 #define NFS4_enc_commit_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_commit_maxsz + \
 				encode_getattr_maxsz)
 #define NFS4_dec_commit_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_commit_maxsz + \
 				decode_getattr_maxsz)
-#define NFS4_enc_open_sz        (compound_encode_hdr_maxsz + \
+#define NFS4_enc_open_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_savefh_maxsz + \
 				encode_open_maxsz + \

@@ -284,7 +304,8 @@ static int nfs4_stat_to_errno(int);
 				encode_getattr_maxsz + \
 				encode_restorefh_maxsz + \
 				encode_getattr_maxsz)
-#define NFS4_dec_open_sz        (compound_decode_hdr_maxsz + \
+#define NFS4_dec_open_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_savefh_maxsz + \
 				decode_open_maxsz + \

@@ -301,43 +322,53 @@ static int nfs4_stat_to_errno(int);
 				 decode_putfh_maxsz + \
 				 decode_open_confirm_maxsz)
 #define NFS4_enc_open_noattr_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 					encode_putfh_maxsz + \
 					encode_open_maxsz + \
 					encode_getattr_maxsz)
 #define NFS4_dec_open_noattr_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 					decode_putfh_maxsz + \
 					decode_open_maxsz + \
 					decode_getattr_maxsz)
 #define NFS4_enc_open_downgrade_sz \
 				(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				 encode_putfh_maxsz + \
 				 encode_open_downgrade_maxsz + \
 				 encode_getattr_maxsz)
 #define NFS4_dec_open_downgrade_sz \
 				(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				 decode_putfh_maxsz + \
 				 decode_open_downgrade_maxsz + \
 				 decode_getattr_maxsz)
 #define NFS4_enc_close_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				 encode_putfh_maxsz + \
 				 encode_close_maxsz + \
 				 encode_getattr_maxsz)
 #define NFS4_dec_close_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				 decode_putfh_maxsz + \
 				 decode_close_maxsz + \
 				 decode_getattr_maxsz)
 #define NFS4_enc_setattr_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				 encode_putfh_maxsz + \
 				 encode_setattr_maxsz + \
 				 encode_getattr_maxsz)
 #define NFS4_dec_setattr_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				 decode_putfh_maxsz + \
 				 decode_setattr_maxsz + \
 				 decode_getattr_maxsz)
 #define NFS4_enc_fsinfo_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_fsinfo_maxsz)
 #define NFS4_dec_fsinfo_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_fsinfo_maxsz)
 #define NFS4_enc_renew_sz	(compound_encode_hdr_maxsz + \

@@ -359,64 +390,81 @@ static int nfs4_stat_to_errno(int);
 				decode_putrootfh_maxsz + \
 				decode_fsinfo_maxsz)
 #define NFS4_enc_lock_sz        (compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_lock_maxsz)
 #define NFS4_dec_lock_sz        (compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_lock_maxsz)
 #define NFS4_enc_lockt_sz       (compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_lockt_maxsz)
 #define NFS4_dec_lockt_sz       (compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				 decode_putfh_maxsz + \
 				 decode_lockt_maxsz)
 #define NFS4_enc_locku_sz       (compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_locku_maxsz)
 #define NFS4_dec_locku_sz       (compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_locku_maxsz)
 #define NFS4_enc_access_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_access_maxsz + \
 				encode_getattr_maxsz)
 #define NFS4_dec_access_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_access_maxsz + \
 				decode_getattr_maxsz)
 #define NFS4_enc_getattr_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_getattr_maxsz)
 #define NFS4_dec_getattr_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_getattr_maxsz)
 #define NFS4_enc_lookup_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_lookup_maxsz + \
 				encode_getattr_maxsz + \
 				encode_getfh_maxsz)
 #define NFS4_dec_lookup_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_lookup_maxsz + \
 				decode_getattr_maxsz + \
 				decode_getfh_maxsz)
 #define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putrootfh_maxsz + \
 				encode_getattr_maxsz + \
 				encode_getfh_maxsz)
 #define NFS4_dec_lookup_root_sz (compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putrootfh_maxsz + \
 				decode_getattr_maxsz + \
 				decode_getfh_maxsz)
 #define NFS4_enc_remove_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_remove_maxsz + \
 				encode_getattr_maxsz)
 #define NFS4_dec_remove_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				op_decode_hdr_maxsz + 5 + \
 				decode_getattr_maxsz)
 #define NFS4_enc_rename_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_savefh_maxsz + \
 				encode_putfh_maxsz + \

@@ -425,6 +473,7 @@ static int nfs4_stat_to_errno(int);
 				encode_restorefh_maxsz + \
 				encode_getattr_maxsz)
 #define NFS4_dec_rename_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_savefh_maxsz + \
 				decode_putfh_maxsz + \

@@ -433,6 +482,7 @@ static int nfs4_stat_to_errno(int);
 				decode_restorefh_maxsz + \
 				decode_getattr_maxsz)
 #define NFS4_enc_link_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_savefh_maxsz + \
 				encode_putfh_maxsz + \

@@ -441,6 +491,7 @@ static int nfs4_stat_to_errno(int);
 				encode_restorefh_maxsz + \
 				decode_getattr_maxsz)
 #define NFS4_dec_link_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_savefh_maxsz + \
 				decode_putfh_maxsz + \

@@ -449,16 +500,19 @@ static int nfs4_stat_to_errno(int);
 				decode_restorefh_maxsz + \
 				decode_getattr_maxsz)
 #define NFS4_enc_symlink_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_symlink_maxsz + \
 				encode_getattr_maxsz + \
 				encode_getfh_maxsz)
 #define NFS4_dec_symlink_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_symlink_maxsz + \
 				decode_getattr_maxsz + \
 				decode_getfh_maxsz)
 #define NFS4_enc_create_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_savefh_maxsz + \
 				encode_create_maxsz + \

@@ -467,6 +521,7 @@ static int nfs4_stat_to_errno(int);
 				encode_restorefh_maxsz + \
 				encode_getattr_maxsz)
 #define NFS4_dec_create_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_savefh_maxsz + \
 				decode_create_maxsz + \

@@ -475,49 +530,63 @@ static int nfs4_stat_to_errno(int);
 				decode_restorefh_maxsz + \
 				decode_getattr_maxsz)
 #define NFS4_enc_pathconf_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_getattr_maxsz)
 #define NFS4_dec_pathconf_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_getattr_maxsz)
 #define NFS4_enc_statfs_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_statfs_maxsz)
 #define NFS4_dec_statfs_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_statfs_maxsz)
 #define NFS4_enc_server_caps_sz (compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_getattr_maxsz)
 #define NFS4_dec_server_caps_sz (compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_getattr_maxsz)
 #define NFS4_enc_delegreturn_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_delegreturn_maxsz + \
 				encode_getattr_maxsz)
 #define NFS4_dec_delegreturn_sz (compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_delegreturn_maxsz + \
 				decode_getattr_maxsz)
 #define NFS4_enc_getacl_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_getacl_maxsz)
 #define NFS4_dec_getacl_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_getacl_maxsz)
 #define NFS4_enc_setacl_sz	(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				encode_putfh_maxsz + \
 				encode_setacl_maxsz)
 #define NFS4_dec_setacl_sz	(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				decode_putfh_maxsz + \
 				decode_setacl_maxsz)
 #define NFS4_enc_fs_locations_sz \
 				(compound_encode_hdr_maxsz + \
+				encode_sequence_maxsz + \
 				 encode_putfh_maxsz + \
 				 encode_lookup_maxsz + \
 				 encode_fs_locations_maxsz)
 #define NFS4_dec_fs_locations_sz \
 				(compound_decode_hdr_maxsz + \
+				decode_sequence_maxsz + \
 				 decode_putfh_maxsz + \
 				 decode_lookup_maxsz + \
 				 decode_fs_locations_maxsz)