static __be32 * encode_fattr3(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp, struct kstat *stat) { struct timespec ts; *p++ = htonl(nfs3_ftypes[(stat->mode & S_IFMT) >> 12]); *p++ = htonl((u32) (stat->mode & S_IALLUGO)); *p++ = htonl((u32) stat->nlink); *p++ = htonl((u32) from_kuid(&init_user_ns, stat->uid)); *p++ = htonl((u32) from_kgid(&init_user_ns, stat->gid)); if (S_ISLNK(stat->mode) && stat->size > NFS3_MAXPATHLEN) { p = xdr_encode_hyper(p, (u64) NFS3_MAXPATHLEN); } else { p = xdr_encode_hyper(p, (u64) stat->size); } p = xdr_encode_hyper(p, ((u64)stat->blocks) << 9); *p++ = htonl((u32) MAJOR(stat->rdev)); *p++ = htonl((u32) MINOR(stat->rdev)); p = encode_fsid(p, fhp); p = xdr_encode_hyper(p, stat->ino); ts = timespec64_to_timespec(stat->atime); p = encode_time3(p, &ts); ts = timespec64_to_timespec(stat->mtime); p = encode_time3(p, &ts); ts = timespec64_to_timespec(stat->ctime); p = encode_time3(p, &ts); return p; }
static int gssx_enc_cb(struct xdr_stream *xdr, struct gssx_cb *cb) { __be32 *p; int err; /* cb->initiator_addrtype */ p = xdr_reserve_space(xdr, 8); if (!p) return -ENOSPC; p = xdr_encode_hyper(p, cb->initiator_addrtype); /* cb->initiator_address */ err = gssx_enc_buffer(xdr, &cb->initiator_address); if (err) return err; /* cb->acceptor_addrtype */ p = xdr_reserve_space(xdr, 8); if (!p) return -ENOSPC; p = xdr_encode_hyper(p, cb->acceptor_addrtype); /* cb->acceptor_address */ err = gssx_enc_buffer(xdr, &cb->acceptor_address); if (err) return err; /* cb->application_data */ err = gssx_enc_buffer(xdr, &cb->application_data); return err; }
/* * Encode a lock as part of an NLM call */ static __be32 * nlm4_encode_lock(__be32 *p, struct nlm_lock *lock) { struct file_lock *fl = &lock->fl; __s64 start, len; if (!(p = xdr_encode_string(p, lock->caller)) || !(p = nlm4_encode_fh(p, &lock->fh)) || !(p = nlm4_encode_oh(p, &lock->oh))) return NULL; if (fl->fl_start > NLM4_OFFSET_MAX || (fl->fl_end > NLM4_OFFSET_MAX && fl->fl_end != OFFSET_MAX)) return NULL; *p++ = htonl(lock->svid); start = loff_t_to_s64(fl->fl_start); if (fl->fl_end == OFFSET_MAX) len = 0; else len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1); p = xdr_encode_hyper(p, start); p = xdr_encode_hyper(p, len); return p; }
static void nfs4_setup_readdir(struct nfs4_compound *cp, u64 cookie, u32 *verifier, struct page **pages, unsigned int bufsize, struct dentry *dentry) { u32 *start, *p; struct nfs4_readdir *readdir = GET_OP(cp, readdir); BUG_ON(bufsize < 80); readdir->rd_cookie = (cookie > 2) ? cookie : 0; memcpy(&readdir->rd_req_verifier, verifier, sizeof(readdir->rd_req_verifier)); readdir->rd_count = bufsize; readdir->rd_bmval[0] = FATTR4_WORD0_FILEID; readdir->rd_bmval[1] = 0; readdir->rd_pages = pages; readdir->rd_pgbase = 0; OPNUM(cp) = OP_READDIR; cp->req_nops++; if (cookie >= 2) return; /* * NFSv4 servers do not return entries for '.' and '..' * Therefore, we fake these entries here. We let '.' * have cookie 0 and '..' have cookie 1. Note that * when talking to the server, we always send cookie 0 * instead of 1 or 2. */ start = p = (u32 *)kmap_atomic(*pages, KM_USER0); if (cookie == 0) { *p++ = xdr_one; /* next */ *p++ = xdr_zero; /* cookie, first word */ *p++ = xdr_one; /* cookie, second word */ *p++ = xdr_one; /* entry len */ memcpy(p, ".\0\0\0", 4); /* entry */ p++; *p++ = xdr_one; /* bitmap length */ *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */ *p++ = htonl(8); /* attribute buffer length */ p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode)); } *p++ = xdr_one; /* next */ *p++ = xdr_zero; /* cookie, first word */ *p++ = xdr_two; /* cookie, second word */ *p++ = xdr_two; /* entry len */ memcpy(p, "..\0\0", 4); /* entry */ p++; *p++ = xdr_one; /* bitmap length */ *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */ *p++ = htonl(8); /* attribute buffer length */ p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode)); readdir->rd_pgbase = (char *)p - (char *)start; readdir->rd_count -= readdir->rd_pgbase; kunmap_atomic(start, KM_USER0); }
void pnfs_osd_xdr_encode_ioerr(__be32 *p, struct pnfs_osd_ioerr *ioerr) { p = pnfs_osd_xdr_encode_objid(p, &ioerr->oer_component); p = xdr_encode_hyper(p, ioerr->oer_comp_offset); p = xdr_encode_hyper(p, ioerr->oer_comp_length); *p++ = cpu_to_be32(ioerr->oer_iswrite); *p = cpu_to_be32(ioerr->oer_errno); }
static inline __be32 * pnfs_osd_xdr_encode_objid(__be32 *p, struct pnfs_osd_objid *object_id) { p = xdr_encode_opaque_fixed(p, &object_id->oid_device_id.data, sizeof(object_id->oid_device_id.data)); p = xdr_encode_hyper(p, object_id->oid_partition_id); p = xdr_encode_hyper(p, object_id->oid_object_id); return p; }
static __be32 * encode_entry_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name, int namlen, u64 ino) { *p++ = xdr_one; /* mark entry present */ p = xdr_encode_hyper(p, ino); /* file id */ p = xdr_encode_array(p, name, namlen);/* name length & name */ cd->offset = p; /* remember pointer */ p = xdr_encode_hyper(p, NFS_OFFSET_MAX);/* offset of next entry */ return p; }
static void encode_clone(struct xdr_stream *xdr, struct nfs42_clone_args *args, struct compound_hdr *hdr) { __be32 *p; encode_op_hdr(xdr, OP_CLONE, decode_clone_maxsz, hdr); encode_nfs4_stateid(xdr, &args->src_stateid); encode_nfs4_stateid(xdr, &args->dst_stateid); p = reserve_space(xdr, 3*8); p = xdr_encode_hyper(p, args->src_offset); p = xdr_encode_hyper(p, args->dst_offset); xdr_encode_hyper(p, args->count); }
/* * struct nlm4_holder { * bool exclusive; * int32 svid; * netobj oh; * uint64 l_offset; * uint64 l_len; * }; */ static void encode_nlm4_holder(struct xdr_stream *xdr, const struct nlm_res *result) { const struct nlm_lock *lock = &result->lock; u64 l_offset, l_len; __be32 *p; encode_bool(xdr, lock->fl.fl_type == F_RDLCK); encode_int32(xdr, lock->svid); encode_netobj(xdr, lock->oh.data, lock->oh.len); p = xdr_reserve_space(xdr, 4 + 4); nlm4_compute_offsets(lock, &l_offset, &l_len); p = xdr_encode_hyper(p, l_offset); xdr_encode_hyper(p, l_len); }
static void encode_sattr3(struct xdr_stream *xdr, const struct iattr *attr) { u32 nbytes; __be32 *p; nbytes = 6 * 4; if (attr->ia_valid & ATTR_MODE) nbytes += 4; if (attr->ia_valid & ATTR_UID) nbytes += 4; if (attr->ia_valid & ATTR_GID) nbytes += 4; if (attr->ia_valid & ATTR_SIZE) nbytes += 8; if (attr->ia_valid & ATTR_ATIME_SET) nbytes += 8; if (attr->ia_valid & ATTR_MTIME_SET) nbytes += 8; p = xdr_reserve_space(xdr, nbytes); if (attr->ia_valid & ATTR_MODE) { *p++ = xdr_one; *p++ = cpu_to_be32(attr->ia_mode & S_IALLUGO); } else *p++ = xdr_zero; if (attr->ia_valid & ATTR_UID) { *p++ = xdr_one; *p++ = cpu_to_be32(attr->ia_uid); } else *p++ = xdr_zero; if (attr->ia_valid & ATTR_GID) { *p++ = xdr_one; *p++ = cpu_to_be32(attr->ia_gid); } else *p++ = xdr_zero; if (attr->ia_valid & ATTR_SIZE) { *p++ = xdr_one; p = xdr_encode_hyper(p, (u64)attr->ia_size); } else *p++ = xdr_zero; if (attr->ia_valid & ATTR_ATIME_SET) { *p++ = xdr_two; p = xdr_encode_nfstime3(p, &attr->ia_atime); } else if (attr->ia_valid & ATTR_ATIME) { *p++ = xdr_one; } else *p++ = xdr_zero; if (attr->ia_valid & ATTR_MTIME_SET) { *p++ = xdr_two; xdr_encode_nfstime3(p, &attr->ia_mtime); } else if (attr->ia_valid & ATTR_MTIME) { *p = xdr_one; } else *p = xdr_zero; }
/* * struct nlm4_lock { * string caller_name<LM_MAXSTRLEN>; * netobj fh; * netobj oh; * int32 svid; * uint64 l_offset; * uint64 l_len; * }; */ static void encode_nlm4_lock(struct xdr_stream *xdr, const struct nlm_lock *lock) { u64 l_offset, l_len; __be32 *p; encode_caller_name(xdr, lock->caller); encode_fh(xdr, &lock->fh); encode_netobj(xdr, lock->oh.data, lock->oh.len); p = xdr_reserve_space(xdr, 4 + 8 + 8); *p++ = cpu_to_be32(lock->svid); nlm4_compute_offsets(lock, &l_offset, &l_len); p = xdr_encode_hyper(p, l_offset); xdr_encode_hyper(p, l_len); }
static inline u32 * encode_fattr3(struct svc_rqst *rqstp, u32 *p, struct svc_fh *fhp) { struct inode *inode = fhp->fh_dentry->d_inode; *p++ = htonl(nfs3_ftypes[(inode->i_mode & S_IFMT) >> 12]); *p++ = htonl((u32) inode->i_mode); *p++ = htonl((u32) inode->i_nlink); *p++ = htonl((u32) nfsd_ruid(rqstp, inode->i_uid)); *p++ = htonl((u32) nfsd_rgid(rqstp, inode->i_gid)); if (S_ISLNK(inode->i_mode) && inode->i_size > NFS3_MAXPATHLEN) { p = xdr_encode_hyper(p, (u64) NFS3_MAXPATHLEN); } else { p = xdr_encode_hyper(p, (u64) inode->i_size); } if (inode->i_blksize == 0 && inode->i_blocks == 0) /* Minix file system(?) i_size is (hopefully) close enough */ p = xdr_encode_hyper(p, (u64)(inode->i_size +511)& ~511); else p = xdr_encode_hyper(p, ((u64)inode->i_blocks) << 9); *p++ = htonl((u32) MAJOR(inode->i_rdev)); *p++ = htonl((u32) MINOR(inode->i_rdev)); if (rqstp->rq_reffh->fh_version == 1 && rqstp->rq_reffh->fh_fsid_type == 1 && (fhp->fh_export->ex_flags & NFSEXP_FSID)) p = xdr_encode_hyper(p, (u64) fhp->fh_export->ex_fsid); else p = xdr_encode_hyper(p, (u64) inode->i_dev); p = xdr_encode_hyper(p, (u64) inode->i_ino); p = encode_time3(p, inode->i_atime); p = encode_time3(p, lease_get_mtime(inode)); p = encode_time3(p, inode->i_ctime); return p; }
void svc_rdma_xdr_encode_array_chunk(struct rpcrdma_write_array *ary, int chunk_no, u32 rs_handle, u64 rs_offset, u32 write_len) { struct rpcrdma_segment *seg = &ary->wc_array[chunk_no].wc_target; seg->rs_handle = htonl(rs_handle); seg->rs_length = htonl(write_len); xdr_encode_hyper((u32 *) &seg->rs_offset, rs_offset); }
static __be32 *encode_fsid(__be32 *p, struct svc_fh *fhp) { u64 f; switch(fsid_source(fhp)) { default: case FSIDSOURCE_DEV: p = xdr_encode_hyper(p, (u64)huge_encode_dev (fhp->fh_dentry->d_inode->i_sb->s_dev)); break; case FSIDSOURCE_FSID: p = xdr_encode_hyper(p, (u64) fhp->fh_export->ex_fsid); break; case FSIDSOURCE_UUID: f = ((u64*)fhp->fh_export->ex_uuid)[0]; f ^= ((u64*)fhp->fh_export->ex_uuid)[1]; p = xdr_encode_hyper(p, f); break; } return p; }
static void encode_commit3args(struct xdr_stream *xdr, const struct nfs_writeargs *args) { __be32 *p; encode_nfs_fh3(xdr, args->fh); p = xdr_reserve_space(xdr, 8 + 4); p = xdr_encode_hyper(p, args->offset); *p = cpu_to_be32(args->count); }
static __be32 encode_attr_time(struct xdr_stream *xdr, const struct timespec *time) { __be32 *p; p = xdr_reserve_space(xdr, 12); if (unlikely(!p)) return htonl(NFS4ERR_RESOURCE); p = xdr_encode_hyper(p, time->tv_sec); *p = htonl(time->tv_nsec); return 0; }
static unsigned encode_attr_time(struct xdr_stream *xdr, const struct timespec *time) { uint32_t *p; p = xdr_reserve_space(xdr, 12); if (unlikely(p == 0)) return htonl(NFS4ERR_RESOURCE); p = xdr_encode_hyper(p, time->tv_sec); *p = htonl(time->tv_nsec); return 0; }
static unsigned encode_attr_size(struct xdr_stream *xdr, const uint32_t *bitmap, uint64_t size) { uint32_t *p; if (!(bitmap[0] & FATTR4_WORD0_SIZE)) return 0; p = xdr_reserve_space(xdr, 8); if (unlikely(p == 0)) return htonl(NFS4ERR_RESOURCE); p = xdr_encode_hyper(p, size); return 0; }
static __be32 encode_attr_change(struct xdr_stream *xdr, const uint32_t *bitmap, uint64_t change) { __be32 *p; if (!(bitmap[0] & FATTR4_WORD0_CHANGE)) return 0; p = xdr_reserve_space(xdr, 8); if (unlikely(p == 0)) return htonl(NFS4ERR_RESOURCE); p = xdr_encode_hyper(p, change); return 0; }
static void encode_layoutstats(struct xdr_stream *xdr, struct nfs42_layoutstat_args *args, struct nfs42_layoutstat_devinfo *devinfo, struct compound_hdr *hdr) { __be32 *p; encode_op_hdr(xdr, OP_LAYOUTSTATS, decode_layoutstats_maxsz, hdr); p = reserve_space(xdr, 8 + 8); p = xdr_encode_hyper(p, devinfo->offset); p = xdr_encode_hyper(p, devinfo->length); encode_nfs4_stateid(xdr, &args->stateid); p = reserve_space(xdr, 4*8 + NFS4_DEVICEID4_SIZE + 4); p = xdr_encode_hyper(p, devinfo->read_count); p = xdr_encode_hyper(p, devinfo->read_bytes); p = xdr_encode_hyper(p, devinfo->write_count); p = xdr_encode_hyper(p, devinfo->write_bytes); p = xdr_encode_opaque_fixed(p, devinfo->dev_id.data, NFS4_DEVICEID4_SIZE); /* Encode layoutupdate4 */ *p++ = cpu_to_be32(devinfo->layout_type); if (devinfo->layoutstats_encode != NULL) devinfo->layoutstats_encode(xdr, args, devinfo); else encode_uint32(xdr, 0); }
static inline u32 * encode_saved_post_attr(struct svc_rqst *rqstp, u32 *p, struct svc_fh *fhp) { struct inode *inode = fhp->fh_dentry->d_inode; /* Attributes to follow */ *p++ = xdr_one; *p++ = htonl(nfs3_ftypes[(fhp->fh_post_mode & S_IFMT) >> 12]); *p++ = htonl((u32) fhp->fh_post_mode); *p++ = htonl((u32) fhp->fh_post_nlink); *p++ = htonl((u32) nfsd_ruid(rqstp, fhp->fh_post_uid)); *p++ = htonl((u32) nfsd_rgid(rqstp, fhp->fh_post_gid)); if (S_ISLNK(fhp->fh_post_mode) && fhp->fh_post_size > NFS3_MAXPATHLEN) { p = xdr_encode_hyper(p, (u64) NFS3_MAXPATHLEN); } else { p = xdr_encode_hyper(p, (u64) fhp->fh_post_size); } p = xdr_encode_hyper(p, ((u64)fhp->fh_post_blocks) << 9); *p++ = htonl((u32) MAJOR(fhp->fh_post_rdev)); *p++ = htonl((u32) MINOR(fhp->fh_post_rdev)); if (rqstp->rq_reffh->fh_version == 1 && rqstp->rq_reffh->fh_fsid_type == 1 && (fhp->fh_export->ex_flags & NFSEXP_FSID)) p = xdr_encode_hyper(p, (u64) fhp->fh_export->ex_fsid); else p = xdr_encode_hyper(p, (u64) inode->i_dev); p = xdr_encode_hyper(p, (u64) inode->i_ino); p = encode_time3(p, fhp->fh_post_atime); p = encode_time3(p, fhp->fh_post_mtime); p = encode_time3(p, fhp->fh_post_ctime); return p; }
static void encode_write3args(struct xdr_stream *xdr, const struct nfs_writeargs *args) { __be32 *p; encode_nfs_fh3(xdr, args->fh); p = xdr_reserve_space(xdr, 8 + 4 + 4 + 4); p = xdr_encode_hyper(p, args->offset); *p++ = cpu_to_be32(args->count); *p++ = cpu_to_be32(args->stable); *p = cpu_to_be32(args->count); xdr_write_pages(xdr, args->pages, args->pgbase, args->count); }
/* * Encode result of a TEST/TEST_MSG call */ static __be32 * nlm4_encode_testres(__be32 *p, struct nlm_res *resp) { s64 start, len; dprintk("xdr: before encode_testres (p %p resp %p)\n", p, resp); if (!(p = nlm4_encode_cookie(p, &resp->cookie))) return NULL; *p++ = resp->status; if (resp->status == nlm_lck_denied) { struct file_lock *fl = &resp->lock.fl; *p++ = (fl->fl_type == F_RDLCK)? xdr_zero : xdr_one; *p++ = htonl(resp->lock.svid); /* Encode owner handle. */ if (!(p = xdr_encode_netobj(p, &resp->lock.oh))) return NULL; start = loff_t_to_s64(fl->fl_start); if (fl->fl_end == OFFSET_MAX) len = 0; else len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1); p = xdr_encode_hyper(p, start); p = xdr_encode_hyper(p, len); dprintk("xdr: encode_testres (status %u pid %d type %d start %Ld end %Ld)\n", resp->status, (int)resp->lock.svid, fl->fl_type, (long long)fl->fl_start, (long long)fl->fl_end); } dprintk("xdr: after encode_testres (p %p resp %p)\n", p, resp); return p; }
int pnfs_osd_xdr_encode_layoutupdate(struct xdr_stream *xdr, struct pnfs_osd_layoutupdate *lou) { __be32 *p = xdr_reserve_space(xdr, 4 + 8 + 4); if (!p) return -E2BIG; *p++ = cpu_to_be32(lou->dsu_valid); if (lou->dsu_valid) p = xdr_encode_hyper(p, lou->dsu_delta); *p++ = cpu_to_be32(lou->olu_ioerr_flag); return 0; }
/* * Encode arguments to readdir call */ static int nfs3_xdr_readdirargs(struct rpc_rqst *req, __be32 *p, struct nfs3_readdirargs *args) { struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth; unsigned int replen; u32 count = args->count; p = xdr_encode_fhandle(p, args->fh); p = xdr_encode_hyper(p, args->cookie); *p++ = args->verf[0]; *p++ = args->verf[1]; if (args->plus) { /* readdirplus: need dircount + buffer size. * We just make sure we make dircount big enough */ *p++ = htonl(count >> 3); }
/* * Write arguments. Splice the buffer to be written into the iovec. */ static int nfs3_xdr_writeargs(struct rpc_rqst *req, u32 *p, struct nfs_writeargs *args) { struct xdr_buf *sndbuf = &req->rq_snd_buf; u32 count = args->count; p = xdr_encode_fhandle(p, args->fh); p = xdr_encode_hyper(p, args->offset); *p++ = htonl(count); *p++ = htonl(args->stable); *p++ = htonl(count); sndbuf->len = xdr_adjust_iovec(sndbuf->head, p); /* Copy the page array */ xdr_encode_pages(sndbuf, args->pages, args->pgbase, count); return 0; }
static inline __be32 * xdr_encode_sattr(__be32 *p, struct iattr *attr) { if (attr->ia_valid & ATTR_MODE) { *p++ = xdr_one; *p++ = htonl(attr->ia_mode & S_IALLUGO); } else { *p++ = xdr_zero; } if (attr->ia_valid & ATTR_UID) { *p++ = xdr_one; *p++ = htonl(attr->ia_uid); } else { *p++ = xdr_zero; } if (attr->ia_valid & ATTR_GID) { *p++ = xdr_one; *p++ = htonl(attr->ia_gid); } else { *p++ = xdr_zero; } if (attr->ia_valid & ATTR_SIZE) { *p++ = xdr_one; p = xdr_encode_hyper(p, (__u64) attr->ia_size); } else { *p++ = xdr_zero; } if (attr->ia_valid & ATTR_ATIME_SET) { *p++ = xdr_two; p = xdr_encode_time3(p, &attr->ia_atime); } else if (attr->ia_valid & ATTR_ATIME) { *p++ = xdr_one; } else { *p++ = xdr_zero; } if (attr->ia_valid & ATTR_MTIME_SET) { *p++ = xdr_two; p = xdr_encode_time3(p, &attr->ia_mtime); } else if (attr->ia_valid & ATTR_MTIME) { *p++ = xdr_one; } else { *p++ = xdr_zero; } return p; }
/* * Arguments to a READ call. Since we read data directly into the page * cache, we also set up the reply iovec here so that iov[1] points * exactly to the page we want to fetch. */ static int nfs3_xdr_readargs(struct rpc_rqst *req, u32 *p, struct nfs_readargs *args) { struct rpc_auth *auth = req->rq_task->tk_auth; unsigned int replen; u32 count = args->count; p = xdr_encode_fhandle(p, args->fh); p = xdr_encode_hyper(p, args->offset); *p++ = htonl(count); req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); /* Inline the page array */ replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readres_sz) << 2; xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, args->pgbase, count); return 0; }
/* * Enocde weak cache consistency data */ static u32 * encode_wcc_data(struct svc_rqst *rqstp, u32 *p, struct svc_fh *fhp) { struct dentry *dentry = fhp->fh_dentry; if (dentry && dentry->d_inode && fhp->fh_post_saved) { if (fhp->fh_pre_saved) { *p++ = xdr_one; p = xdr_encode_hyper(p, (u64) fhp->fh_pre_size); p = encode_time3(p, fhp->fh_pre_mtime); p = encode_time3(p, fhp->fh_pre_ctime); } else { *p++ = xdr_zero; } return encode_saved_post_attr(rqstp, p, fhp); } /* no pre- or post-attrs */ *p++ = xdr_zero; return encode_post_op_attr(rqstp, p, fhp); }
/* FSINFO */ int nfs3svc_encode_fsinfores(struct svc_rqst *rqstp, u32 *p, struct nfsd3_fsinfores *resp) { *p++ = xdr_zero; /* no post_op_attr */ if (resp->status == 0) { *p++ = htonl(resp->f_rtmax); *p++ = htonl(resp->f_rtpref); *p++ = htonl(resp->f_rtmult); *p++ = htonl(resp->f_wtmax); *p++ = htonl(resp->f_wtpref); *p++ = htonl(resp->f_wtmult); *p++ = htonl(resp->f_dtpref); p = xdr_encode_hyper(p, resp->f_maxfilesize); *p++ = xdr_one; *p++ = xdr_zero; *p++ = htonl(resp->f_properties); } return xdr_ressize_check(rqstp, p); }