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

/* * Encode RENAME arguments */static intnfs_xdr_renameargs(struct rpc_rqst *req, u32 *p, struct nfs_renameargs *args){	p = xdr_encode_fhandle(p, args->fromfh);	p = xdr_encode_array(p, args->fromname, args->fromlen);	p = xdr_encode_fhandle(p, args->tofh);	p = xdr_encode_array(p, args->toname, args->tolen);	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);	return 0;}

/* * Encode SYMLINK arguments */static intnfs_xdr_symlinkargs(struct rpc_rqst *req, u32 *p, struct nfs_symlinkargs *args){	p = xdr_encode_fhandle(p, args->fromfh);	p = xdr_encode_array(p, args->fromname, args->fromlen);	p = xdr_encode_array(p, args->topath, args->tolen);	p = xdr_encode_sattr(p, args->sattr);	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);	return 0;}

/* * Encode RENAME arguments */static intnfs3_xdr_renameargs(struct rpc_rqst *req, __be32 *p, struct nfs_renameargs *args){	p = xdr_encode_fhandle(p, args->old_dir);	p = xdr_encode_array(p, args->old_name->name, args->old_name->len);	p = xdr_encode_fhandle(p, args->new_dir);	p = xdr_encode_array(p, args->new_name->name, args->new_name->len);	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);	return 0;}

static intnlm4clt_encode_unlockargs(struct rpc_rqst *req, __be32 *p, nlm_args *argp){    struct nlm_lock    *lock = &argp->lock;    if (!(p = nlm4_encode_cookie(p, &argp->cookie)))        return -EIO;    if (!(p = nlm4_encode_lock(p, lock)))        return -EIO;    req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);    return 0;}

static intxdr_encode_mon(struct rpc_rqst *rqstp, u32 *p, struct nsm_args *argp){	p = xdr_encode_common(rqstp, p, argp);	if (IS_ERR(p))		return PTR_ERR(p);	*p++ = argp->addr;	*p++ = argp->vers;	*p++ = argp->proto;	*p++ = 0;	rqstp->rq_slen = xdr_adjust_iovec(rqstp->rq_svec, p);	return 0;}

static intnlm4clt_encode_testargs(struct rpc_rqst *req, __be32 *p, nlm_args *argp){    struct nlm_lock    *lock = &argp->lock;    if (!(p = nlm4_encode_cookie(p, &argp->cookie)))        return -EIO;    *p++ = (lock->fl.fl_type == F_WRLCK)? xdr_one : xdr_zero;    if (!(p = nlm4_encode_lock(p, lock)))        return -EIO;    req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);    return 0;}

/* * Encode READLINK args */static intnfs_xdr_readlinkargs(struct rpc_rqst *req, u32 *p, struct nfs_readlinkargs *args){	struct rpc_auth *auth = req->rq_task->tk_auth;	unsigned int replen;	p = xdr_encode_fhandle(p, args->fh);	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);	/* Inline the page array */	replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readlinkres_sz) << 2;	xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, args->pgbase, args->pglen);	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;}

/* * Write arguments. Splice the buffer to be written into the iovec. */static intnfs_xdr_writeargs(struct rpc_rqst *req, u32 *p, struct nfs_writeargs *args){	unsigned int nr;	u32 count = args->count;	p = xdr_encode_fhandle(p, args->fh);	*p++ = htonl(args->offset);	*p++ = htonl(args->offset);	*p++ = htonl(count);	*p++ = htonl(count);	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);	/* Get the number of buffers in the send iovec */	nr = args->nriov;	if (nr+2 > MAX_IOVEC) {                printk(KERN_ERR "NFS: Bad number of iov's in xdr_writeargs "                        "(nr %d max %d)/n", nr, MAX_IOVEC);                return -EINVAL;        }	/* Copy the iovec */        memcpy(req->rq_svec + 1, args->iov, nr * sizeof(struct iovec));#ifdef NFS_PAD_WRITES	/*	 * Some old servers require that the message length	 * be a multiple of 4, so we pad it here if needed.	 */	if (count & 3) {		struct iovec	*iov = req->rq_svec + nr + 1;		int		pad = 4 - (count & 3);		iov->iov_base = (void *) "/0/0/0";		iov->iov_len  = pad;		count += pad;		nr++;	}#endif	req->rq_slen += count;	req->rq_snr += nr;	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;}

