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

/* * Encode SETATTR arguments */static intnfs_xdr_sattrargs(struct rpc_rqst *req, u32 *p, struct nfs_sattrargs *args){    p = xdr_encode_fhandle(p, args->fh);    p = xdr_encode_sattr(p, args->sattr);    req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);    return 0;}

/* * Encode directory ops argument * LOOKUP, REMOVE, RMDIR */static intnfs_xdr_diropargs(struct rpc_rqst *req, u32 *p, struct nfs_diropargs *args){    p = xdr_encode_fhandle(p, args->fh);    p = xdr_encode_array(p, args->name, args->len);    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;}

int nfs_proc_readdir(struct nfs_server *server, struct nfs_fh *fhandle,		     int cookie, int count, struct nfs_entry *entry){	int *p, *p0;	int status;	int ruid = 0;	int i;	int size;	int eof;	PRINTK("NFS call  readdir %d @ %d/n", count, cookie);	size = server->rsize;	if (!(p0 = nfs_rpc_alloc(server->rsize)))		return -EIO;retry:	p = nfs_rpc_header(p0, NFSPROC_READDIR, ruid);	p = xdr_encode_fhandle(p, fhandle);	*p++ = htonl(cookie);	*p++ = htonl(size);	if ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {		nfs_rpc_free(p0);		return status;	}	if (!(p = nfs_rpc_verify(p0)))		status = -errno_NFSERR_IO;	else if ((status = ntohl(*p++)) == NFS_OK) {		for (i = 0; i < count && *p++; i++) {			if (!(p = xdr_decode_entry(p, entry++)))				break;		}		if (!p) {			printk("nfs_proc_readdir: giant filename/n");			status = -errno_NFSERR_IO;		}		else {			eof = (i == count && !*p++ && *p++)			      || (i < count && *p++);			if (eof && i)				entry[-1].eof = 1;			PRINTK("NFS reply readdir %d %s/n", i,			       eof ? "eof" : "");			status = i;		}	}	else {		if (!ruid && current->fsuid == 0 && current->uid != 0) {			ruid = 1;			goto retry;		}		PRINTK("NFS reply readdir failed = %d/n", status);		status = -nfs_stat_to_errno(status);	}	nfs_rpc_free(p0);	return status;}

int nfs_proc_rename(struct nfs_server *server,		    struct nfs_fh *old_dir, const char *old_name,		    struct nfs_fh *new_dir, const char *new_name){	int *p, *p0;	int status;	int ruid = 0;	PRINTK("NFS call  rename %s -> %s/n", old_name, new_name);	if (!(p0 = nfs_rpc_alloc(server->wsize)))		return -EIO;retry:	p = nfs_rpc_header(p0, NFSPROC_RENAME, ruid);	p = xdr_encode_fhandle(p, old_dir);	p = xdr_encode_string(p, old_name);	p = xdr_encode_fhandle(p, new_dir);	p = xdr_encode_string(p, new_name);	if ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {		nfs_rpc_free(p0);		return status;	}	if (!(p = nfs_rpc_verify(p0)))		status = -errno_NFSERR_IO;	else if ((status = ntohl(*p++)) == NFS_OK) {		PRINTK("NFS reply rename/n");		/* status = 0; */	}	else {		if (!ruid && current->fsuid == 0 && current->uid != 0) {			ruid = 1;			goto retry;		}		PRINTK("NFS reply rename failed = %d/n", status);		status = -nfs_stat_to_errno(status);	}	nfs_rpc_free(p0);	return status;}

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

int nfs_proc_read(struct nfs_server *server, struct nfs_fh *fhandle,	  int offset, int count, char *data, struct nfs_fattr *fattr, int fs){	int *p, *p0;	int status;	int ruid = 0;	int len;	PRINTK("NFS call  read %d @ %d/n", count, offset);	if (!(p0 = nfs_rpc_alloc(server->rsize)))		return -EIO;retry:	p = nfs_rpc_header(p0, NFSPROC_READ, ruid);	p = xdr_encode_fhandle(p, fhandle);	*p++ = htonl(offset);	*p++ = htonl(count);	*p++ = htonl(count); /* traditional, could be any value */	if ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {		nfs_rpc_free(p0);		return status;	}	if (!(p = nfs_rpc_verify(p0)))		status = -errno_NFSERR_IO;	else if ((status = ntohl(*p++)) == NFS_OK) {		p = xdr_decode_fattr(p, fattr);		if (!(p = xdr_decode_data(p, data, &len, count, fs))) {			printk("nfs_proc_read: giant data size/n"); 			status = -errno_NFSERR_IO;		}		else {			status = len;			PRINTK("NFS reply read %d/n", len);		}	}	else {		if (!ruid && current->fsuid == 0 && current->uid != 0) {			ruid = 1;			goto retry;		}		PRINTK("NFS reply read failed = %d/n", status);		status = -nfs_stat_to_errno(status);	}	nfs_rpc_free(p0);	return status;}

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

