自学教程：C++ xdr_encode_hyper函数代码示例

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 voidnfs4_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;}

intpnfs_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;}

/* * Write arguments. Splice the buffer to be written into the iovec. */static intnfs3_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;}

/* * 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 intnfs3_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 */intnfs3svc_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);}