UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

nfs: nfs4xdr: optimize low level encoding 

do not increment encoding ptr if not needed.

Signed-off-by: Benny Halevy <bhalevy@panasas.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
This commit is contained in:
Benny Halevy 2009-08-14 17:19:30 +03:00 committed by Trond Myklebust
parent 13c65ce900
commit 345585132a
1 changed files with 64 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
fs/nfs/nfs4xdr.c
View File

@ -737,7 +737,7 @@ static void encode_compound_hdr(struct xdr_stream *xdr,
p = xdr_encode_opaque_fixed(p, hdr->tag, hdr->taglen); p = xdr_encode_opaque_fixed(p, hdr->tag, hdr->taglen);
*p++ = cpu_to_be32(hdr->minorversion); *p++ = cpu_to_be32(hdr->minorversion);
hdr->nops_p = p; hdr->nops_p = p;
*p++ = cpu_to_be32(hdr->nops); *p = cpu_to_be32(hdr->nops);
} }
static void encode_nops(struct compound_hdr *hdr) static void encode_nops(struct compound_hdr *hdr)
@ -874,7 +874,7 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const
len = (char *)p - (char *)q - 12; len = (char *)p - (char *)q - 12;
*q++ = htonl(bmval0); *q++ = htonl(bmval0);
*q++ = htonl(bmval1); *q++ = htonl(bmval1);
*q++ = htonl(len); *q = htonl(len);
/* out: */ /* out: */
} }
@ -885,7 +885,7 @@ static void encode_access(struct xdr_stream *xdr, u32 access, struct compound_hd
p = reserve_space(xdr, 8); p = reserve_space(xdr, 8);
*p++ = cpu_to_be32(OP_ACCESS); *p++ = cpu_to_be32(OP_ACCESS);
*p++ = cpu_to_be32(access); *p = cpu_to_be32(access);
hdr->nops++; hdr->nops++;
hdr->replen += decode_access_maxsz; hdr->replen += decode_access_maxsz;
} }
@ -897,7 +897,7 @@ static void encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg
p = reserve_space(xdr, 8+NFS4_STATEID_SIZE); p = reserve_space(xdr, 8+NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(OP_CLOSE); *p++ = cpu_to_be32(OP_CLOSE);
*p++ = cpu_to_be32(arg->seqid->sequence->counter); *p++ = cpu_to_be32(arg->seqid->sequence->counter);
p = xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE); xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE);
hdr->nops++; hdr->nops++;
hdr->replen += decode_close_maxsz; hdr->replen += decode_close_maxsz;
} }
@ -909,7 +909,7 @@ static void encode_commit(struct xdr_stream *xdr, const struct nfs_writeargs *ar
p = reserve_space(xdr, 16); p = reserve_space(xdr, 16);
*p++ = cpu_to_be32(OP_COMMIT); *p++ = cpu_to_be32(OP_COMMIT);
p = xdr_encode_hyper(p, args->offset); p = xdr_encode_hyper(p, args->offset);
*p++ = cpu_to_be32(args->count); *p = cpu_to_be32(args->count);
hdr->nops++; hdr->nops++;
hdr->replen += decode_commit_maxsz; hdr->replen += decode_commit_maxsz;
} }
@ -920,19 +920,19 @@ static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *
p = reserve_space(xdr, 8); p = reserve_space(xdr, 8);
*p++ = cpu_to_be32(OP_CREATE); *p++ = cpu_to_be32(OP_CREATE);
*p++ = cpu_to_be32(create->ftype); *p = cpu_to_be32(create->ftype);
switch (create->ftype) { switch (create->ftype) {
case NF4LNK: case NF4LNK:
p = reserve_space(xdr, 4); p = reserve_space(xdr, 4);
*p++ = cpu_to_be32(create->u.symlink.len); *p = cpu_to_be32(create->u.symlink.len);
xdr_write_pages(xdr, create->u.symlink.pages, 0, create->u.symlink.len); xdr_write_pages(xdr, create->u.symlink.pages, 0, create->u.symlink.len);
break; break;
case NF4BLK: case NF4CHR: case NF4BLK: case NF4CHR:
p = reserve_space(xdr, 8); p = reserve_space(xdr, 8);
*p++ = cpu_to_be32(create->u.device.specdata1); *p++ = cpu_to_be32(create->u.device.specdata1);
*p++ = cpu_to_be32(create->u.device.specdata2); *p = cpu_to_be32(create->u.device.specdata2);
break; break;
default: default:
@ -941,7 +941,7 @@ static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *
p = reserve_space(xdr, 4 + create->name->len); p = reserve_space(xdr, 4 + create->name->len);
*p++ = cpu_to_be32(create->name->len); *p++ = cpu_to_be32(create->name->len);
p = xdr_encode_opaque_fixed(p, create->name->name, create->name->len); xdr_encode_opaque_fixed(p, create->name->name, create->name->len);
hdr->nops++; hdr->nops++;
hdr->replen += decode_create_maxsz; hdr->replen += decode_create_maxsz;
@ -955,7 +955,7 @@ static void encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap, struct c
p = reserve_space(xdr, 12); p = reserve_space(xdr, 12);
*p++ = cpu_to_be32(OP_GETATTR); *p++ = cpu_to_be32(OP_GETATTR);
*p++ = cpu_to_be32(1); *p++ = cpu_to_be32(1);
*p++ = cpu_to_be32(bitmap); *p = cpu_to_be32(bitmap);
hdr->nops++; hdr->nops++;
hdr->replen += decode_getattr_maxsz; hdr->replen += decode_getattr_maxsz;
} }
@ -968,7 +968,7 @@ static void encode_getattr_two(struct xdr_stream *xdr, uint32_t bm0, uint32_t bm
*p++ = cpu_to_be32(OP_GETATTR); *p++ = cpu_to_be32(OP_GETATTR);
*p++ = cpu_to_be32(2); *p++ = cpu_to_be32(2);
*p++ = cpu_to_be32(bm0); *p++ = cpu_to_be32(bm0);
*p++ = cpu_to_be32(bm1); *p = cpu_to_be32(bm1);
hdr->nops++; hdr->nops++;
hdr->replen += decode_getattr_maxsz; hdr->replen += decode_getattr_maxsz;
} }
@ -996,7 +996,7 @@ static void encode_getfh(struct xdr_stream *xdr, struct compound_hdr *hdr)
__be32 *p; __be32 *p;
p = reserve_space(xdr, 4); p = reserve_space(xdr, 4);
*p++ = cpu_to_be32(OP_GETFH); *p = cpu_to_be32(OP_GETFH);
hdr->nops++; hdr->nops++;
hdr->replen += decode_getfh_maxsz; hdr->replen += decode_getfh_maxsz;
} }
@ -1008,7 +1008,7 @@ static void encode_link(struct xdr_stream *xdr, const struct qstr *name, struct
p = reserve_space(xdr, 8 + name->len); p = reserve_space(xdr, 8 + name->len);
*p++ = cpu_to_be32(OP_LINK); *p++ = cpu_to_be32(OP_LINK);
*p++ = cpu_to_be32(name->len); *p++ = cpu_to_be32(name->len);
p = xdr_encode_opaque_fixed(p, name->name, name->len); xdr_encode_opaque_fixed(p, name->name, name->len);
hdr->nops++; hdr->nops++;
hdr->replen += decode_link_maxsz; hdr->replen += decode_link_maxsz;
} }
@ -1041,7 +1041,7 @@ static void encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args
*p++ = cpu_to_be32(args->reclaim); *p++ = cpu_to_be32(args->reclaim);
p = xdr_encode_hyper(p, args->fl->fl_start); p = xdr_encode_hyper(p, args->fl->fl_start);
p = xdr_encode_hyper(p, nfs4_lock_length(args->fl)); p = xdr_encode_hyper(p, nfs4_lock_length(args->fl));
*p++ = cpu_to_be32(args->new_lock_owner); *p = cpu_to_be32(args->new_lock_owner);
if (args->new_lock_owner){ if (args->new_lock_owner){
p = reserve_space(xdr, 4+NFS4_STATEID_SIZE+32); p = reserve_space(xdr, 4+NFS4_STATEID_SIZE+32);
*p++ = cpu_to_be32(args->open_seqid->sequence->counter); *p++ = cpu_to_be32(args->open_seqid->sequence->counter);
@ -1050,12 +1050,12 @@ static void encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args
p = xdr_encode_hyper(p, args->lock_owner.clientid); p = xdr_encode_hyper(p, args->lock_owner.clientid);
*p++ = cpu_to_be32(16); *p++ = cpu_to_be32(16);
p = xdr_encode_opaque_fixed(p, "lock id:", 8); p = xdr_encode_opaque_fixed(p, "lock id:", 8);
p = xdr_encode_hyper(p, args->lock_owner.id); xdr_encode_hyper(p, args->lock_owner.id);
} }
else { else {
p = reserve_space(xdr, NFS4_STATEID_SIZE+4); p = reserve_space(xdr, NFS4_STATEID_SIZE+4);
p = xdr_encode_opaque_fixed(p, args->lock_stateid->data, NFS4_STATEID_SIZE); p = xdr_encode_opaque_fixed(p, args->lock_stateid->data, NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(args->lock_seqid->sequence->counter); *p = cpu_to_be32(args->lock_seqid->sequence->counter);
} }
hdr->nops++; hdr->nops++;
hdr->replen += decode_lock_maxsz; hdr->replen += decode_lock_maxsz;
@ -1073,7 +1073,7 @@ static void encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *ar
p = xdr_encode_hyper(p, args->lock_owner.clientid); p = xdr_encode_hyper(p, args->lock_owner.clientid);
*p++ = cpu_to_be32(16); *p++ = cpu_to_be32(16);
p = xdr_encode_opaque_fixed(p, "lock id:", 8); p = xdr_encode_opaque_fixed(p, "lock id:", 8);
p = xdr_encode_hyper(p, args->lock_owner.id); xdr_encode_hyper(p, args->lock_owner.id);
hdr->nops++; hdr->nops++;
hdr->replen += decode_lockt_maxsz; hdr->replen += decode_lockt_maxsz;
} }
@ -1088,7 +1088,7 @@ static void encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *ar
*p++ = cpu_to_be32(args->seqid->sequence->counter); *p++ = cpu_to_be32(args->seqid->sequence->counter);
p = xdr_encode_opaque_fixed(p, args->stateid->data, NFS4_STATEID_SIZE); p = xdr_encode_opaque_fixed(p, args->stateid->data, NFS4_STATEID_SIZE);
p = xdr_encode_hyper(p, args->fl->fl_start); p = xdr_encode_hyper(p, args->fl->fl_start);
p = xdr_encode_hyper(p, nfs4_lock_length(args->fl)); xdr_encode_hyper(p, nfs4_lock_length(args->fl));
hdr->nops++; hdr->nops++;
hdr->replen += decode_locku_maxsz; hdr->replen += decode_locku_maxsz;
} }
@ -1101,7 +1101,7 @@ static void encode_lookup(struct xdr_stream *xdr, const struct qstr *name, struc
p = reserve_space(xdr, 8 + len); p = reserve_space(xdr, 8 + len);
*p++ = cpu_to_be32(OP_LOOKUP); *p++ = cpu_to_be32(OP_LOOKUP);
*p++ = cpu_to_be32(len); *p++ = cpu_to_be32(len);
p = xdr_encode_opaque_fixed(p, name->name, len); xdr_encode_opaque_fixed(p, name->name, len);
hdr->nops++; hdr->nops++;
hdr->replen += decode_lookup_maxsz; hdr->replen += decode_lookup_maxsz;
} }
@ -1124,7 +1124,7 @@ static void encode_share_access(struct xdr_stream *xdr, fmode_t fmode)
default: default:
*p++ = cpu_to_be32(0); *p++ = cpu_to_be32(0);
} }
*p++ = cpu_to_be32(0); /* for linux, share_deny = 0 always */ *p = cpu_to_be32(0); /* for linux, share_deny = 0 always */
} }
static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_openargs *arg) static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_openargs *arg)
@ -1136,13 +1136,13 @@ static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_opena
*/ */
p = reserve_space(xdr, 8); p = reserve_space(xdr, 8);
*p++ = cpu_to_be32(OP_OPEN); *p++ = cpu_to_be32(OP_OPEN);
*p++ = cpu_to_be32(arg->seqid->sequence->counter); *p = cpu_to_be32(arg->seqid->sequence->counter);
encode_share_access(xdr, arg->fmode); encode_share_access(xdr, arg->fmode);
p = reserve_space(xdr, 28); p = reserve_space(xdr, 28);
p = xdr_encode_hyper(p, arg->clientid); p = xdr_encode_hyper(p, arg->clientid);
*p++ = cpu_to_be32(16); *p++ = cpu_to_be32(16);
p = xdr_encode_opaque_fixed(p, "open id:", 8); p = xdr_encode_opaque_fixed(p, "open id:", 8);
p = xdr_encode_hyper(p, arg->id); xdr_encode_hyper(p, arg->id);
} }
static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_openargs *arg) static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_openargs *arg)
@ -1152,11 +1152,11 @@ static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_op
p = reserve_space(xdr, 4); p = reserve_space(xdr, 4);
switch(arg->open_flags & O_EXCL) { switch(arg->open_flags & O_EXCL) {
case 0: case 0:
*p++ = cpu_to_be32(NFS4_CREATE_UNCHECKED); *p = cpu_to_be32(NFS4_CREATE_UNCHECKED);
encode_attrs(xdr, arg->u.attrs, arg->server); encode_attrs(xdr, arg->u.attrs, arg->server);
break; break;
default: default:
*p++ = cpu_to_be32(NFS4_CREATE_EXCLUSIVE); *p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE);
encode_nfs4_verifier(xdr, &arg->u.verifier); encode_nfs4_verifier(xdr, &arg->u.verifier);
} }
} }
@ -1168,11 +1168,11 @@ static void encode_opentype(struct xdr_stream *xdr, const struct nfs_openargs *a
p = reserve_space(xdr, 4); p = reserve_space(xdr, 4);
switch (arg->open_flags & O_CREAT) { switch (arg->open_flags & O_CREAT) {
case 0: case 0:
*p++ = cpu_to_be32(NFS4_OPEN_NOCREATE); *p = cpu_to_be32(NFS4_OPEN_NOCREATE);
break; break;
default: default:
BUG_ON(arg->claim != NFS4_OPEN_CLAIM_NULL); BUG_ON(arg->claim != NFS4_OPEN_CLAIM_NULL);
*p++ = cpu_to_be32(NFS4_OPEN_CREATE); *p = cpu_to_be32(NFS4_OPEN_CREATE);
encode_createmode(xdr, arg); encode_createmode(xdr, arg);
} }
} }
@ -1184,13 +1184,13 @@ static inline void encode_delegation_type(struct xdr_stream *xdr, fmode_t delega
p = reserve_space(xdr, 4); p = reserve_space(xdr, 4);
switch (delegation_type) { switch (delegation_type) {
case 0: case 0:
*p++ = cpu_to_be32(NFS4_OPEN_DELEGATE_NONE); *p = cpu_to_be32(NFS4_OPEN_DELEGATE_NONE);
break; break;
case FMODE_READ: case FMODE_READ:
*p++ = cpu_to_be32(NFS4_OPEN_DELEGATE_READ); *p = cpu_to_be32(NFS4_OPEN_DELEGATE_READ);
break; break;
case FMODE_WRITE|FMODE_READ: case FMODE_WRITE|FMODE_READ:
*p++ = cpu_to_be32(NFS4_OPEN_DELEGATE_WRITE); *p = cpu_to_be32(NFS4_OPEN_DELEGATE_WRITE);
break; break;
default: default:
BUG(); BUG();
@ -1202,7 +1202,7 @@ static inline void encode_claim_null(struct xdr_stream *xdr, const struct qstr *
__be32 *p; __be32 *p;
p = reserve_space(xdr, 4); p = reserve_space(xdr, 4);
*p++ = cpu_to_be32(NFS4_OPEN_CLAIM_NULL); *p = cpu_to_be32(NFS4_OPEN_CLAIM_NULL);
encode_string(xdr, name->len, name->name); encode_string(xdr, name->len, name->name);
} }
@ -1211,7 +1211,7 @@ static inline void encode_claim_previous(struct xdr_stream *xdr, fmode_t type)
__be32 *p; __be32 *p;
p = reserve_space(xdr, 4); p = reserve_space(xdr, 4);
*p++ = cpu_to_be32(NFS4_OPEN_CLAIM_PREVIOUS); *p = cpu_to_be32(NFS4_OPEN_CLAIM_PREVIOUS);
encode_delegation_type(xdr, type); encode_delegation_type(xdr, type);
} }
@ -1221,7 +1221,7 @@ static inline void encode_claim_delegate_cur(struct xdr_stream *xdr, const struc
p = reserve_space(xdr, 4+NFS4_STATEID_SIZE); p = reserve_space(xdr, 4+NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(NFS4_OPEN_CLAIM_DELEGATE_CUR); *p++ = cpu_to_be32(NFS4_OPEN_CLAIM_DELEGATE_CUR);
p = xdr_encode_opaque_fixed(p, stateid->data, NFS4_STATEID_SIZE); xdr_encode_opaque_fixed(p, stateid->data, NFS4_STATEID_SIZE);
encode_string(xdr, name->len, name->name); encode_string(xdr, name->len, name->name);
} }
@ -1253,7 +1253,7 @@ static void encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_co
p = reserve_space(xdr, 4+NFS4_STATEID_SIZE+4); p = reserve_space(xdr, 4+NFS4_STATEID_SIZE+4);
*p++ = cpu_to_be32(OP_OPEN_CONFIRM); *p++ = cpu_to_be32(OP_OPEN_CONFIRM);
p = xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE); p = xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(arg->seqid->sequence->counter); *p = cpu_to_be32(arg->seqid->sequence->counter);
hdr->nops++; hdr->nops++;
hdr->replen += decode_open_confirm_maxsz; hdr->replen += decode_open_confirm_maxsz;
} }
@ -1265,7 +1265,7 @@ static void encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_close
p = reserve_space(xdr, 4+NFS4_STATEID_SIZE+4); p = reserve_space(xdr, 4+NFS4_STATEID_SIZE+4);
*p++ = cpu_to_be32(OP_OPEN_DOWNGRADE); *p++ = cpu_to_be32(OP_OPEN_DOWNGRADE);
p = xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE); p = xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(arg->seqid->sequence->counter); *p = cpu_to_be32(arg->seqid->sequence->counter);
encode_share_access(xdr, arg->fmode); encode_share_access(xdr, arg->fmode);
hdr->nops++; hdr->nops++;
hdr->replen += decode_open_downgrade_maxsz; hdr->replen += decode_open_downgrade_maxsz;
@ -1280,7 +1280,7 @@ encode_putfh(struct xdr_stream *xdr, const struct nfs_fh *fh, struct compound_hd
p = reserve_space(xdr, 8 + len); p = reserve_space(xdr, 8 + len);
*p++ = cpu_to_be32(OP_PUTFH); *p++ = cpu_to_be32(OP_PUTFH);
*p++ = cpu_to_be32(len); *p++ = cpu_to_be32(len);
p = xdr_encode_opaque_fixed(p, fh->data, len); xdr_encode_opaque_fixed(p, fh->data, len);
hdr->nops++; hdr->nops++;
hdr->replen += decode_putfh_maxsz; hdr->replen += decode_putfh_maxsz;
} }
@ -1290,7 +1290,7 @@ static void encode_putrootfh(struct xdr_stream *xdr, struct compound_hdr *hdr)
__be32 *p; __be32 *p;
p = reserve_space(xdr, 4); p = reserve_space(xdr, 4);
*p++ = cpu_to_be32(OP_PUTROOTFH); *p = cpu_to_be32(OP_PUTROOTFH);
hdr->nops++; hdr->nops++;
hdr->replen += decode_putrootfh_maxsz; hdr->replen += decode_putrootfh_maxsz;
} }
@ -1303,9 +1303,9 @@ static void encode_stateid(struct xdr_stream *xdr, const struct nfs_open_context
p = reserve_space(xdr, NFS4_STATEID_SIZE); p = reserve_space(xdr, NFS4_STATEID_SIZE);
if (ctx->state != NULL) { if (ctx->state != NULL) {
nfs4_copy_stateid(&stateid, ctx->state, ctx->lockowner); nfs4_copy_stateid(&stateid, ctx->state, ctx->lockowner);
p = xdr_encode_opaque_fixed(p, stateid.data, NFS4_STATEID_SIZE); xdr_encode_opaque_fixed(p, stateid.data, NFS4_STATEID_SIZE);
} else } else
p = xdr_encode_opaque_fixed(p, zero_stateid.data, NFS4_STATEID_SIZE); xdr_encode_opaque_fixed(p, zero_stateid.data, NFS4_STATEID_SIZE);
} }
static void encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args, struct compound_hdr *hdr) static void encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args, struct compound_hdr *hdr)
@ -1313,13 +1313,13 @@ static void encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args,
__be32 *p; __be32 *p;
p = reserve_space(xdr, 4); p = reserve_space(xdr, 4);
*p++ = cpu_to_be32(OP_READ); *p = cpu_to_be32(OP_READ);
encode_stateid(xdr, args->context); encode_stateid(xdr, args->context);
p = reserve_space(xdr, 12); p = reserve_space(xdr, 12);
p = xdr_encode_hyper(p, args->offset); p = xdr_encode_hyper(p, args->offset);
*p++ = cpu_to_be32(args->count); *p = cpu_to_be32(args->count);
hdr->nops++; hdr->nops++;
hdr->replen += decode_read_maxsz; hdr->replen += decode_read_maxsz;
} }
@ -1345,7 +1345,7 @@ static void encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg
else else
attrs[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID; attrs[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
*p++ = cpu_to_be32(attrs[0] & readdir->bitmask[0]); *p++ = cpu_to_be32(attrs[0] & readdir->bitmask[0]);
*p++ = cpu_to_be32(attrs[1] & readdir->bitmask[1]); *p = cpu_to_be32(attrs[1] & readdir->bitmask[1]);
hdr->nops++; hdr->nops++;
hdr->replen += decode_readdir_maxsz; hdr->replen += decode_readdir_maxsz;
dprintk("%s: cookie = %Lu, verifier = %08x:%08x, bitmap = %08x:%08x\n", dprintk("%s: cookie = %Lu, verifier = %08x:%08x, bitmap = %08x:%08x\n",
@ -1362,7 +1362,7 @@ static void encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *
__be32 *p; __be32 *p;
p = reserve_space(xdr, 4); p = reserve_space(xdr, 4);
*p++ = cpu_to_be32(OP_READLINK); *p = cpu_to_be32(OP_READLINK);
hdr->nops++; hdr->nops++;
hdr->replen += decode_readlink_maxsz; hdr->replen += decode_readlink_maxsz;
} }
@ -1374,7 +1374,7 @@ static void encode_remove(struct xdr_stream *xdr, const struct qstr *name, struc
p = reserve_space(xdr, 8 + name->len); p = reserve_space(xdr, 8 + name->len);
*p++ = cpu_to_be32(OP_REMOVE); *p++ = cpu_to_be32(OP_REMOVE);
*p++ = cpu_to_be32(name->len); *p++ = cpu_to_be32(name->len);
p = xdr_encode_opaque_fixed(p, name->name, name->len); xdr_encode_opaque_fixed(p, name->name, name->len);
hdr->nops++; hdr->nops++;
hdr->replen += decode_remove_maxsz; hdr->replen += decode_remove_maxsz;
} }
@ -1386,11 +1386,11 @@ static void encode_rename(struct xdr_stream *xdr, const struct qstr *oldname, co
p = reserve_space(xdr, 8 + oldname->len); p = reserve_space(xdr, 8 + oldname->len);
*p++ = cpu_to_be32(OP_RENAME); *p++ = cpu_to_be32(OP_RENAME);
*p++ = cpu_to_be32(oldname->len); *p++ = cpu_to_be32(oldname->len);
p = xdr_encode_opaque_fixed(p, oldname->name, oldname->len); xdr_encode_opaque_fixed(p, oldname->name, oldname->len);
p = reserve_space(xdr, 4 + newname->len); p = reserve_space(xdr, 4 + newname->len);
*p++ = cpu_to_be32(newname->len); *p++ = cpu_to_be32(newname->len);
p = xdr_encode_opaque_fixed(p, newname->name, newname->len); xdr_encode_opaque_fixed(p, newname->name, newname->len);
hdr->nops++; hdr->nops++;
hdr->replen += decode_rename_maxsz; hdr->replen += decode_rename_maxsz;
} }
@ -1401,7 +1401,7 @@ static void encode_renew(struct xdr_stream *xdr, const struct nfs_client *client
p = reserve_space(xdr, 12); p = reserve_space(xdr, 12);
*p++ = cpu_to_be32(OP_RENEW); *p++ = cpu_to_be32(OP_RENEW);
p = xdr_encode_hyper(p, client_stateid->cl_clientid); xdr_encode_hyper(p, client_stateid->cl_clientid);
hdr->nops++; hdr->nops++;
hdr->replen += decode_renew_maxsz; hdr->replen += decode_renew_maxsz;
} }
@ -1412,7 +1412,7 @@ encode_restorefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
__be32 *p; __be32 *p;
p = reserve_space(xdr, 4); p = reserve_space(xdr, 4);
*p++ = cpu_to_be32(OP_RESTOREFH); *p = cpu_to_be32(OP_RESTOREFH);
hdr->nops++; hdr->nops++;
hdr->replen += decode_restorefh_maxsz; hdr->replen += decode_restorefh_maxsz;
} }
@ -1424,14 +1424,14 @@ encode_setacl(struct xdr_stream *xdr, struct nfs_setaclargs *arg, struct compoun
p = reserve_space(xdr, 4+NFS4_STATEID_SIZE); p = reserve_space(xdr, 4+NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(OP_SETATTR); *p++ = cpu_to_be32(OP_SETATTR);
p = xdr_encode_opaque_fixed(p, zero_stateid.data, NFS4_STATEID_SIZE); xdr_encode_opaque_fixed(p, zero_stateid.data, NFS4_STATEID_SIZE);
p = reserve_space(xdr, 2*4); p = reserve_space(xdr, 2*4);
*p++ = cpu_to_be32(1); *p++ = cpu_to_be32(1);
*p++ = cpu_to_be32(FATTR4_WORD0_ACL); *p = cpu_to_be32(FATTR4_WORD0_ACL);
if (arg->acl_len % 4) if (arg->acl_len % 4)
return -EINVAL; return -EINVAL;
p = reserve_space(xdr, 4); p = reserve_space(xdr, 4);
*p++ = cpu_to_be32(arg->acl_len); *p = cpu_to_be32(arg->acl_len);
xdr_write_pages(xdr, arg->acl_pages, arg->acl_pgbase, arg->acl_len); xdr_write_pages(xdr, arg->acl_pages, arg->acl_pgbase, arg->acl_len);
hdr->nops++; hdr->nops++;
hdr->replen += decode_setacl_maxsz; hdr->replen += decode_setacl_maxsz;
@ -1444,7 +1444,7 @@ encode_savefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
__be32 *p; __be32 *p;
p = reserve_space(xdr, 4); p = reserve_space(xdr, 4);
*p++ = cpu_to_be32(OP_SAVEFH); *p = cpu_to_be32(OP_SAVEFH);
hdr->nops++; hdr->nops++;
hdr->replen += decode_savefh_maxsz; hdr->replen += decode_savefh_maxsz;
} }
@ -1455,7 +1455,7 @@ static void encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs
p = reserve_space(xdr, 4+NFS4_STATEID_SIZE); p = reserve_space(xdr, 4+NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(OP_SETATTR); *p++ = cpu_to_be32(OP_SETATTR);
p = xdr_encode_opaque_fixed(p, arg->stateid.data, NFS4_STATEID_SIZE); xdr_encode_opaque_fixed(p, arg->stateid.data, NFS4_STATEID_SIZE);
hdr->nops++; hdr->nops++;
hdr->replen += decode_setattr_maxsz; hdr->replen += decode_setattr_maxsz;
encode_attrs(xdr, arg->iap, server); encode_attrs(xdr, arg->iap, server);
@ -1467,15 +1467,15 @@ static void encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclie
p = reserve_space(xdr, 4 + NFS4_VERIFIER_SIZE); p = reserve_space(xdr, 4 + NFS4_VERIFIER_SIZE);
*p++ = cpu_to_be32(OP_SETCLIENTID); *p++ = cpu_to_be32(OP_SETCLIENTID);
p = xdr_encode_opaque_fixed(p, setclientid->sc_verifier->data, NFS4_VERIFIER_SIZE); xdr_encode_opaque_fixed(p, setclientid->sc_verifier->data, NFS4_VERIFIER_SIZE);
encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name); encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name);
p = reserve_space(xdr, 4); p = reserve_space(xdr, 4);
*p++ = cpu_to_be32(setclientid->sc_prog); *p = cpu_to_be32(setclientid->sc_prog);
encode_string(xdr, setclientid->sc_netid_len, setclientid->sc_netid); encode_string(xdr, setclientid->sc_netid_len, setclientid->sc_netid);
encode_string(xdr, setclientid->sc_uaddr_len, setclientid->sc_uaddr); encode_string(xdr, setclientid->sc_uaddr_len, setclientid->sc_uaddr);
p = reserve_space(xdr, 4); p = reserve_space(xdr, 4);
*p++ = cpu_to_be32(setclientid->sc_cb_ident); *p = cpu_to_be32(setclientid->sc_cb_ident);
hdr->nops++; hdr->nops++;
hdr->replen += decode_setclientid_maxsz; hdr->replen += decode_setclientid_maxsz;
} }
@ -1487,7 +1487,7 @@ static void encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs_
p = reserve_space(xdr, 12 + NFS4_VERIFIER_SIZE); p = reserve_space(xdr, 12 + NFS4_VERIFIER_SIZE);
*p++ = cpu_to_be32(OP_SETCLIENTID_CONFIRM); *p++ = cpu_to_be32(OP_SETCLIENTID_CONFIRM);
p = xdr_encode_hyper(p, client_state->cl_clientid); p = xdr_encode_hyper(p, client_state->cl_clientid);
p = xdr_encode_opaque_fixed(p, client_state->cl_confirm.data, NFS4_VERIFIER_SIZE); xdr_encode_opaque_fixed(p, client_state->cl_confirm.data, NFS4_VERIFIER_SIZE);
hdr->nops++; hdr->nops++;
hdr->replen += decode_setclientid_confirm_maxsz; hdr->replen += decode_setclientid_confirm_maxsz;
} }
@ -1497,14 +1497,14 @@ static void encode_write(struct xdr_stream *xdr, const struct nfs_writeargs *arg
__be32 *p; __be32 *p;
p = reserve_space(xdr, 4); p = reserve_space(xdr, 4);
*p++ = cpu_to_be32(OP_WRITE); *p = cpu_to_be32(OP_WRITE);
encode_stateid(xdr, args->context); encode_stateid(xdr, args->context);
p = reserve_space(xdr, 16); p = reserve_space(xdr, 16);
p = xdr_encode_hyper(p, args->offset); p = xdr_encode_hyper(p, args->offset);
*p++ = cpu_to_be32(args->stable); *p++ = cpu_to_be32(args->stable);
*p++ = cpu_to_be32(args->count); *p = cpu_to_be32(args->count);
xdr_write_pages(xdr, args->pages, args->pgbase, args->count); xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
hdr->nops++; hdr->nops++;
@ -1518,7 +1518,7 @@ static void encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *state
p = reserve_space(xdr, 4+NFS4_STATEID_SIZE); p = reserve_space(xdr, 4+NFS4_STATEID_SIZE);
*p++ = cpu_to_be32(OP_DELEGRETURN); *p++ = cpu_to_be32(OP_DELEGRETURN);
p = xdr_encode_opaque_fixed(p, stateid->data, NFS4_STATEID_SIZE); xdr_encode_opaque_fixed(p, stateid->data, NFS4_STATEID_SIZE);
hdr->nops++; hdr->nops++;
hdr->replen += decode_delegreturn_maxsz; hdr->replen += decode_delegreturn_maxsz;
} }
@ -1533,14 +1533,14 @@ static void encode_exchange_id(struct xdr_stream *xdr,
p = reserve_space(xdr, 4 + sizeof(args->verifier->data)); p = reserve_space(xdr, 4 + sizeof(args->verifier->data));
*p++ = cpu_to_be32(OP_EXCHANGE_ID); *p++ = cpu_to_be32(OP_EXCHANGE_ID);
p = xdr_encode_opaque_fixed(p, args->verifier->data, sizeof(args->verifier->data)); xdr_encode_opaque_fixed(p, args->verifier->data, sizeof(args->verifier->data));
encode_string(xdr, args->id_len, args->id); encode_string(xdr, args->id_len, args->id);
p = reserve_space(xdr, 12); p = reserve_space(xdr, 12);
*p++ = cpu_to_be32(args->flags); *p++ = cpu_to_be32(args->flags);
*p++ = cpu_to_be32(0); /* zero length state_protect4_a */ *p++ = cpu_to_be32(0); /* zero length state_protect4_a */
*p++ = cpu_to_be32(0); /* zero length implementation id array */ *p = cpu_to_be32(0); /* zero length implementation id array */
hdr->nops++; hdr->nops++;
hdr->replen += decode_exchange_id_maxsz; hdr->replen += decode_exchange_id_maxsz;
} }
@ -1591,7 +1591,7 @@ static void encode_create_session(struct xdr_stream *xdr,
p = xdr_encode_opaque_fixed(p, machine_name, len); p = xdr_encode_opaque_fixed(p, machine_name, len);
*p++ = cpu_to_be32(0); /* UID */ *p++ = cpu_to_be32(0); /* UID */
*p++ = cpu_to_be32(0); /* GID */ *p++ = cpu_to_be32(0); /* GID */
*p++ = cpu_to_be32(0); /* No more gids */ *p = cpu_to_be32(0); /* No more gids */
hdr->nops++; hdr->nops++;
hdr->replen += decode_create_session_maxsz; hdr->replen += decode_create_session_maxsz;
} }
@ -1603,7 +1603,7 @@ static void encode_destroy_session(struct xdr_stream *xdr,
__be32 *p; __be32 *p;
p = reserve_space(xdr, 4 + NFS4_MAX_SESSIONID_LEN); p = reserve_space(xdr, 4 + NFS4_MAX_SESSIONID_LEN);
*p++ = cpu_to_be32(OP_DESTROY_SESSION); *p++ = cpu_to_be32(OP_DESTROY_SESSION);
p = xdr_encode_opaque_fixed(p, session->sess_id.data, NFS4_MAX_SESSIONID_LEN); xdr_encode_opaque_fixed(p, session->sess_id.data, NFS4_MAX_SESSIONID_LEN);
hdr->nops++; hdr->nops++;
hdr->replen += decode_destroy_session_maxsz; hdr->replen += decode_destroy_session_maxsz;
} }
@ -1646,7 +1646,7 @@ static void encode_sequence(struct xdr_stream *xdr,
*p++ = cpu_to_be32(slot->seq_nr); *p++ = cpu_to_be32(slot->seq_nr);
*p++ = cpu_to_be32(args->sa_slotid); *p++ = cpu_to_be32(args->sa_slotid);
*p++ = cpu_to_be32(tp->highest_used_slotid); *p++ = cpu_to_be32(tp->highest_used_slotid);
*p++ = cpu_to_be32(args->sa_cache_this); *p = cpu_to_be32(args->sa_cache_this);
hdr->nops++; hdr->nops++;
hdr->replen += decode_sequence_maxsz; hdr->replen += decode_sequence_maxsz;
#endif /* CONFIG_NFS_V4_1 */ #endif /* CONFIG_NFS_V4_1 */