/* not parallel */int nfs_proc_read_np(struct nfs_fh *fhandle, int offset, int count, 	      char *data, struct nfs_fattr *fattr) {    int *p;    int len = 0;    int status;    int ruid = 0;    struct generic_server *server = fhandle->server;    int *p0;        DPRINTF(CLUHELP_LEVEL,("NFS call  read %d @ %d/n", count, offset));    if (!(p0 = overhead_rpc_alloc(server->rsize)))	return -EIO;    p = nfs_rpc_header(p0, NFSPROC_READ, ruid);    p = xdr_encode_fhandle(p, fhandle);    *p++ = htonl(offset);    *p++ = htonl(count);    *p++ = htonl(count);		/* traditional, could be any value */    DPRINTF(CLUHELP_LEVEL,("ORIGNAL/n"));    /*     print_rpc2(p0,128); */    if ((status = generic_rpc_call(server, p0, p)) < 0) {	overhead_rpc_free(p0);	return status;    }    if (!(p = generic_rpc_verify(p0)))	status = NFSERR_IO;    else if ((status = ntohl(*p++)) == NFS_OK) {	p = xdr_decode_fattr(p, fattr);	if (!(p = xdr_decode_data(p, data, &len, count))) {	    DPRINTF(CLUHELP_LEVEL,("nfs_proc_read: giant data size/n")); 	    status = NFSERR_IO;	}	else	    DPRINTF(CLUHELP_LEVEL,("NFS reply read %d/n", len));    }    overhead_rpc_free(p0);    return (status == NFS_OK) ? len : nfs_stat_to_errno(status);}

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