static intnfs_xdr_writeargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args){	struct xdr_buf *sndbuf = &req->rq_snd_buf;	u32 offset = (u32)args->offset;	u32 count = args->count;	p = xdr_encode_fhandle(p, args->fh);	*p++ = htonl(offset);	*p++ = htonl(offset);	*p++ = htonl(count);	*p++ = htonl(count);	sndbuf->len = xdr_adjust_iovec(sndbuf->head, p);	/* Copy the page array */	xdr_encode_pages(sndbuf, args->pages, args->pgbase, count);	sndbuf->flags |= XDRBUF_WRITE;	return 0;}

/* * Encode READLINK args */static intnfs_xdr_readlinkargs(struct rpc_rqst *req, u32 *p, struct nfs_readlinkargs *args){	struct rpc_task *task = req->rq_task;	struct rpc_auth *auth = task->tk_auth;	int		buflen, replen;	p = xdr_encode_fhandle(p, args->fh);	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);	replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readlinkres_sz) << 2;	buflen = req->rq_rvec[0].iov_len;	req->rq_rvec[0].iov_len  = replen;	req->rq_rvec[1].iov_base = args->buffer;	req->rq_rvec[1].iov_len  = args->bufsiz;	req->rq_rvec[2].iov_base = (u8 *) req->rq_rvec[0].iov_base + replen;	req->rq_rvec[2].iov_len  = buflen - replen;	req->rq_rlen = buflen + args->bufsiz;	req->rq_rnr += 2;	return 0;}

static intxdr_encode_mon(struct rpc_rqst *rqstp, u32 *p, struct nsm_args *argp){	char	buffer[20];	u32	addr = ntohl(argp->addr);	dprintk("nsm: xdr_encode_mon(%08x, %d, %d, %d)/n",			htonl(argp->addr), htonl(argp->proc),			htonl(argp->vers), htonl(argp->proc));	/*	 * Use the dotted-quad IP address of the remote host as	 * identifier. Linux statd always looks up the canonical	 * hostname first for whatever remote hostname it receives,	 * so this works alright.	 */	sprintf(buffer, "%d.%d.%d.%d", (addr>>24) & 0xff, (addr>>16) & 0xff,				 	(addr>>8) & 0xff,  (addr) & 0xff);	if (!(p = xdr_encode_string(p, buffer))	 || !(p = xdr_encode_string(p, system_utsname.nodename)))		return -EIO;	*p++ = htonl(argp->prog);	*p++ = htonl(argp->vers);	*p++ = htonl(argp->proc);	/* This is the private part. Needed only for SM_MON call */	if (rqstp->rq_task->tk_proc == SM_MON) {		*p++ = argp->addr;		*p++ = 0;		*p++ = 0;		*p++ = 0;	}	rqstp->rq_slen = xdr_adjust_iovec(rqstp->rq_svec, p);	return 0;}

