Skip to content

L
linux
Commit c373b0a4 authored by J. Bruce Fields's avatar J. Bruce Fields
Browse files
Options

nfsd4: kill WRITE32 

These macros just obscure what's going on.  Adopt the convention of the
client-side code.
Signed-off-by: default avatarJ. Bruce Fields <bfields@redhat.com>
parent c8f13d97
Show whitespace changes
Inline Side-by-side
Showing with 154 additions and 152 deletions
fs/nfsd/nfs4xdr.c
View file @ c373b0a4
...@@ -1683,7 +1683,6 @@ nfsd4_decode_compound(struct nfsd4_compoundargs *argp) ...@@ -1683,7 +1683,6 @@ nfsd4_decode_compound(struct nfsd4_compoundargs *argp)
DECODE_TAIL; DECODE_TAIL;
} }
#define WRITE32(n) *p++ = htonl(n)
#define WRITE64(n) do { \ #define WRITE64(n) do { \
*p++ = htonl((u32)((n) >> 32)); \ *p++ = htonl((u32)((n) >> 32)); \
*p++ = htonl((u32)(n)); \ *p++ = htonl((u32)(n)); \
...@@ -1774,7 +1773,7 @@ static __be32 nfsd4_encode_components_esc(struct xdr_stream *xdr, char sep, ...@@ -1774,7 +1773,7 @@ static __be32 nfsd4_encode_components_esc(struct xdr_stream *xdr, char sep,
p = xdr_reserve_space(xdr, strlen + 4); p = xdr_reserve_space(xdr, strlen + 4);
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITE32(strlen); *p++ = cpu_to_be32(strlen);
WRITEMEM(str, strlen); WRITEMEM(str, strlen);
count++; count++;
} }
...@@ -1857,7 +1856,7 @@ static __be32 nfsd4_encode_path(struct xdr_stream *xdr, ...@@ -1857,7 +1856,7 @@ static __be32 nfsd4_encode_path(struct xdr_stream *xdr,
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_free; goto out_free;
WRITE32(ncomponents); *p++ = cpu_to_be32(ncomponents);
while (ncomponents) { while (ncomponents) {
struct dentry *dentry = components[ncomponents - 1]; struct dentry *dentry = components[ncomponents - 1];
...@@ -1870,7 +1869,7 @@ static __be32 nfsd4_encode_path(struct xdr_stream *xdr, ...@@ -1870,7 +1869,7 @@ static __be32 nfsd4_encode_path(struct xdr_stream *xdr,
spin_unlock(&dentry->d_lock); spin_unlock(&dentry->d_lock);
goto out_free; goto out_free;
} }
WRITE32(len); *p++ = cpu_to_be32(len);
WRITEMEM(dentry->d_name.name, len); WRITEMEM(dentry->d_name.name, len);
dprintk("/%s", dentry->d_name.name); dprintk("/%s", dentry->d_name.name);
spin_unlock(&dentry->d_lock); spin_unlock(&dentry->d_lock);
...@@ -1919,7 +1918,7 @@ static __be32 nfsd4_encode_fs_locations(struct xdr_stream *xdr, ...@@ -1919,7 +1918,7 @@ static __be32 nfsd4_encode_fs_locations(struct xdr_stream *xdr,
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITE32(fslocs->locations_count); *p++ = cpu_to_be32(fslocs->locations_count);
for (i=0; i<fslocs->locations_count; i++) { for (i=0; i<fslocs->locations_count; i++) {
status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]); status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]);
if (status) if (status)
...@@ -1973,8 +1972,8 @@ nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp, ...@@ -1973,8 +1972,8 @@ nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp,
* For now we use a 0 here to indicate the null translation; in * For now we use a 0 here to indicate the null translation; in
* the future we may place a call to translation code here. * the future we may place a call to translation code here.
*/ */
WRITE32(0); /* lfs */ *p++ = cpu_to_be32(0); /* lfs */
WRITE32(0); /* pi */ *p++ = cpu_to_be32(0); /* pi */
p = xdr_encode_opaque(p, context, len); p = xdr_encode_opaque(p, context, len);
return 0; return 0;
} }
...@@ -2123,23 +2122,23 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, ...@@ -2123,23 +2122,23 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
p = xdr_reserve_space(xdr, 16); p = xdr_reserve_space(xdr, 16);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(3); *p++ = cpu_to_be32(3);
WRITE32(bmval0); *p++ = cpu_to_be32(bmval0);
WRITE32(bmval1); *p++ = cpu_to_be32(bmval1);
WRITE32(bmval2); *p++ = cpu_to_be32(bmval2);
} else if (bmval1) { } else if (bmval1) {
p = xdr_reserve_space(xdr, 12); p = xdr_reserve_space(xdr, 12);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(2); *p++ = cpu_to_be32(2);
WRITE32(bmval0); *p++ = cpu_to_be32(bmval0);
WRITE32(bmval1); *p++ = cpu_to_be32(bmval1);
} else { } else {
p = xdr_reserve_space(xdr, 8); p = xdr_reserve_space(xdr, 8);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(1); *p++ = cpu_to_be32(1);
WRITE32(bmval0); *p++ = cpu_to_be32(bmval0);
} }
attrlen_offset = xdr->buf->len; attrlen_offset = xdr->buf->len;
...@@ -2161,17 +2160,17 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, ...@@ -2161,17 +2160,17 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
p = xdr_reserve_space(xdr, 12); p = xdr_reserve_space(xdr, 12);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(2); *p++ = cpu_to_be32(2);
WRITE32(word0); *p++ = cpu_to_be32(word0);
WRITE32(word1); *p++ = cpu_to_be32(word1);
} else { } else {
p = xdr_reserve_space(xdr, 16); p = xdr_reserve_space(xdr, 16);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(3); *p++ = cpu_to_be32(3);
WRITE32(word0); *p++ = cpu_to_be32(word0);
WRITE32(word1); *p++ = cpu_to_be32(word1);
WRITE32(word2); *p++ = cpu_to_be32(word2);
} }
} }
if (bmval0 & FATTR4_WORD0_TYPE) { if (bmval0 & FATTR4_WORD0_TYPE) {
...@@ -2183,16 +2182,17 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, ...@@ -2183,16 +2182,17 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
status = nfserr_serverfault; status = nfserr_serverfault;
goto out; goto out;
} }
WRITE32(dummy); *p++ = cpu_to_be32(dummy);
} }
if (bmval0 & FATTR4_WORD0_FH_EXPIRE_TYPE) { if (bmval0 & FATTR4_WORD0_FH_EXPIRE_TYPE) {
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
if (exp->ex_flags & NFSEXP_NOSUBTREECHECK) if (exp->ex_flags & NFSEXP_NOSUBTREECHECK)
WRITE32(NFS4_FH_PERSISTENT); *p++ = cpu_to_be32(NFS4_FH_PERSISTENT);
else else
WRITE32(NFS4_FH_PERSISTENT|NFS4_FH_VOL_RENAME); *p++ = cpu_to_be32(NFS4_FH_PERSISTENT|
NFS4_FH_VOL_RENAME);
} }
if (bmval0 & FATTR4_WORD0_CHANGE) { if (bmval0 & FATTR4_WORD0_CHANGE) {
p = xdr_reserve_space(xdr, 8); p = xdr_reserve_space(xdr, 8);
...@@ -2210,19 +2210,19 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, ...@@ -2210,19 +2210,19 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(1); *p++ = cpu_to_be32(1);
} }
if (bmval0 & FATTR4_WORD0_SYMLINK_SUPPORT) { if (bmval0 & FATTR4_WORD0_SYMLINK_SUPPORT) {
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(1); *p++ = cpu_to_be32(1);
} }
if (bmval0 & FATTR4_WORD0_NAMED_ATTR) { if (bmval0 & FATTR4_WORD0_NAMED_ATTR) {
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(0); *p++ = cpu_to_be32(0);
} }
if (bmval0 & FATTR4_WORD0_FSID) { if (bmval0 & FATTR4_WORD0_FSID) {
p = xdr_reserve_space(xdr, 16); p = xdr_reserve_space(xdr, 16);
...@@ -2237,10 +2237,10 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, ...@@ -2237,10 +2237,10 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
WRITE64((u64)0); WRITE64((u64)0);
break; break;
case FSIDSOURCE_DEV: case FSIDSOURCE_DEV:
WRITE32(0); *p++ = cpu_to_be32(0);
WRITE32(MAJOR(stat.dev)); *p++ = cpu_to_be32(MAJOR(stat.dev));
WRITE32(0); *p++ = cpu_to_be32(0);
WRITE32(MINOR(stat.dev)); *p++ = cpu_to_be32(MINOR(stat.dev));
break; break;
case FSIDSOURCE_UUID: case FSIDSOURCE_UUID:
WRITEMEM(exp->ex_uuid, 16); WRITEMEM(exp->ex_uuid, 16);
...@@ -2251,19 +2251,19 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, ...@@ -2251,19 +2251,19 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(0); *p++ = cpu_to_be32(0);
} }
if (bmval0 & FATTR4_WORD0_LEASE_TIME) { if (bmval0 & FATTR4_WORD0_LEASE_TIME) {
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(nn->nfsd4_lease); *p++ = cpu_to_be32(nn->nfsd4_lease);
} }
if (bmval0 & FATTR4_WORD0_RDATTR_ERROR) { if (bmval0 & FATTR4_WORD0_RDATTR_ERROR) {
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(rdattr_err); *p++ = cpu_to_be32(rdattr_err);
} }
if (bmval0 & FATTR4_WORD0_ACL) { if (bmval0 & FATTR4_WORD0_ACL) {
struct nfs4_ace *ace; struct nfs4_ace *ace;
...@@ -2273,21 +2273,22 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, ...@@ -2273,21 +2273,22 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(0); *p++ = cpu_to_be32(0);
goto out_acl; goto out_acl;
} }
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(acl->naces); *p++ = cpu_to_be32(acl->naces);
for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) { for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) {
p = xdr_reserve_space(xdr, 4*3); p = xdr_reserve_space(xdr, 4*3);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(ace->type); *p++ = cpu_to_be32(ace->type);
WRITE32(ace->flag); *p++ = cpu_to_be32(ace->flag);
WRITE32(ace->access_mask & NFS4_ACE_MASK_ALL); *p++ = cpu_to_be32(ace->access_mask &
NFS4_ACE_MASK_ALL);
status = nfsd4_encode_aclname(xdr, rqstp, ace); status = nfsd4_encode_aclname(xdr, rqstp, ace);
if (status) if (status)
goto out; goto out;
...@@ -2298,38 +2299,38 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, ...@@ -2298,38 +2299,38 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(aclsupport ? *p++ = cpu_to_be32(aclsupport ?
ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL : 0); ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL : 0);
} }
if (bmval0 & FATTR4_WORD0_CANSETTIME) { if (bmval0 & FATTR4_WORD0_CANSETTIME) {
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(1); *p++ = cpu_to_be32(1);
} }
if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) { if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) {
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(0); *p++ = cpu_to_be32(0);
} }
if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) { if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) {
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(1); *p++ = cpu_to_be32(1);
} }
if (bmval0 & FATTR4_WORD0_CHOWN_RESTRICTED) { if (bmval0 & FATTR4_WORD0_CHOWN_RESTRICTED) {
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(1); *p++ = cpu_to_be32(1);
} }
if (bmval0 & FATTR4_WORD0_FILEHANDLE) { if (bmval0 & FATTR4_WORD0_FILEHANDLE) {
p = xdr_reserve_space(xdr, fhp->fh_handle.fh_size + 4); p = xdr_reserve_space(xdr, fhp->fh_handle.fh_size + 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(fhp->fh_handle.fh_size); *p++ = cpu_to_be32(fhp->fh_handle.fh_size);
WRITEMEM(&fhp->fh_handle.fh_base, fhp->fh_handle.fh_size); WRITEMEM(&fhp->fh_handle.fh_base, fhp->fh_handle.fh_size);
} }
if (bmval0 & FATTR4_WORD0_FILEID) { if (bmval0 & FATTR4_WORD0_FILEID) {
...@@ -2365,7 +2366,7 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, ...@@ -2365,7 +2366,7 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(1); *p++ = cpu_to_be32(1);
} }
if (bmval0 & FATTR4_WORD0_MAXFILESIZE) { if (bmval0 & FATTR4_WORD0_MAXFILESIZE) {
p = xdr_reserve_space(xdr, 8); p = xdr_reserve_space(xdr, 8);
...@@ -2377,13 +2378,13 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, ...@@ -2377,13 +2378,13 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(255); *p++ = cpu_to_be32(255);
} }
if (bmval0 & FATTR4_WORD0_MAXNAME) { if (bmval0 & FATTR4_WORD0_MAXNAME) {
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(statfs.f_namelen); *p++ = cpu_to_be32(statfs.f_namelen);
} }
if (bmval0 & FATTR4_WORD0_MAXREAD) { if (bmval0 & FATTR4_WORD0_MAXREAD) {
p = xdr_reserve_space(xdr, 8); p = xdr_reserve_space(xdr, 8);
...@@ -2401,19 +2402,19 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, ...@@ -2401,19 +2402,19 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(stat.mode & S_IALLUGO); *p++ = cpu_to_be32(stat.mode & S_IALLUGO);
} }
if (bmval1 & FATTR4_WORD1_NO_TRUNC) { if (bmval1 & FATTR4_WORD1_NO_TRUNC) {
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(1); *p++ = cpu_to_be32(1);
} }
if (bmval1 & FATTR4_WORD1_NUMLINKS) { if (bmval1 & FATTR4_WORD1_NUMLINKS) {
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(stat.nlink); *p++ = cpu_to_be32(stat.nlink);
} }
if (bmval1 & FATTR4_WORD1_OWNER) { if (bmval1 & FATTR4_WORD1_OWNER) {
status = nfsd4_encode_user(xdr, rqstp, stat.uid); status = nfsd4_encode_user(xdr, rqstp, stat.uid);
...@@ -2429,8 +2430,8 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, ...@@ -2429,8 +2430,8 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
p = xdr_reserve_space(xdr, 8); p = xdr_reserve_space(xdr, 8);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32((u32) MAJOR(stat.rdev)); *p++ = cpu_to_be32((u32) MAJOR(stat.rdev));
WRITE32((u32) MINOR(stat.rdev)); *p++ = cpu_to_be32((u32) MINOR(stat.rdev));
} }
if (bmval1 & FATTR4_WORD1_SPACE_AVAIL) { if (bmval1 & FATTR4_WORD1_SPACE_AVAIL) {
p = xdr_reserve_space(xdr, 8); p = xdr_reserve_space(xdr, 8);
...@@ -2465,29 +2466,29 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, ...@@ -2465,29 +2466,29 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE64((s64)stat.atime.tv_sec); WRITE64((s64)stat.atime.tv_sec);
WRITE32(stat.atime.tv_nsec); *p++ = cpu_to_be32(stat.atime.tv_nsec);
} }
if (bmval1 & FATTR4_WORD1_TIME_DELTA) { if (bmval1 & FATTR4_WORD1_TIME_DELTA) {
p = xdr_reserve_space(xdr, 12); p = xdr_reserve_space(xdr, 12);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(0); *p++ = cpu_to_be32(0);
WRITE32(1); *p++ = cpu_to_be32(1);
WRITE32(0); *p++ = cpu_to_be32(0);
} }
if (bmval1 & FATTR4_WORD1_TIME_METADATA) { if (bmval1 & FATTR4_WORD1_TIME_METADATA) {
p = xdr_reserve_space(xdr, 12); p = xdr_reserve_space(xdr, 12);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE64((s64)stat.ctime.tv_sec); WRITE64((s64)stat.ctime.tv_sec);
WRITE32(stat.ctime.tv_nsec); *p++ = cpu_to_be32(stat.ctime.tv_nsec);
} }
if (bmval1 & FATTR4_WORD1_TIME_MODIFY) { if (bmval1 & FATTR4_WORD1_TIME_MODIFY) {
p = xdr_reserve_space(xdr, 12); p = xdr_reserve_space(xdr, 12);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE64((s64)stat.mtime.tv_sec); WRITE64((s64)stat.mtime.tv_sec);
WRITE32(stat.mtime.tv_nsec); *p++ = cpu_to_be32(stat.mtime.tv_nsec);
} }
if (bmval1 & FATTR4_WORD1_MOUNTED_ON_FILEID) { if (bmval1 & FATTR4_WORD1_MOUNTED_ON_FILEID) {
p = xdr_reserve_space(xdr, 8); p = xdr_reserve_space(xdr, 8);
...@@ -2512,10 +2513,10 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, ...@@ -2512,10 +2513,10 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
p = xdr_reserve_space(xdr, 16); p = xdr_reserve_space(xdr, 16);
if (!p) if (!p)
goto out_resource; goto out_resource;
WRITE32(3); *p++ = cpu_to_be32(3);
WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD0); *p++ = cpu_to_be32(NFSD_SUPPATTR_EXCLCREAT_WORD0);
WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD1); *p++ = cpu_to_be32(NFSD_SUPPATTR_EXCLCREAT_WORD1);
WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD2); *p++ = cpu_to_be32(NFSD_SUPPATTR_EXCLCREAT_WORD2);
} }
attrlen = htonl(xdr->buf->len - attrlen_offset - 4); attrlen = htonl(xdr->buf->len - attrlen_offset - 4);
...@@ -2750,7 +2751,7 @@ nfsd4_encode_stateid(struct xdr_stream *xdr, stateid_t *sid) ...@@ -2750,7 +2751,7 @@ nfsd4_encode_stateid(struct xdr_stream *xdr, stateid_t *sid)
p = xdr_reserve_space(xdr, sizeof(stateid_t)); p = xdr_reserve_space(xdr, sizeof(stateid_t));
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITE32(sid->si_generation); *p++ = cpu_to_be32(sid->si_generation);
WRITEMEM(&sid->si_opaque, sizeof(stateid_opaque_t)); WRITEMEM(&sid->si_opaque, sizeof(stateid_opaque_t));
return 0; return 0;
} }
...@@ -2765,8 +2766,8 @@ nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_ ...@@ -2765,8 +2766,8 @@ nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_
p = xdr_reserve_space(xdr, 8); p = xdr_reserve_space(xdr, 8);
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITE32(access->ac_supported); *p++ = cpu_to_be32(access->ac_supported);
WRITE32(access->ac_resp_access); *p++ = cpu_to_be32(access->ac_resp_access);
} }
return nfserr; return nfserr;
} }
...@@ -2781,9 +2782,9 @@ static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, ...@@ -2781,9 +2782,9 @@ static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp,
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITEMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN); WRITEMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN);
WRITE32(bcts->dir); *p++ = cpu_to_be32(bcts->dir);
/* Sorry, we do not yet support RDMA over 4.1: */ /* Sorry, we do not yet support RDMA over 4.1: */
WRITE32(0); *p++ = cpu_to_be32(0);
} }
return nfserr; return nfserr;
} }
...@@ -2826,9 +2827,9 @@ nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_ ...@@ -2826,9 +2827,9 @@ nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
write_cinfo(&p, &create->cr_cinfo); write_cinfo(&p, &create->cr_cinfo);
WRITE32(2); *p++ = cpu_to_be32(2);
WRITE32(create->cr_bmval[0]); *p++ = cpu_to_be32(create->cr_bmval[0]);
WRITE32(create->cr_bmval[1]); *p++ = cpu_to_be32(create->cr_bmval[1]);
} }
return nfserr; return nfserr;
} }
...@@ -2861,7 +2862,7 @@ nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh ...@@ -2861,7 +2862,7 @@ nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh
p = xdr_reserve_space(xdr, len + 4); p = xdr_reserve_space(xdr, len + 4);
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITE32(len); *p++ = cpu_to_be32(len);
WRITEMEM(&fhp->fh_handle.fh_base, len); WRITEMEM(&fhp->fh_handle.fh_base, len);
} }
return nfserr; return nfserr;
...@@ -2893,14 +2894,14 @@ nfsd4_encode_lock_denied(struct xdr_stream *xdr, struct nfsd4_lock_denied *ld) ...@@ -2893,14 +2894,14 @@ nfsd4_encode_lock_denied(struct xdr_stream *xdr, struct nfsd4_lock_denied *ld)
} }
WRITE64(ld->ld_start); WRITE64(ld->ld_start);
WRITE64(ld->ld_length); WRITE64(ld->ld_length);
WRITE32(ld->ld_type); *p++ = cpu_to_be32(ld->ld_type);
if (conf->len) { if (conf->len) {
WRITEMEM(&ld->ld_clientid, 8); WRITEMEM(&ld->ld_clientid, 8);
WRITE32(conf->len); *p++ = cpu_to_be32(conf->len);
WRITEMEM(conf->data, conf->len); WRITEMEM(conf->data, conf->len);
} else { /* non - nfsv4 lock in conflict, no clientid nor owner */ } else { /* non - nfsv4 lock in conflict, no clientid nor owner */
WRITE64((u64)0); /* clientid */ WRITE64((u64)0); /* clientid */
WRITE32(0); /* length of owner name */ *p++ = cpu_to_be32(0); /* length of owner name */
} }
return nfserr_denied; return nfserr_denied;
} }
...@@ -2972,11 +2973,11 @@ nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_op ...@@ -2972,11 +2973,11 @@ nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_op
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
write_cinfo(&p, &open->op_cinfo); write_cinfo(&p, &open->op_cinfo);
WRITE32(open->op_rflags); *p++ = cpu_to_be32(open->op_rflags);
WRITE32(2); *p++ = cpu_to_be32(2);
WRITE32(open->op_bmval[0]); *p++ = cpu_to_be32(open->op_bmval[0]);
WRITE32(open->op_bmval[1]); *p++ = cpu_to_be32(open->op_bmval[1]);
WRITE32(open->op_delegate_type); *p++ = cpu_to_be32(open->op_delegate_type);
switch (open->op_delegate_type) { switch (open->op_delegate_type) {
case NFS4_OPEN_DELEGATE_NONE: case NFS4_OPEN_DELEGATE_NONE:
...@@ -2988,15 +2989,15 @@ nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_op ...@@ -2988,15 +2989,15 @@ nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_op
p = xdr_reserve_space(xdr, 20); p = xdr_reserve_space(xdr, 20);
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITE32(open->op_recall); *p++ = cpu_to_be32(open->op_recall);
/* /*
* TODO: ACE's in delegations * TODO: ACE's in delegations
*/ */
WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE); *p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
WRITE32(0); *p++ = cpu_to_be32(0);
WRITE32(0); *p++ = cpu_to_be32(0);
WRITE32(0); /* XXX: is NULL principal ok? */ *p++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */
break; break;
case NFS4_OPEN_DELEGATE_WRITE: case NFS4_OPEN_DELEGATE_WRITE:
nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid); nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid);
...@@ -3005,22 +3006,22 @@ nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_op ...@@ -3005,22 +3006,22 @@ nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_op
p = xdr_reserve_space(xdr, 32); p = xdr_reserve_space(xdr, 32);
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITE32(0); *p++ = cpu_to_be32(0);
/* /*
* TODO: space_limit's in delegations * TODO: space_limit's in delegations
*/ */
WRITE32(NFS4_LIMIT_SIZE); *p++ = cpu_to_be32(NFS4_LIMIT_SIZE);
WRITE32(~(u32)0); *p++ = cpu_to_be32(~(u32)0);
WRITE32(~(u32)0); *p++ = cpu_to_be32(~(u32)0);
/* /*
* TODO: ACE's in delegations * TODO: ACE's in delegations
*/ */
WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE); *p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
WRITE32(0); *p++ = cpu_to_be32(0);
WRITE32(0); *p++ = cpu_to_be32(0);
WRITE32(0); /* XXX: is NULL principal ok? */ *p++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */
break; break;
case NFS4_OPEN_DELEGATE_NONE_EXT: /* 4.1 */ case NFS4_OPEN_DELEGATE_NONE_EXT: /* 4.1 */
switch (open->op_why_no_deleg) { switch (open->op_why_no_deleg) {
...@@ -3029,14 +3030,15 @@ nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_op ...@@ -3029,14 +3030,15 @@ nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_op
p = xdr_reserve_space(xdr, 8); p = xdr_reserve_space(xdr, 8);
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITE32(open->op_why_no_deleg); *p++ = cpu_to_be32(open->op_why_no_deleg);
WRITE32(0); /* deleg signaling not supported yet */ /* deleg signaling not supported yet: */
*p++ = cpu_to_be32(0);
break; break;
default: default:
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITE32(open->op_why_no_deleg); *p++ = cpu_to_be32(open->op_why_no_deleg);
} }
break; break;
default: default:
...@@ -3310,8 +3312,8 @@ nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4 ...@@ -3310,8 +3312,8 @@ nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4
return nfserr_resource; return nfserr_resource;
/* XXX: Following NFSv3, we ignore the READDIR verifier for now. */ /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
WRITE32(0); *p++ = cpu_to_be32(0);
WRITE32(0); *p++ = cpu_to_be32(0);
resp->xdr.buf->head[0].iov_len = ((char *)resp->xdr.p) resp->xdr.buf->head[0].iov_len = ((char *)resp->xdr.p)
- (char *)resp->xdr.buf->head[0].iov_base; - (char *)resp->xdr.buf->head[0].iov_base;
...@@ -3460,17 +3462,17 @@ nfsd4_do_encode_secinfo(struct xdr_stream *xdr, ...@@ -3460,17 +3462,17 @@ nfsd4_do_encode_secinfo(struct xdr_stream *xdr,
XDR_LEN(info.oid.len) + 4 + 4); XDR_LEN(info.oid.len) + 4 + 4);
if (!p) if (!p)
goto out; goto out;
WRITE32(RPC_AUTH_GSS); *p++ = cpu_to_be32(RPC_AUTH_GSS);
WRITE32(info.oid.len); *p++ = cpu_to_be32(info.oid.len);
WRITEMEM(info.oid.data, info.oid.len); WRITEMEM(info.oid.data, info.oid.len);
WRITE32(info.qop); *p++ = cpu_to_be32(info.qop);
WRITE32(info.service); *p++ = cpu_to_be32(info.service);
} else if (pf < RPC_AUTH_MAXFLAVOR) { } else if (pf < RPC_AUTH_MAXFLAVOR) {
supported++; supported++;
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
goto out; goto out;
WRITE32(pf); *p++ = cpu_to_be32(pf);
} else { } else {
if (report) if (report)
pr_warn("NFS: SECINFO: security flavor %u " pr_warn("NFS: SECINFO: security flavor %u "
...@@ -3520,16 +3522,16 @@ nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4 ...@@ -3520,16 +3522,16 @@ nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
if (nfserr) { if (nfserr) {
WRITE32(3); *p++ = cpu_to_be32(3);
WRITE32(0); *p++ = cpu_to_be32(0);
WRITE32(0); *p++ = cpu_to_be32(0);
WRITE32(0); *p++ = cpu_to_be32(0);
} }
else { else {
WRITE32(3); *p++ = cpu_to_be32(3);
WRITE32(setattr->sa_bmval[0]); *p++ = cpu_to_be32(setattr->sa_bmval[0]);
WRITE32(setattr->sa_bmval[1]); *p++ = cpu_to_be32(setattr->sa_bmval[1]);
WRITE32(setattr->sa_bmval[2]); *p++ = cpu_to_be32(setattr->sa_bmval[2]);
} }
return nfserr; return nfserr;
} }
...@@ -3551,8 +3553,8 @@ nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, struct n ...@@ -3551,8 +3553,8 @@ nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, struct n
p = xdr_reserve_space(xdr, 8); p = xdr_reserve_space(xdr, 8);
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITE32(0); *p++ = cpu_to_be32(0);
WRITE32(0); *p++ = cpu_to_be32(0);
} }
return nfserr; return nfserr;
} }
...@@ -3567,8 +3569,8 @@ nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_w ...@@ -3567,8 +3569,8 @@ nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_w
p = xdr_reserve_space(xdr, 16); p = xdr_reserve_space(xdr, 16);
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITE32(write->wr_bytes_written); *p++ = cpu_to_be32(write->wr_bytes_written);
WRITE32(write->wr_how_written); *p++ = cpu_to_be32(write->wr_how_written);
WRITEMEM(write->wr_verifier.data, NFS4_VERIFIER_SIZE); WRITEMEM(write->wr_verifier.data, NFS4_VERIFIER_SIZE);
} }
return nfserr; return nfserr;
...@@ -3611,10 +3613,10 @@ nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr, ...@@ -3611,10 +3613,10 @@ nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr,
return nfserr_resource; return nfserr_resource;
WRITEMEM(&exid->clientid, 8); WRITEMEM(&exid->clientid, 8);
WRITE32(exid->seqid); *p++ = cpu_to_be32(exid->seqid);
WRITE32(exid->flags); *p++ = cpu_to_be32(exid->flags);
WRITE32(exid->spa_how); *p++ = cpu_to_be32(exid->spa_how);
switch (exid->spa_how) { switch (exid->spa_how) {
case SP4_NONE: case SP4_NONE:
...@@ -3626,11 +3628,11 @@ nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr, ...@@ -3626,11 +3628,11 @@ nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr,
return nfserr_resource; return nfserr_resource;
/* spo_must_enforce bitmap: */ /* spo_must_enforce bitmap: */
WRITE32(2); *p++ = cpu_to_be32(2);
WRITE32(nfs4_minimal_spo_must_enforce[0]); *p++ = cpu_to_be32(nfs4_minimal_spo_must_enforce[0]);
WRITE32(nfs4_minimal_spo_must_enforce[1]); *p++ = cpu_to_be32(nfs4_minimal_spo_must_enforce[1]);
/* empty spo_must_allow bitmap: */ /* empty spo_must_allow bitmap: */
WRITE32(0); *p++ = cpu_to_be32(0);
break; break;
default: default:
...@@ -3650,15 +3652,15 @@ nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr, ...@@ -3650,15 +3652,15 @@ nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr,
/* The server_owner struct */ /* The server_owner struct */
WRITE64(minor_id); /* Minor id */ WRITE64(minor_id); /* Minor id */
/* major id */ /* major id */
WRITE32(major_id_sz); *p++ = cpu_to_be32(major_id_sz);
WRITEMEM(major_id, major_id_sz); WRITEMEM(major_id, major_id_sz);
/* Server scope */ /* Server scope */
WRITE32(server_scope_sz); *p++ = cpu_to_be32(server_scope_sz);
WRITEMEM(server_scope, server_scope_sz); WRITEMEM(server_scope, server_scope_sz);
/* Implementation id */ /* Implementation id */
WRITE32(0); /* zero length nfs_impl_id4 array */ *p++ = cpu_to_be32(0); /* zero length nfs_impl_id4 array */
return 0; return 0;
} }
...@@ -3676,43 +3678,43 @@ nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr, ...@@ -3676,43 +3678,43 @@ nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr,
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITEMEM(sess->sessionid.data, NFS4_MAX_SESSIONID_LEN); WRITEMEM(sess->sessionid.data, NFS4_MAX_SESSIONID_LEN);
WRITE32(sess->seqid); *p++ = cpu_to_be32(sess->seqid);
WRITE32(sess->flags); *p++ = cpu_to_be32(sess->flags);
p = xdr_reserve_space(xdr, 28); p = xdr_reserve_space(xdr, 28);
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITE32(0); /* headerpadsz */ *p++ = cpu_to_be32(0); /* headerpadsz */
WRITE32(sess->fore_channel.maxreq_sz); *p++ = cpu_to_be32(sess->fore_channel.maxreq_sz);
WRITE32(sess->fore_channel.maxresp_sz); *p++ = cpu_to_be32(sess->fore_channel.maxresp_sz);
WRITE32(sess->fore_channel.maxresp_cached); *p++ = cpu_to_be32(sess->fore_channel.maxresp_cached);
WRITE32(sess->fore_channel.maxops); *p++ = cpu_to_be32(sess->fore_channel.maxops);
WRITE32(sess->fore_channel.maxreqs); *p++ = cpu_to_be32(sess->fore_channel.maxreqs);
WRITE32(sess->fore_channel.nr_rdma_attrs); *p++ = cpu_to_be32(sess->fore_channel.nr_rdma_attrs);
if (sess->fore_channel.nr_rdma_attrs) { if (sess->fore_channel.nr_rdma_attrs) {
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITE32(sess->fore_channel.rdma_attrs); *p++ = cpu_to_be32(sess->fore_channel.rdma_attrs);
} }
p = xdr_reserve_space(xdr, 28); p = xdr_reserve_space(xdr, 28);
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITE32(0); /* headerpadsz */ *p++ = cpu_to_be32(0); /* headerpadsz */
WRITE32(sess->back_channel.maxreq_sz); *p++ = cpu_to_be32(sess->back_channel.maxreq_sz);
WRITE32(sess->back_channel.maxresp_sz); *p++ = cpu_to_be32(sess->back_channel.maxresp_sz);
WRITE32(sess->back_channel.maxresp_cached); *p++ = cpu_to_be32(sess->back_channel.maxresp_cached);
WRITE32(sess->back_channel.maxops); *p++ = cpu_to_be32(sess->back_channel.maxops);
WRITE32(sess->back_channel.maxreqs); *p++ = cpu_to_be32(sess->back_channel.maxreqs);
WRITE32(sess->back_channel.nr_rdma_attrs); *p++ = cpu_to_be32(sess->back_channel.nr_rdma_attrs);
if (sess->back_channel.nr_rdma_attrs) { if (sess->back_channel.nr_rdma_attrs) {
p = xdr_reserve_space(xdr, 4); p = xdr_reserve_space(xdr, 4);
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITE32(sess->back_channel.rdma_attrs); *p++ = cpu_to_be32(sess->back_channel.rdma_attrs);
} }
return 0; return 0;
} }
...@@ -3731,12 +3733,12 @@ nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr, ...@@ -3731,12 +3733,12 @@ nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr,
if (!p) if (!p)
return nfserr_resource; return nfserr_resource;
WRITEMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN); WRITEMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN);
WRITE32(seq->seqid); *p++ = cpu_to_be32(seq->seqid);
WRITE32(seq->slotid); *p++ = cpu_to_be32(seq->slotid);
/* Note slotid's are numbered from zero: */ /* Note slotid's are numbered from zero: */
WRITE32(seq->maxslots - 1); /* sr_highest_slotid */ *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_highest_slotid */
WRITE32(seq->maxslots - 1); /* sr_target_highest_slotid */ *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_target_highest_slotid */
WRITE32(seq->status_flags); *p++ = cpu_to_be32(seq->status_flags);
resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */ resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */
return 0; return 0;
...@@ -3883,7 +3885,7 @@ nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op) ...@@ -3883,7 +3885,7 @@ nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op)
WARN_ON_ONCE(1); WARN_ON_ONCE(1);
return; return;
} }
WRITE32(op->opnum); *p++ = cpu_to_be32(op->opnum);
post_err_offset = xdr->buf->len; post_err_offset = xdr->buf->len;
if (op->opnum == OP_ILLEGAL) if (op->opnum == OP_ILLEGAL)
...@@ -3956,7 +3958,7 @@ nfsd4_encode_replay(struct xdr_stream *xdr, struct nfsd4_op *op) ...@@ -3956,7 +3958,7 @@ nfsd4_encode_replay(struct xdr_stream *xdr, struct nfsd4_op *op)
WARN_ON_ONCE(1); WARN_ON_ONCE(1);
return; return;
} }
WRITE32(op->opnum); *p++ = cpu_to_be32(op->opnum);
*p++ = rp->rp_status; /* already xdr'ed */ *p++ = rp->rp_status; /* already xdr'ed */
WRITEMEM(rp->rp_buf, rp->rp_buflen); WRITEMEM(rp->rp_buf, rp->rp_buflen);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7