int nfs_proc_lookup(struct nfs_server *server, struct nfs_fh *dir, const char *name,		    struct nfs_fh *fhandle, struct nfs_fattr *fattr){	int *p, *p0;	int status;	int ruid = 0;	PRINTK("NFS call  lookup %s/n", name);#ifdef NFS_PROC_DEBUG	if (!strcmp(name, "xyzzy"))		proc_debug = 1 - proc_debug;#endif	if (!(p0 = nfs_rpc_alloc(server->rsize)))		return -EIO;retry:	p = nfs_rpc_header(p0, NFSPROC_LOOKUP, ruid);	p = xdr_encode_fhandle(p, dir);	p = xdr_encode_string(p, name);	if ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {		nfs_rpc_free(p0);		return status;	}	if (!(p = nfs_rpc_verify(p0)))		status = -errno_NFSERR_IO;	else if ((status = ntohl(*p++)) == NFS_OK) {		p = xdr_decode_fhandle(p, fhandle);		p = xdr_decode_fattr(p, fattr);		PRINTK("NFS reply lookup/n");		/* status = 0; */	}	else {		if (!ruid && current->fsuid == 0 && current->uid != 0) {			ruid = 1;			goto retry;		}		PRINTK("NFS reply lookup failed = %d/n", status);		status = -nfs_stat_to_errno(status);	}	nfs_rpc_free(p0);	return status;}

int nfs_proc_write(struct nfs_server *server, struct nfs_fh *fhandle,		   int offset, int count, char *data, struct nfs_fattr *fattr){	int *p, *p0;	int status;	int ruid = 0;	PRINTK("NFS call  write %d @ %d/n", count, offset);	if (!(p0 = nfs_rpc_alloc(server->wsize)))		return -EIO;retry:	p = nfs_rpc_header(p0, NFSPROC_WRITE, ruid);	p = xdr_encode_fhandle(p, fhandle);	*p++ = htonl(offset); /* traditional, could be any value */	*p++ = htonl(offset);	*p++ = htonl(count); /* traditional, could be any value */	p = xdr_encode_data(p, data, count);	if ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {		nfs_rpc_free(p0);		return status;	}	if (!(p = nfs_rpc_verify(p0)))		status = -errno_NFSERR_IO;	else if ((status = ntohl(*p++)) == NFS_OK) {		p = xdr_decode_fattr(p, fattr);		PRINTK("NFS reply write/n");		/* status = 0; */	}	else {		if (!ruid && current->fsuid == 0 && current->uid != 0) {			ruid = 1;			goto retry;		}		PRINTK("NFS reply write failed = %d/n", status);		status = -nfs_stat_to_errno(status);	}	nfs_rpc_free(p0);	return status;}

int nfs_proc_mkdir(struct nfs_server *server, struct nfs_fh *dir,		   const char *name, struct nfs_sattr *sattr,		   struct nfs_fh *fhandle, struct nfs_fattr *fattr){	int *p, *p0;	int status;	int ruid = 0;	PRINTK("NFS call  mkdir %s/n", name);	if (!(p0 = nfs_rpc_alloc(server->wsize)))		return -EIO;retry:	p = nfs_rpc_header(p0, NFSPROC_MKDIR, ruid);	p = xdr_encode_fhandle(p, dir);	p = xdr_encode_string(p, name);	p = xdr_encode_sattr(p, sattr);	if ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {		nfs_rpc_free(p0);		return status;	}	if (!(p = nfs_rpc_verify(p0)))		status = -errno_NFSERR_IO;	else if ((status = ntohl(*p++)) == NFS_OK) {		p = xdr_decode_fhandle(p, fhandle);		p = xdr_decode_fattr(p, fattr);		PRINTK("NFS reply mkdir/n");		/* status = 0; */	}	else {		if (!ruid && current->fsuid == 0 && current->uid != 0) {			ruid = 1;			goto retry;		}		PRINTK("NFS reply mkdir failed = %d/n", status);		status = -nfs_stat_to_errno(status);	}	nfs_rpc_free(p0);	return status;}

int nfs_proc_readlink(struct nfs_server *server, struct nfs_fh *fhandle,		      char *res){	int *p, *p0;	int status;	int ruid = 0;	PRINTK("NFS call  readlink/n");	if (!(p0 = nfs_rpc_alloc()))		return -EIO;retry:	p = nfs_rpc_header(p0, NFSPROC_READLINK, ruid);	p = xdr_encode_fhandle(p, fhandle);	if ((status = nfs_rpc_call(server, p0, p)) < 0) {		nfs_rpc_free(p0);		return status;	}	if (!(p = nfs_rpc_verify(p0)))		status = NFSERR_IO;	else if ((status = ntohl(*p++)) == NFS_OK) {		if (!(p = xdr_decode_string(p, res, NFS_MAXPATHLEN))) {			printk("nfs_proc_readlink: giant pathname/n");			status = NFSERR_IO;		}		else			PRINTK("NFS reply readlink %s/n", res);	}	else {		if (!ruid && current->euid == 0 && current->uid != 0) {			ruid = 1;			goto retry;		}		PRINTK("NFS reply readlink failed = %d/n", status);	}	nfs_rpc_free(p0);	return -nfs_stat_to_errno(status);}

int nfs_proc_read_p(struct nfs_fh *fhandle, int offset, int count, 	      char *data, struct nfs_fattr *fattr) {    int *p;    int len = 0;    int status;    int ruid = 0;    struct generic_server *server = fhandle->server;    struct p_rpc *prpc;    struct p_rpc_rec *rw;    int i;    int rsize;			/* to be used with new prpc */    int remaining_count = count;    int total_length = 0;    char *tmp_data;    char *tmp_data0;        DPRINTF(CLUHELP_LEVEL,("NFS call  read %d @ %d/n", count, offset));    rsize = server->rsize;    //rsize = 1366;    if ((offset < NFSMAXOFFSET) && ((offset % 4096) != 0)) {      kprintf("warning non page aligned read: %d:%d/n",offset,count);    }    if (!(prpc = p_overhead_rpc_alloc(rsize, count)))	return -EIO;    for (i = 0; i < prpc->n ; i++) {	rw = &prpc->rw[i];	rw->start = nfs_rpc_header(rw->ptr, NFSPROC_READ, ruid);	rw->start = xdr_encode_fhandle(rw->start, fhandle);	*rw->start++ = htonl(offset + i*rsize);	/* offset */	*rw->start++ = htonl((remaining_count >= rsize) ? 			     rsize : remaining_count); /* count */	rw->count = (remaining_count >= rsize) ? rsize : remaining_count;	remaining_count -= rsize;	*rw->start++ = htonl(rsize); /* traditional, could be any value */	rw->end = rw->start;	rw->r.n = 0;	rw->xid = rw->ptr[0];	rw->done = 0;	/* 	print_rpc2(prpc->rw[i].ptr,128); */    }    /*     pr_p_rpc(prpc); */    if ((status = p_generic_rpc_call(server,prpc)) < 0) {	p_overhead_rpc_free(prpc);	return status;    }    DPRINTF(CLUHELP_LEVEL,("P_GENERIC_RPC_CALL: %d/n",status));    tmp_data = tmp_data0 = data;    for (i = 0; i < prpc->n ; i++) {	rw = &prpc->rw[i];	if (!(p = generic_rpc_verify(rw->ptr))) {	    status = NFSERR_IO;	    break;	} else if ((status = ntohl(*p++)) == NFS_OK) {	    p = xdr_decode_fattr(p, fattr);	    if (!(p = xdr_decode_data(p, tmp_data, &len, rw->count))) {		DPRINTF(CLUHELP_LEVEL,("nfs_proc_read: giant data size/n")); 		status = NFSERR_IO;		break;	    } else {		DPRINTF(CLUHELP_LEVEL,("NFS reply read xid: %d, length: %d count %d/n", 			 rw->xid,len,rw->count));		tmp_data += len;		total_length += len;	    }	}    }    DPRINTF(CLUHELP_LEVEL,("status: %d/n",status));    p_overhead_rpc_free(prpc);    return (status == NFS_OK) ? total_length : nfs_stat_to_errno(status);}

int nfs_proc_writev(struct nfs_fh *fhandle, int offset, int count, 	       struct ae_recv *r, struct nfs_fattr *fattr) {        int *p;    int status;    int ruid = 0;    struct generic_server *server = fhandle->server;    char *tmp_data;    int i;    int wsize;			/* to be used with new prpc */    int remaining_count = count;    struct p_rpc *prpc;    struct p_rpc_rec *rw;            DPRINTF(CLUHELP_LEVEL,("NFS call  write %p  %d @ %d/n", r, count, offset));    wsize = server->wsize;    if (!(prpc = p_overhead_rpc_alloc(wsize, count)))	return -EIO;    demand(count <= wsize, we only handle up to 8K for now);    tmp_data = NULL; // data;    for (i = 0; i < prpc->n ; i++) {      static char overflow[4];	rw = &prpc->rw[i];	rw->start = nfs_rpc_header(rw->ptr, NFSPROC_WRITE, ruid);	rw->start = xdr_encode_fhandle(rw->start, fhandle);	*rw->start++ = htonl(offset + i*wsize);	/* offset */	*rw->start++ = htonl(offset + i*wsize);	/* offset */	rw->count = (remaining_count >= wsize) ? wsize : remaining_count;	*rw->start++ = htonl(rw->count); /* count */	*rw->start++ = htonl(rw->count); /* data len */	rw->end = rw->start;	rw->r.n = 1;	rw->r = *r;	if ((rw->count % 4) != 0) {	  rw->r.r[r->n].data = overflow;	  rw->r.r[r->n].sz = 4 - (rw->count % 4);	  rw->r.n++;	}	pr_ae_recv(&rw->r);	tmp_data += rw->count;	remaining_count -= rw->count;	rw->xid = rw->ptr[0];	rw->done = 0;	/* 	print_rpc2(prpc->rw[i].ptr,128); */    }    /*     pr_p_rpc(prpc); */    lprintf("p_generic_rpc_call start/n");    if ((status = p_generic_rpc_call(server,prpc)) < 0) {	p_overhead_rpc_free(prpc);	return status;    }    lprintf("p_generic_rpc_call done/n");    DPRINTF(CLUHELP_LEVEL,("P_GENERIC_RPC_CALL: %d/n",status));    for (i = 0; i < prpc->n ; i++) {	rw = &prpc->rw[i];	if (!(p = generic_rpc_verify(rw->ptr))) {	    status = NFSERR_IO;	    break;	} else if ((status = ntohl(*p++)) == NFS_OK) {	    p = xdr_decode_fattr(p, fattr);	    DPRINTF(CLUHELP_LEVEL,("NFS reply write xid: %d, count %d/n", 		   rw->xid,rw->count));	}    }        DPRINTF(CLUHELP_LEVEL,("status: %d/n",status));        p_overhead_rpc_free(prpc);    return nfs_stat_to_errno(status);}