/* * Create NSM client for the local host */static struct rpc_clnt *nsm_create(void){	struct sockaddr_in	sin = {		.sin_family	= AF_INET,		.sin_addr.s_addr = htonl(INADDR_LOOPBACK),		.sin_port	= 0,	};	struct rpc_create_args args = {		.protocol	= IPPROTO_UDP,		.address	= (struct sockaddr *)&sin,		.addrsize	= sizeof(sin),		.servername	= "localhost",		.program	= &nsm_program,		.version	= SM_VERSION,		.authflavor	= RPC_AUTH_NULL,		.flags		= (RPC_CLNT_CREATE_ONESHOT),	};	return rpc_create(&args);}/* * XDR functions for NSM. */static __be32 *xdr_encode_common(struct rpc_rqst *rqstp, __be32 *p, struct nsm_args *argp){	char	buffer[20], *name;	/*	 * Use the dotted-quad IP address of the remote host as	 * identifier. Linux statd always looks up the canonical	 * hostname first for whatever remote hostname it receives,	 * so this works alright.	 */	if (nsm_use_hostnames) {		name = argp->mon_name;	} else {		sprintf(buffer, "%u.%u.%u.%u", NIPQUAD(argp->addr));		name = buffer;	}	if (!(p = xdr_encode_string(p, name))	 || !(p = xdr_encode_string(p, utsname()->nodename)))		return ERR_PTR(-EIO);	*p++ = htonl(argp->prog);	*p++ = htonl(argp->vers);	*p++ = htonl(argp->proc);	return p;}static intxdr_encode_mon(struct rpc_rqst *rqstp, __be32 *p, struct nsm_args *argp){	p = xdr_encode_common(rqstp, p, argp);	if (IS_ERR(p))		return PTR_ERR(p);	/* Surprise - there may even be room for an IPv6 address now */	*p++ = argp->addr;	*p++ = 0;	*p++ = 0;	*p++ = 0;	rqstp->rq_slen = xdr_adjust_iovec(rqstp->rq_svec, p);	return 0;}

//.........这里部分代码省略.........		xprt->ops->set_port(xprt, clnt->cl_port);		clnt->cl_port = htons(clnt->cl_port);	}	spin_lock(&pmap_lock);	map->pm_binding = 0;	rpc_wake_up(&map->pm_bindwait);	spin_unlock(&pmap_lock);}/* * Set or unset a port registration with the local portmapper. * port == 0 means unregister, port != 0 means register. */intrpc_register(u32 prog, u32 vers, int prot, unsigned short port, int *okay){	struct sockaddr_in	sin;	struct rpc_portmap	map;	struct rpc_clnt		*pmap_clnt;	int error = 0;	dprintk("RPC: registering (%d, %d, %d, %d) with portmapper./n",			prog, vers, prot, port);	sin.sin_family = AF_INET;	sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);	pmap_clnt = pmap_create("localhost", &sin, IPPROTO_UDP, 1);	if (IS_ERR(pmap_clnt)) {		error = PTR_ERR(pmap_clnt);		dprintk("RPC: couldn't create pmap client. Error = %d/n", error);		return error;	}	map.pm_prog = prog;	map.pm_vers = vers;	map.pm_prot = prot;	map.pm_port = port;	error = rpc_call(pmap_clnt, port? PMAP_SET : PMAP_UNSET,					&map, okay, 0);	if (error < 0) {		printk(KERN_WARNING			"RPC: failed to contact portmap (errno %d)./n",			error);	}	dprintk("RPC: registration status %d/%d/n", error, *okay);	/* Client deleted automatically because cl_oneshot == 1 */	return error;}static struct rpc_clnt *pmap_create(char *hostname, struct sockaddr_in *srvaddr, int proto, int privileged){	struct rpc_xprt	*xprt;	struct rpc_clnt	*clnt;	/* printk("pmap: create xprt/n"); */	xprt = xprt_create_proto(proto, srvaddr, NULL);	if (IS_ERR(xprt))		return (struct rpc_clnt *)xprt;	xprt->ops->set_port(xprt, RPC_PMAP_PORT);	if (!privileged)		xprt->resvport = 0;	/* printk("pmap: create clnt/n"); */	clnt = rpc_new_client(xprt, hostname,				&pmap_program, RPC_PMAP_VERSION,				RPC_AUTH_UNIX);	if (!IS_ERR(clnt)) {		clnt->cl_softrtry = 1;		clnt->cl_oneshot  = 1;	}	return clnt;}/* * XDR encode/decode functions for PMAP */static intxdr_encode_mapping(struct rpc_rqst *req, u32 *p, struct rpc_portmap *map){	dprintk("RPC: xdr_encode_mapping(%d, %d, %d, %d)/n",		map->pm_prog, map->pm_vers, map->pm_prot, map->pm_port);	*p++ = htonl(map->pm_prog);	*p++ = htonl(map->pm_vers);	*p++ = htonl(map->pm_prot);	*p++ = htonl(map->pm_port);	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);	return 0;}static intxdr_decode_port(struct rpc_rqst *req, u32 *p, unsigned short *portp){	*portp = (unsigned short) ntohl(*p++);	return 0;}

//.........这里部分代码省略.........	rpc_put_task(child);	task->tk_xprt->stat.bind_count++;	return;bailout:	kfree(map);	xprt_put(xprt);bailout_nofree:	rpcb_wake_rpcbind_waiters(xprt, status);bailout_nowake:	task->tk_status = status;}EXPORT_SYMBOL_GPL(rpcb_getport_async);/* * Rpcbind child task calls this callback via tk_exit. */static void rpcb_getport_done(struct rpc_task *child, void *data){	struct rpcbind_args *map = data;	struct rpc_xprt *xprt = map->r_xprt;	int status = child->tk_status;	/* Garbage reply: retry with a lesser rpcbind version */	if (status == -EIO)		status = -EPROTONOSUPPORT;	/* rpcbind server doesn't support this rpcbind protocol version */	if (status == -EPROTONOSUPPORT)		xprt->bind_index++;	if (status < 0) {		/* rpcbind server not available on remote host? */		xprt->ops->set_port(xprt, 0);	} else if (map->r_port == 0) {		/* Requested RPC service wasn't registered on remote host */		xprt->ops->set_port(xprt, 0);		status = -EACCES;	} else {		/* Succeeded */		xprt->ops->set_port(xprt, map->r_port);		xprt_set_bound(xprt);		status = 0;	}	dprintk("RPC: %5u rpcb_getport_done(status %d, port %u)/n",			child->tk_pid, status, map->r_port);	rpcb_wake_rpcbind_waiters(xprt, status);}static int rpcb_encode_mapping(struct rpc_rqst *req, __be32 *p,			       struct rpcbind_args *rpcb){	dprintk("RPC:       rpcb_encode_mapping(%u, %u, %d, %u)/n",			rpcb->r_prog, rpcb->r_vers, rpcb->r_prot, rpcb->r_port);	*p++ = htonl(rpcb->r_prog);	*p++ = htonl(rpcb->r_vers);	*p++ = htonl(rpcb->r_prot);	*p++ = htonl(rpcb->r_port);	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);	return 0;}static int rpcb_decode_getport(struct rpc_rqst *req, __be32 *p,			       unsigned short *portp){	*portp = (unsigned short) ntohl(*p++);	dprintk("RPC:      rpcb_decode_getport result %u/n",			*portp);	return 0;}static int rpcb_decode_set(struct rpc_rqst *req, __be32 *p,			   unsigned int *boolp){	*boolp = (unsigned int) ntohl(*p++);	dprintk("RPC:      rpcb_decode_set result %u/n",			*boolp);	return 0;}static int rpcb_encode_getaddr(struct rpc_rqst *req, __be32 *p,			       struct rpcbind_args *rpcb){	dprintk("RPC:       rpcb_encode_getaddr(%u, %u, %s)/n",			rpcb->r_prog, rpcb->r_vers, rpcb->r_addr);	*p++ = htonl(rpcb->r_prog);	*p++ = htonl(rpcb->r_vers);	p = xdr_encode_string(p, rpcb->r_netid);	p = xdr_encode_string(p, rpcb->r_addr);	p = xdr_encode_string(p, rpcb->r_owner);	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);	return 0;}