renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-15 00:34:10 +08:00
Code

SUNRPC: New xdr_streams XDR encoder API

Browse Source 
Now that all client-side XDR encoder routines use xdr_streams, there
should be no need to support the legacy calling sequence [rpc_rqst *,
__be32 *, RPC arg *] anywhere.  We can construct an xdr_stream in the
generic RPC code, instead of in each encoder function.

Also, all the client-side encoder functions return 0 now, making a
return value superfluous.  Take this opportunity to convert them to
return void instead.

This is a refactoring change.  It should not cause different behavior.

Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Tested-by: J. Bruce Fields <bfields@redhat.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
This commit is contained in:
Chuck Lever 2010-12-14 14:59:18 +00:00 committed by Trond Myklebust
parent 1ac7c23e4a
commit 9f06c719f4
15 changed files with 606 additions and 807 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
fs/lockd/clnt4xdr.c
View File

@ -385,17 +385,15 @@ static void encode_nlm4_lock(struct xdr_stream *xdr,
* struct nlm4_lock alock;
* };
*/
static int nlm4_xdr_enc_testargs(struct rpc_rqst *req, __be32 *p,
const struct nlm_args *args)
static void nlm4_xdr_enc_testargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nlm_args *args)
{
const struct nlm_lock *lock = &args->lock;
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_cookie(&xdr, &args->cookie);
encode_bool(&xdr, lock->fl.fl_type == F_WRLCK);
encode_nlm4_lock(&xdr, lock);
return 0;
encode_cookie(xdr, &args->cookie);
encode_bool(xdr, lock->fl.fl_type == F_WRLCK);
encode_nlm4_lock(xdr, lock);
}
/*
@ -408,20 +406,18 @@ static int nlm4_xdr_enc_testargs(struct rpc_rqst *req, __be32 *p,
* int state;
* };
*/
static int nlm4_xdr_enc_lockargs(struct rpc_rqst *req, __be32 *p,
const struct nlm_args *args)
static void nlm4_xdr_enc_lockargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nlm_args *args)
{
const struct nlm_lock *lock = &args->lock;
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_cookie(&xdr, &args->cookie);
encode_bool(&xdr, args->block);
encode_bool(&xdr, lock->fl.fl_type == F_WRLCK);
encode_nlm4_lock(&xdr, lock);
encode_bool(&xdr, args->reclaim);
encode_int32(&xdr, args->state);
return 0;
encode_cookie(xdr, &args->cookie);
encode_bool(xdr, args->block);
encode_bool(xdr, lock->fl.fl_type == F_WRLCK);
encode_nlm4_lock(xdr, lock);
encode_bool(xdr, args->reclaim);
encode_int32(xdr, args->state);
}
/*
@ -432,18 +428,16 @@ static int nlm4_xdr_enc_lockargs(struct rpc_rqst *req, __be32 *p,
* struct nlm4_lock alock;
* };
*/
static int nlm4_xdr_enc_cancargs(struct rpc_rqst *req, __be32 *p,
const struct nlm_args *args)
static void nlm4_xdr_enc_cancargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nlm_args *args)
{
const struct nlm_lock *lock = &args->lock;
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_cookie(&xdr, &args->cookie);
encode_bool(&xdr, args->block);
encode_bool(&xdr, lock->fl.fl_type == F_WRLCK);
encode_nlm4_lock(&xdr, lock);
return 0;
encode_cookie(xdr, &args->cookie);
encode_bool(xdr, args->block);
encode_bool(xdr, lock->fl.fl_type == F_WRLCK);
encode_nlm4_lock(xdr, lock);
}
/*
@ -452,16 +446,14 @@ static int nlm4_xdr_enc_cancargs(struct rpc_rqst *req, __be32 *p,
* struct nlm4_lock alock;
* };
*/
static int nlm4_xdr_enc_unlockargs(struct rpc_rqst *req, __be32 *p,
const struct nlm_args *args)
static void nlm4_xdr_enc_unlockargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nlm_args *args)
{
const struct nlm_lock *lock = &args->lock;
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_cookie(&xdr, &args->cookie);
encode_nlm4_lock(&xdr, lock);
return 0;
encode_cookie(xdr, &args->cookie);
encode_nlm4_lock(xdr, lock);
}
/*
@ -470,15 +462,12 @@ static int nlm4_xdr_enc_unlockargs(struct rpc_rqst *req, __be32 *p,
* nlm4_stat stat;
* };
*/
static int nlm4_xdr_enc_res(struct rpc_rqst *req, __be32 *p,
const struct nlm_res *result)
static void nlm4_xdr_enc_res(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nlm_res *result)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_cookie(&xdr, &result->cookie);
encode_nlm4_stat(&xdr, result->status);
return 0;
encode_cookie(xdr, &result->cookie);
encode_nlm4_stat(xdr, result->status);
}
/*
@ -494,17 +483,14 @@ static int nlm4_xdr_enc_res(struct rpc_rqst *req, __be32 *p,
* nlm4_testrply test_stat;
* };
*/
static int nlm4_xdr_enc_testres(struct rpc_rqst *req, __be32 *p,
const struct nlm_res *result)
static void nlm4_xdr_enc_testres(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nlm_res *result)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_cookie(&xdr, &result->cookie);
encode_nlm4_stat(&xdr, result->status);
encode_cookie(xdr, &result->cookie);
encode_nlm4_stat(xdr, result->status);
if (result->status == nlm_lck_denied)
encode_nlm4_holder(&xdr, result);
return 0;
encode_nlm4_holder(xdr, result);
}
@ -588,7 +574,7 @@ out:
#define PROC(proc, argtype, restype) \
[NLMPROC_##proc] = { \
.p_proc = NLMPROC_##proc, \
.p_encode = (kxdrproc_t)nlm4_xdr_enc_##argtype, \
.p_encode = (kxdreproc_t)nlm4_xdr_enc_##argtype, \
.p_decode = (kxdrproc_t)nlm4_xdr_dec_##restype, \
.p_arglen = NLM4_##argtype##_sz, \
.p_replen = NLM4_##restype##_sz, \

92
fs/lockd/clntxdr.c
View File

@ -378,17 +378,15 @@ static void encode_nlm_lock(struct xdr_stream *xdr,
* struct nlm_lock alock;
* };
*/
static int nlm_xdr_enc_testargs(struct rpc_rqst *req, __be32 *p,
const struct nlm_args *args)
static void nlm_xdr_enc_testargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nlm_args *args)
{
const struct nlm_lock *lock = &args->lock;
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_cookie(&xdr, &args->cookie);
encode_bool(&xdr, lock->fl.fl_type == F_WRLCK);
encode_nlm_lock(&xdr, lock);
return 0;
encode_cookie(xdr, &args->cookie);
encode_bool(xdr, lock->fl.fl_type == F_WRLCK);
encode_nlm_lock(xdr, lock);
}
/*
@ -401,20 +399,18 @@ static int nlm_xdr_enc_testargs(struct rpc_rqst *req, __be32 *p,
* int state;
* };
*/
static int nlm_xdr_enc_lockargs(struct rpc_rqst *req, __be32 *p,
const struct nlm_args *args)
static void nlm_xdr_enc_lockargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nlm_args *args)
{
const struct nlm_lock *lock = &args->lock;
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_cookie(&xdr, &args->cookie);
encode_bool(&xdr, args->block);
encode_bool(&xdr, lock->fl.fl_type == F_WRLCK);
encode_nlm_lock(&xdr, lock);
encode_bool(&xdr, args->reclaim);
encode_int32(&xdr, args->state);
return 0;
encode_cookie(xdr, &args->cookie);
encode_bool(xdr, args->block);
encode_bool(xdr, lock->fl.fl_type == F_WRLCK);
encode_nlm_lock(xdr, lock);
encode_bool(xdr, args->reclaim);
encode_int32(xdr, args->state);
}
/*
@ -425,18 +421,16 @@ static int nlm_xdr_enc_lockargs(struct rpc_rqst *req, __be32 *p,
* struct nlm_lock alock;
* };
*/
static int nlm_xdr_enc_cancargs(struct rpc_rqst *req, __be32 *p,
const struct nlm_args *args)
static void nlm_xdr_enc_cancargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nlm_args *args)
{
const struct nlm_lock *lock = &args->lock;
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_cookie(&xdr, &args->cookie);
encode_bool(&xdr, args->block);
encode_bool(&xdr, lock->fl.fl_type == F_WRLCK);
encode_nlm_lock(&xdr, lock);
return 0;
encode_cookie(xdr, &args->cookie);
encode_bool(xdr, args->block);
encode_bool(xdr, lock->fl.fl_type == F_WRLCK);
encode_nlm_lock(xdr, lock);
}
/*
@ -445,16 +439,14 @@ static int nlm_xdr_enc_cancargs(struct rpc_rqst *req, __be32 *p,
* struct nlm_lock alock;
* };
*/
static int nlm_xdr_enc_unlockargs(struct rpc_rqst *req, __be32 *p,
const struct nlm_args *args)
static void nlm_xdr_enc_unlockargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nlm_args *args)
{
const struct nlm_lock *lock = &args->lock;
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_cookie(&xdr, &args->cookie);
encode_nlm_lock(&xdr, lock);
return 0;
encode_cookie(xdr, &args->cookie);
encode_nlm_lock(xdr, lock);
}
/*
@ -463,15 +455,12 @@ static int nlm_xdr_enc_unlockargs(struct rpc_rqst *req, __be32 *p,
* nlm_stat stat;
* };
*/
static int nlm_xdr_enc_res(struct rpc_rqst *req, __be32 *p,
const struct nlm_res *result)
static void nlm_xdr_enc_res(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nlm_res *result)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_cookie(&xdr, &result->cookie);
encode_nlm_stat(&xdr, result->status);
return 0;
encode_cookie(xdr, &result->cookie);
encode_nlm_stat(xdr, result->status);
}
/*
@ -494,16 +483,13 @@ static void encode_nlm_testrply(struct xdr_stream *xdr,
encode_nlm_holder(xdr, result);
}
static int nlm_xdr_enc_testres(struct rpc_rqst *req, __be32 *p,
const struct nlm_res *result)
static void nlm_xdr_enc_testres(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nlm_res *result)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_cookie(&xdr, &result->cookie);
encode_nlm_stat(&xdr, result->status);
encode_nlm_testrply(&xdr, result);
return 0;
encode_cookie(xdr, &result->cookie);
encode_nlm_stat(xdr, result->status);
encode_nlm_testrply(xdr, result);
}
@ -586,7 +572,7 @@ out:
#define PROC(proc, argtype, restype) \
[NLMPROC_##proc] = { \
.p_proc = NLMPROC_##proc, \
.p_encode = (kxdrproc_t)nlm_xdr_enc_##argtype, \
.p_encode = (kxdreproc_t)nlm_xdr_enc_##argtype, \
.p_decode = (kxdrproc_t)nlm_xdr_dec_##restype, \
.p_arglen = NLM_##argtype##_sz, \
.p_replen = NLM_##restype##_sz, \

26
fs/lockd/mon.c
View File

@ -459,25 +459,17 @@ static void encode_priv(struct xdr_stream *xdr, const struct nsm_args *argp)
xdr_encode_opaque_fixed(p, argp->priv->data, SM_PRIV_SIZE);
}
static int xdr_enc_mon(struct rpc_rqst *req, __be32 *p,
const struct nsm_args *argp)
static void nsm_xdr_enc_mon(struct rpc_rqst *req, struct xdr_stream *xdr,
const struct nsm_args *argp)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_mon_id(&xdr, argp);
encode_priv(&xdr, argp);
return 0;
encode_mon_id(xdr, argp);
encode_priv(xdr, argp);
}
static int xdr_enc_unmon(struct rpc_rqst *req, __be32 *p,
const struct nsm_args *argp)
static void nsm_xdr_enc_unmon(struct rpc_rqst *req, struct xdr_stream *xdr,
const struct nsm_args *argp)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_mon_id(&xdr, argp);
return 0;
encode_mon_id(xdr, argp);
}
static int xdr_dec_stat_res(struct rpc_rqst *rqstp, __be32 *p,
@ -524,7 +516,7 @@ static int xdr_dec_stat(struct rpc_rqst *rqstp, __be32 *p,
static struct rpc_procinfo nsm_procedures[] = {
[NSMPROC_MON] = {
.p_proc = NSMPROC_MON,
.p_encode = (kxdrproc_t)xdr_enc_mon,
.p_encode = (kxdreproc_t)nsm_xdr_enc_mon,
.p_decode = (kxdrproc_t)xdr_dec_stat_res,
.p_arglen = SM_mon_sz,
.p_replen = SM_monres_sz,
@ -533,7 +525,7 @@ static struct rpc_procinfo nsm_procedures[] = {
},
[NSMPROC_UNMON] = {
.p_proc = NSMPROC_UNMON,
.p_encode = (kxdrproc_t)xdr_enc_unmon,
.p_encode = (kxdreproc_t)nsm_xdr_enc_unmon,
.p_decode = (kxdrproc_t)xdr_dec_stat,
.p_arglen = SM_mon_id_sz,
.p_replen = SM_unmonres_sz,

18
fs/nfs/mount_clnt.c
View File

@ -288,14 +288,10 @@ static void encode_mntdirpath(struct xdr_stream *xdr, const char *pathname)
xdr_encode_opaque(p, pathname, pathname_len);
}
static int mnt_enc_dirpath(struct rpc_rqst *req, __be32 *p,
const char *dirpath)
static void mnt_xdr_enc_dirpath(struct rpc_rqst *req, struct xdr_stream *xdr,
const char *dirpath)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_mntdirpath(&xdr, dirpath);
return 0;
encode_mntdirpath(xdr, dirpath);
}
/*
@ -460,7 +456,7 @@ static int mnt_dec_mountres3(struct rpc_rqst *req, __be32 *p,
static struct rpc_procinfo mnt_procedures[] = {
[MOUNTPROC_MNT] = {
.p_proc = MOUNTPROC_MNT,
.p_encode = (kxdrproc_t)mnt_enc_dirpath,
.p_encode = (kxdreproc_t)mnt_xdr_enc_dirpath,
.p_decode = (kxdrproc_t)mnt_dec_mountres,
.p_arglen = MNT_enc_dirpath_sz,
.p_replen = MNT_dec_mountres_sz,
@ -469,7 +465,7 @@ static struct rpc_procinfo mnt_procedures[] = {
},
[MOUNTPROC_UMNT] = {
.p_proc = MOUNTPROC_UMNT,
.p_encode = (kxdrproc_t)mnt_enc_dirpath,
.p_encode = (kxdreproc_t)mnt_xdr_enc_dirpath,
.p_arglen = MNT_enc_dirpath_sz,
.p_statidx = MOUNTPROC_UMNT,
.p_name = "UMOUNT",
@ -479,7 +475,7 @@ static struct rpc_procinfo mnt_procedures[] = {
static struct rpc_procinfo mnt3_procedures[] = {
[MOUNTPROC3_MNT] = {
.p_proc = MOUNTPROC3_MNT,
.p_encode = (kxdrproc_t)mnt_enc_dirpath,
.p_encode = (kxdreproc_t)mnt_xdr_enc_dirpath,
.p_decode = (kxdrproc_t)mnt_dec_mountres3,
.p_arglen = MNT_enc_dirpath_sz,
.p_replen = MNT_dec_mountres3_sz,
@ -488,7 +484,7 @@ static struct rpc_procinfo mnt3_procedures[] = {
},
[MOUNTPROC3_UMNT] = {
.p_proc = MOUNTPROC3_UMNT,
.p_encode = (kxdrproc_t)mnt_enc_dirpath,
.p_encode = (kxdreproc_t)mnt_xdr_enc_dirpath,
.p_arglen = MNT_enc_dirpath_sz,
.p_statidx = MOUNTPROC3_UMNT,
.p_name = "UMOUNT",

147
fs/nfs/nfs2xdr.c
View File

@ -558,14 +558,11 @@ out_default:
* "NFS: Network File System Protocol Specification".
*/
static int nfs2_xdr_enc_fhandle(struct rpc_rqst *req, __be32 *p,
const struct nfs_fh *fh)
static void nfs2_xdr_enc_fhandle(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_fh *fh)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_fhandle(&xdr, fh);
return 0;
encode_fhandle(xdr, fh);
}
/*
@ -576,37 +573,28 @@ static int nfs2_xdr_enc_fhandle(struct rpc_rqst *req, __be32 *p,
* sattr attributes;
* };
*/
static int nfs2_xdr_enc_sattrargs(struct rpc_rqst *req, __be32 *p,
const struct nfs_sattrargs *args)
static void nfs2_xdr_enc_sattrargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_sattrargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_fhandle(&xdr, args->fh);
encode_sattr(&xdr, args->sattr);
return 0;
encode_fhandle(xdr, args->fh);
encode_sattr(xdr, args->sattr);
}
static int nfs2_xdr_enc_diropargs(struct rpc_rqst *req, __be32 *p,
const struct nfs_diropargs *args)
static void nfs2_xdr_enc_diropargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_diropargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_diropargs(&xdr, args->fh, args->name, args->len);
return 0;
encode_diropargs(xdr, args->fh, args->name, args->len);
}
static int nfs2_xdr_enc_readlinkargs(struct rpc_rqst *req, __be32 *p,
const struct nfs_readlinkargs *args)
static void nfs2_xdr_enc_readlinkargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_readlinkargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_fhandle(&xdr, args->fh);
encode_fhandle(xdr, args->fh);
prepare_reply_buffer(req, args->pages, args->pgbase,
args->pglen, NFS_readlinkres_sz);
return 0;
}
/*
@ -634,17 +622,14 @@ static void encode_readargs(struct xdr_stream *xdr,
*p = cpu_to_be32(count);
}
static int nfs2_xdr_enc_readargs(struct rpc_rqst *req, __be32 *p,
const struct nfs_readargs *args)
static void nfs2_xdr_enc_readargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_readargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_readargs(&xdr, args);
encode_readargs(xdr, args);
prepare_reply_buffer(req, args->pages, args->pgbase,
args->count, NFS_readres_sz);
req->rq_rcv_buf.flags |= XDRBUF_READ;
return 0;
}
/*
@ -677,15 +662,12 @@ static void encode_writeargs(struct xdr_stream *xdr,
xdr_write_pages(xdr, args->pages, args->pgbase, count);
}
static int nfs2_xdr_enc_writeargs(struct rpc_rqst *req, __be32 *p,
const struct nfs_writeargs *args)
static void nfs2_xdr_enc_writeargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_writeargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_writeargs(&xdr, args);
xdr.buf->flags |= XDRBUF_WRITE;
return 0;
encode_writeargs(xdr, args);
xdr->buf->flags |= XDRBUF_WRITE;
}
/*
@ -696,25 +678,19 @@ static int nfs2_xdr_enc_writeargs(struct rpc_rqst *req, __be32 *p,
* sattr attributes;
* };
*/
static int nfs2_xdr_enc_createargs(struct rpc_rqst *req, __be32 *p,
const struct nfs_createargs *args)
static void nfs2_xdr_enc_createargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_createargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_diropargs(&xdr, args->fh, args->name, args->len);
encode_sattr(&xdr, args->sattr);
return 0;
encode_diropargs(xdr, args->fh, args->name, args->len);
encode_sattr(xdr, args->sattr);
}
static int nfs2_xdr_enc_removeargs(struct rpc_rqst *req, __be32 *p,
const struct nfs_removeargs *args)
static void nfs2_xdr_enc_removeargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_removeargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_diropargs(&xdr, args->fh, args->name.name, args->name.len);
return 0;
encode_diropargs(xdr, args->fh, args->name.name, args->name.len);
}
/*
@ -725,17 +701,15 @@ static int nfs2_xdr_enc_removeargs(struct rpc_rqst *req, __be32 *p,
* diropargs to;
* };
*/
static int nfs2_xdr_enc_renameargs(struct rpc_rqst *req, __be32 *p,
const struct nfs_renameargs *args)
static void nfs2_xdr_enc_renameargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_renameargs *args)
{
const struct qstr *old = args->old_name;
const struct qstr *new = args->new_name;
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_diropargs(&xdr, args->old_dir, old->name, old->len);
encode_diropargs(&xdr, args->new_dir, new->name, new->len);
return 0;
encode_diropargs(xdr, args->old_dir, old->name, old->len);
encode_diropargs(xdr, args->new_dir, new->name, new->len);
}
/*
@ -746,15 +720,12 @@ static int nfs2_xdr_enc_renameargs(struct rpc_rqst *req, __be32 *p,
* diropargs to;
* };
*/
static int nfs2_xdr_enc_linkargs(struct rpc_rqst *req, __be32 *p,
const struct nfs_linkargs *args)
static void nfs2_xdr_enc_linkargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_linkargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_fhandle(&xdr, args->fromfh);
encode_diropargs(&xdr, args->tofh, args->toname, args->tolen);
return 0;
encode_fhandle(xdr, args->fromfh);
encode_diropargs(xdr, args->tofh, args->toname, args->tolen);
}
/*
@ -766,16 +737,13 @@ static int nfs2_xdr_enc_linkargs(struct rpc_rqst *req, __be32 *p,
* sattr attributes;
* };
*/
static int nfs2_xdr_enc_symlinkargs(struct rpc_rqst *req, __be32 *p,
const struct nfs_symlinkargs *args)
static void nfs2_xdr_enc_symlinkargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_symlinkargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_diropargs(&xdr, args->fromfh, args->fromname, args->fromlen);
encode_path(&xdr, args->pages, args->pathlen);
encode_sattr(&xdr, args->sattr);
return 0;
encode_diropargs(xdr, args->fromfh, args->fromname, args->fromlen);
encode_path(xdr, args->pages, args->pathlen);
encode_sattr(xdr, args->sattr);
}
/*
@ -799,16 +767,13 @@ static void encode_readdirargs(struct xdr_stream *xdr,
*p = cpu_to_be32(args->count);
}
static int nfs2_xdr_enc_readdirargs(struct rpc_rqst *req, __be32 *p,
const struct nfs_readdirargs *args)
static void nfs2_xdr_enc_readdirargs(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_readdirargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_readdirargs(&xdr, args);
encode_readdirargs(xdr, args);
prepare_reply_buffer(req, args->pages, 0,
args->count, NFS_readdirres_sz);
return 0;
}
/*
@ -1184,7 +1149,7 @@ int nfs_stat_to_errno(enum nfs_stat status)
#define PROC(proc, argtype, restype, timer) \
[NFSPROC_##proc] = { \
.p_proc = NFSPROC_##proc, \
.p_encode = (kxdrproc_t)nfs2_xdr_enc_##argtype, \
.p_encode = (kxdreproc_t)nfs2_xdr_enc_##argtype, \
.p_decode = (kxdrproc_t)nfs2_xdr_dec_##restype, \
.p_arglen = NFS_##argtype##_sz, \
.p_replen = NFS_##restype##_sz, \

241
fs/nfs/nfs3xdr.c
View File

@ -835,14 +835,11 @@ static void encode_diropargs3(struct xdr_stream *xdr, const struct nfs_fh *fh,
* nfs_fh3 object;
* };
*/
static int nfs3_xdr_enc_getattr3args(struct rpc_rqst *req, __be32 *p,
const struct nfs_fh *fh)
static void nfs3_xdr_enc_getattr3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_fh *fh)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_nfs_fh3(&xdr, fh);
return 0;
encode_nfs_fh3(xdr, fh);
}
/*
@ -876,16 +873,13 @@ static void encode_sattrguard3(struct xdr_stream *xdr,
}
}
static int nfs3_xdr_enc_setattr3args(struct rpc_rqst *req, __be32 *p,
const struct nfs3_sattrargs *args)
static void nfs3_xdr_enc_setattr3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs3_sattrargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_nfs_fh3(&xdr, args->fh);
encode_sattr3(&xdr, args->sattr);
encode_sattrguard3(&xdr, args);
return 0;
encode_nfs_fh3(xdr, args->fh);
encode_sattr3(xdr, args->sattr);
encode_sattrguard3(xdr, args);
}
/*
@ -895,14 +889,11 @@ static int nfs3_xdr_enc_setattr3args(struct rpc_rqst *req, __be32 *p,
* diropargs3 what;
* };
*/
static int nfs3_xdr_enc_lookup3args(struct rpc_rqst *req, __be32 *p,
const struct nfs3_diropargs *args)
static void nfs3_xdr_enc_lookup3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs3_diropargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_diropargs3(&xdr, args->fh, args->name, args->len);
return 0;
encode_diropargs3(xdr, args->fh, args->name, args->len);
}
/*
@ -920,14 +911,11 @@ static void encode_access3args(struct xdr_stream *xdr,
encode_uint32(xdr, args->access);
}
static int nfs3_xdr_enc_access3args(struct rpc_rqst *req, __be32 *p,
const struct nfs3_accessargs *args)
static void nfs3_xdr_enc_access3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs3_accessargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_access3args(&xdr, args);
return 0;
encode_access3args(xdr, args);
}
/*
@ -937,16 +925,13 @@ static int nfs3_xdr_enc_access3args(struct rpc_rqst *req, __be32 *p,
* nfs_fh3 symlink;
* };
*/
static int nfs3_xdr_enc_readlink3args(struct rpc_rqst *req, __be32 *p,
const struct nfs3_readlinkargs *args)
static void nfs3_xdr_enc_readlink3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs3_readlinkargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_nfs_fh3(&xdr, args->fh);
encode_nfs_fh3(xdr, args->fh);
prepare_reply_buffer(req, args->pages, args->pgbase,
args->pglen, NFS3_readlinkres_sz);
return 0;
}
/*
@ -970,17 +955,14 @@ static void encode_read3args(struct xdr_stream *xdr,
*p = cpu_to_be32(args->count);
}
static int nfs3_xdr_enc_read3args(struct rpc_rqst *req, __be32 *p,
const struct nfs_readargs *args)
static void nfs3_xdr_enc_read3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_readargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_read3args(&xdr, args);
encode_read3args(xdr, args);
prepare_reply_buffer(req, args->pages, args->pgbase,
args->count, NFS3_readres_sz);
req->rq_rcv_buf.flags |= XDRBUF_READ;
return 0;
}
/*
@ -1015,15 +997,12 @@ static void encode_write3args(struct xdr_stream *xdr,
xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
}
static int nfs3_xdr_enc_write3args(struct rpc_rqst *req, __be32 *p,
const struct nfs_writeargs *args)
static void nfs3_xdr_enc_write3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_writeargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_write3args(&xdr, args);
xdr.buf->flags |= XDRBUF_WRITE;
return 0;
encode_write3args(xdr, args);
xdr->buf->flags |= XDRBUF_WRITE;
}
/*
@ -1065,15 +1044,12 @@ static void encode_createhow3(struct xdr_stream *xdr,
}
}
static int nfs3_xdr_enc_create3args(struct rpc_rqst *req, __be32 *p,
const struct nfs3_createargs *args)
static void nfs3_xdr_enc_create3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs3_createargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_diropargs3(&xdr, args->fh, args->name, args->len);
encode_createhow3(&xdr, args);
return 0;
encode_diropargs3(xdr, args->fh, args->name, args->len);
encode_createhow3(xdr, args);
}
/*
@ -1084,15 +1060,12 @@ static int nfs3_xdr_enc_create3args(struct rpc_rqst *req, __be32 *p,
* sattr3 attributes;
* };
*/
static int nfs3_xdr_enc_mkdir3args(struct rpc_rqst *req, __be32 *p,
const struct nfs3_mkdirargs *args)
static void nfs3_xdr_enc_mkdir3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs3_mkdirargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_diropargs3(&xdr, args->fh, args->name, args->len);
encode_sattr3(&xdr, args->sattr);
return 0;
encode_diropargs3(xdr, args->fh, args->name, args->len);
encode_sattr3(xdr, args->sattr);
}
/*
@ -1115,15 +1088,12 @@ static void encode_symlinkdata3(struct xdr_stream *xdr,
encode_nfspath3(xdr, args->pages, args->pathlen);
}
static int nfs3_xdr_enc_symlink3args(struct rpc_rqst *req, __be32 *p,
const struct nfs3_symlinkargs *args)
static void nfs3_xdr_enc_symlink3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs3_symlinkargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_diropargs3(&xdr, args->fromfh, args->fromname, args->fromlen);
encode_symlinkdata3(&xdr, args);
return 0;
encode_diropargs3(xdr, args->fromfh, args->fromname, args->fromlen);
encode_symlinkdata3(xdr, args);
}
/*
@ -1178,15 +1148,12 @@ static void encode_mknoddata3(struct xdr_stream *xdr,
}
}
static int nfs3_xdr_enc_mknod3args(struct rpc_rqst *req, __be32 *p,
const struct nfs3_mknodargs *args)
static void nfs3_xdr_enc_mknod3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs3_mknodargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_diropargs3(&xdr, args->fh, args->name, args->len);
encode_mknoddata3(&xdr, args);
return 0;
encode_diropargs3(xdr, args->fh, args->name, args->len);
encode_mknoddata3(xdr, args);
}
/*
@ -1196,14 +1163,11 @@ static int nfs3_xdr_enc_mknod3args(struct rpc_rqst *req, __be32 *p,
* diropargs3 object;
* };
*/
static int nfs3_xdr_enc_remove3args(struct rpc_rqst *req, __be32 *p,
const struct nfs_removeargs *args)
static void nfs3_xdr_enc_remove3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_removeargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_diropargs3(&xdr, args->fh, args->name.name, args->name.len);
return 0;
encode_diropargs3(xdr, args->fh, args->name.name, args->name.len);
}
/*
@ -1214,17 +1178,15 @@ static int nfs3_xdr_enc_remove3args(struct rpc_rqst *req, __be32 *p,
* diropargs3 to;
* };
*/
static int nfs3_xdr_enc_rename3args(struct rpc_rqst *req, __be32 *p,
const struct nfs_renameargs *args)
static void nfs3_xdr_enc_rename3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_renameargs *args)
{
const struct qstr *old = args->old_name;
const struct qstr *new = args->new_name;
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_diropargs3(&xdr, args->old_dir, old->name, old->len);
encode_diropargs3(&xdr, args->new_dir, new->name, new->len);
return 0;
encode_diropargs3(xdr, args->old_dir, old->name, old->len);
encode_diropargs3(xdr, args->new_dir, new->name, new->len);
}
/*
@ -1235,15 +1197,12 @@ static int nfs3_xdr_enc_rename3args(struct rpc_rqst *req, __be32 *p,
* diropargs3 link;
* };
*/
static int nfs3_xdr_enc_link3args(struct rpc_rqst *req, __be32 *p,
const struct nfs3_linkargs *args)
static void nfs3_xdr_enc_link3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs3_linkargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_nfs_fh3(&xdr, args->fromfh);
encode_diropargs3(&xdr, args->tofh, args->toname, args->tolen);
return 0;
encode_nfs_fh3(xdr, args->fromfh);
encode_diropargs3(xdr, args->tofh, args->toname, args->tolen);
}
/*
@ -1269,16 +1228,13 @@ static void encode_readdir3args(struct xdr_stream *xdr,
*p = cpu_to_be32(args->count);
}
static int nfs3_xdr_enc_readdir3args(struct rpc_rqst *req, __be32 *p,
const struct nfs3_readdirargs *args)
static void nfs3_xdr_enc_readdir3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs3_readdirargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_readdir3args(&xdr, args);
encode_readdir3args(xdr, args);
prepare_reply_buffer(req, args->pages, 0,
args->count, NFS3_readdirres_sz);
return 0;
}
/*
@ -1312,16 +1268,13 @@ static void encode_readdirplus3args(struct xdr_stream *xdr,
*p = cpu_to_be32(args->count);
}
static int nfs3_xdr_enc_readdirplus3args(struct rpc_rqst *req, __be32 *p,
const struct nfs3_readdirargs *args)
static void nfs3_xdr_enc_readdirplus3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs3_readdirargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_readdirplus3args(&xdr, args);
encode_readdirplus3args(xdr, args);
prepare_reply_buffer(req, args->pages, 0,
args->count, NFS3_readdirres_sz);
return 0;
}
/*
@ -1345,57 +1298,49 @@ static void encode_commit3args(struct xdr_stream *xdr,
*p = cpu_to_be32(args->count);
}
static int nfs3_xdr_enc_commit3args(struct rpc_rqst *req, __be32 *p,
const struct nfs_writeargs *args)
static void nfs3_xdr_enc_commit3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs_writeargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_commit3args(&xdr, args);
return 0;
encode_commit3args(xdr, args);
}
#ifdef CONFIG_NFS_V3_ACL
static int nfs3_xdr_enc_getacl3args(struct rpc_rqst *req, __be32 *p,
const struct nfs3_getaclargs *args)
static void nfs3_xdr_enc_getacl3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs3_getaclargs *args)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_nfs_fh3(&xdr, args->fh);
encode_uint32(&xdr, args->mask);
encode_nfs_fh3(xdr, args->fh);
encode_uint32(xdr, args->mask);
if (args->mask & (NFS_ACL | NFS_DFACL))
prepare_reply_buffer(req, args->pages, 0,
NFSACL_MAXPAGES << PAGE_SHIFT,
ACL3_getaclres_sz);
return 0;
}
static int nfs3_xdr_enc_setacl3args(struct rpc_rqst *req, __be32 *p,
const struct nfs3_setaclargs *args)
static void nfs3_xdr_enc_setacl3args(struct rpc_rqst *req,
struct xdr_stream *xdr,
const struct nfs3_setaclargs *args)
{
struct xdr_stream xdr;
unsigned int base;
int error;
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_nfs_fh3(&xdr, NFS_FH(args->inode));
encode_uint32(&xdr, args->mask);
encode_nfs_fh3(xdr, NFS_FH(args->inode));
encode_uint32(xdr, args->mask);
if (args->npages != 0)
xdr_write_pages(&xdr, args->pages, 0, args->len);
xdr_write_pages(xdr, args->pages, 0, args->len);
base = req->rq_slen;
error = nfsacl_encode(xdr.buf, base, args->inode,
error = nfsacl_encode(xdr->buf, base, args->inode,
(args->mask & NFS_ACL) ?
args->acl_access : NULL, 1, 0);
BUG_ON(error < 0);
error = nfsacl_encode(xdr.buf, base + error, args->inode,
error = nfsacl_encode(xdr->buf, base + error, args->inode,
(args->mask & NFS_DFACL) ?
args->acl_default : NULL, 1,
NFS_ACL_DEFAULT);
BUG_ON(error < 0);
return 0;
}
#endif /* CONFIG_NFS_V3_ACL */
@ -2506,7 +2451,7 @@ out_default:
#define PROC(proc, argtype, restype, timer) \
[NFS3PROC_##proc] = { \
.p_proc = NFS3PROC_##proc, \
.p_encode = (kxdrproc_t)nfs3_xdr_enc_##argtype##3args, \
.p_encode = (kxdreproc_t)nfs3_xdr_enc_##argtype##3args, \
.p_decode = (kxdrproc_t)nfs3_xdr_dec_##restype##3res, \
.p_arglen = NFS3_##argtype##args_sz, \
.p_replen = NFS3_##restype##res_sz, \
@ -2549,7 +2494,7 @@ struct rpc_version nfs_version3 = {
static struct rpc_procinfo nfs3_acl_procedures[] = {
[ACLPROC3_GETACL] = {
.p_proc = ACLPROC3_GETACL,
.p_encode = (kxdrproc_t)nfs3_xdr_enc_getacl3args,
.p_encode = (kxdreproc_t)nfs3_xdr_enc_getacl3args,
.p_decode = (kxdrproc_t)nfs3_xdr_dec_getacl3res,
.p_arglen = ACL3_getaclargs_sz,
.p_replen = ACL3_getaclres_sz,
@ -2558,7 +2503,7 @@ static struct rpc_procinfo nfs3_acl_procedures[] = {
},
[ACLPROC3_SETACL] = {
.p_proc = ACLPROC3_SETACL,
.p_encode = (kxdrproc_t)nfs3_xdr_enc_setacl3args,
.p_encode = (kxdreproc_t)nfs3_xdr_enc_setacl3args,
.p_decode = (kxdrproc_t)nfs3_xdr_dec_setacl3res,
.p_arglen = ACL3_setaclargs_sz,
.p_replen = ACL3_setaclres_sz,

663
fs/nfs/nfs4xdr.c
View File

File diff suppressed because it is too large Load Diff

22
fs/nfsd/nfs4callback.c
View File

@ -499,34 +499,28 @@ out_default:
/*
* NB: Without this zero space reservation, callbacks over krb5p fail
*/
static int nfs4_xdr_enc_cb_null(struct rpc_rqst *req, __be32 *p, void *__unused)
static void nfs4_xdr_enc_cb_null(struct rpc_rqst *req, struct xdr_stream *xdr,
void *__unused)
{
struct xdr_stream xdrs, *xdr = &xdrs;
xdr_init_encode(&xdrs, &req->rq_snd_buf, p);
xdr_reserve_space(xdr, 0);
return 0;
}
/*
* 20.2. Operation 4: CB_RECALL - Recall a Delegation
*/
static int nfs4_xdr_enc_cb_recall(struct rpc_rqst *req, __be32 *p,
const struct nfsd4_callback *cb)
static void nfs4_xdr_enc_cb_recall(struct rpc_rqst *req, struct xdr_stream *xdr,
const struct nfsd4_callback *cb)
{
struct xdr_stream xdr;
const struct nfs4_delegation *args = cb->cb_op;
struct nfs4_cb_compound_hdr hdr = {
.ident = cb->cb_clp->cl_cb_ident,
.minorversion = cb->cb_minorversion,
};
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
encode_cb_compound4args(&xdr, &hdr);
encode_cb_sequence4args(&xdr, cb, &hdr);
encode_cb_recall4args(&xdr, args, &hdr);
encode_cb_compound4args(xdr, &hdr);
encode_cb_sequence4args(xdr, cb, &hdr);
encode_cb_recall4args(xdr, args, &hdr);
encode_cb_nops(&hdr);
return 0;
}
@ -583,7 +577,7 @@ out_default:
#define PROC(proc, call, argtype, restype) \
[NFSPROC4_CLNT_##proc] = { \
.p_proc = NFSPROC4_CB_##call, \
.p_encode = (kxdrproc_t)nfs4_xdr_enc_##argtype, \
.p_encode = (kxdreproc_t)nfs4_xdr_enc_##argtype, \
.p_decode = (kxdrproc_t)nfs4_xdr_dec_##restype, \
.p_arglen = NFS4_enc_##argtype##_sz, \
.p_replen = NFS4_dec_##restype##_sz, \

4
include/linux/sunrpc/auth.h
View File

@ -110,7 +110,7 @@ struct rpc_credops {
__be32 * (*crmarshal)(struct rpc_task *, __be32 *);
int (*crrefresh)(struct rpc_task *);
__be32 * (*crvalidate)(struct rpc_task *, __be32 *);
int (*crwrap_req)(struct rpc_task *, kxdrproc_t,
int (*crwrap_req)(struct rpc_task *, kxdreproc_t,
void *, __be32 *, void *);
int (*crunwrap_resp)(struct rpc_task *, kxdrproc_t,
void *, __be32 *, void *);
@ -139,7 +139,7 @@ struct rpc_cred * rpcauth_generic_bind_cred(struct rpc_task *, struct rpc_cred *
void put_rpccred(struct rpc_cred *);
__be32 * rpcauth_marshcred(struct rpc_task *, __be32 *);
__be32 * rpcauth_checkverf(struct rpc_task *, __be32 *);
int rpcauth_wrap_req(struct rpc_task *task, kxdrproc_t encode, void *rqstp, __be32 *data, void *obj);
int rpcauth_wrap_req(struct rpc_task *task, kxdreproc_t encode, void *rqstp, __be32 *data, void *obj);
int rpcauth_unwrap_resp(struct rpc_task *task, kxdrproc_t decode, void *rqstp, __be32 *data, void *obj);
int rpcauth_refreshcred(struct rpc_task *);
void rpcauth_invalcred(struct rpc_task *);

2
include/linux/sunrpc/clnt.h
View File

@ -89,7 +89,7 @@ struct rpc_version {
*/
struct rpc_procinfo {
u32 p_proc; /* RPC procedure number */
kxdrproc_t p_encode; /* XDR encode function */
kxdreproc_t p_encode; /* XDR encode function */
kxdrproc_t p_decode; /* XDR decode function */
unsigned int p_arglen; /* argument hdr length (u32) */
unsigned int p_replen; /* reply hdr length (u32) */

9
include/linux/sunrpc/xdr.h
View File

@ -33,8 +33,8 @@ struct xdr_netobj {
};
/*
* This is the generic XDR function. rqstp is either a rpc_rqst (client
* side) or svc_rqst pointer (server side).
* This is the legacy generic XDR function. rqstp is either a rpc_rqst
* (client side) or svc_rqst pointer (server side).
* Encode functions always assume there's enough room in the buffer.
*/
typedef int (*kxdrproc_t)(void *rqstp, __be32 *data, void *obj);
@ -203,6 +203,11 @@ struct xdr_stream {
struct kvec *iov; /* pointer to the current kvec */
};
/*
* This is the xdr_stream style generic XDR function.
*/
typedef void (*kxdreproc_t)(void *rqstp, struct xdr_stream *xdr, void *obj);
extern void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p);
extern __be32 *xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes);
extern void xdr_write_pages(struct xdr_stream *xdr, struct page **pages,

14
net/sunrpc/auth.c
View File

@ -563,8 +563,17 @@ rpcauth_checkverf(struct rpc_task *task, __be32 *p)
return cred->cr_ops->crvalidate(task, p);
}
static void rpcauth_wrap_req_encode(kxdreproc_t encode, struct rpc_rqst *rqstp,
__be32 *data, void *obj)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &rqstp->rq_snd_buf, data);
encode(rqstp, &xdr, obj);
}
int
rpcauth_wrap_req(struct rpc_task *task, kxdrproc_t encode, void *rqstp,
rpcauth_wrap_req(struct rpc_task *task, kxdreproc_t encode, void *rqstp,
__be32 *data, void *obj)
{
struct rpc_cred *cred = task->tk_rqstp->rq_cred;
@ -574,7 +583,8 @@ rpcauth_wrap_req(struct rpc_task *task, kxdrproc_t encode, void *rqstp,
if (cred->cr_ops->crwrap_req)
return cred->cr_ops->crwrap_req(task, encode, rqstp, data, obj);
/* By default, we encode the arguments normally. */
return encode(rqstp, data, obj);
rpcauth_wrap_req_encode(encode, rqstp, data, obj);
return 0;
}
int

31
net/sunrpc/auth_gss/auth_gss.c
View File

@ -1231,9 +1231,19 @@ out_bad:
return NULL;
}
static void gss_wrap_req_encode(kxdreproc_t encode, struct rpc_rqst *rqstp,
__be32 *p, void *obj)
{
struct xdr_stream xdr;
xdr_init_encode(&xdr, &rqstp->rq_snd_buf, p);
encode(rqstp, &xdr, obj);
}
static inline int
gss_wrap_req_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
kxdrproc_t encode, struct rpc_rqst *rqstp, __be32 *p, void *obj)
kxdreproc_t encode, struct rpc_rqst *rqstp,
__be32 *p, void *obj)
{
struct xdr_buf *snd_buf = &rqstp->rq_snd_buf;
struct xdr_buf integ_buf;
@ -1249,9 +1259,7 @@ gss_wrap_req_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
offset = (u8 *)p - (u8 *)snd_buf->head[0].iov_base;
*p++ = htonl(rqstp->rq_seqno);
status = encode(rqstp, p, obj);
if (status)
return status;
gss_wrap_req_encode(encode, rqstp, p, obj);
if (xdr_buf_subsegment(snd_buf, &integ_buf,
offset, snd_buf->len - offset))
@ -1325,7 +1333,8 @@ out:
static inline int
gss_wrap_req_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
kxdrproc_t encode, struct rpc_rqst *rqstp, __be32 *p, void *obj)
kxdreproc_t encode, struct rpc_rqst *rqstp,
__be32 *p, void *obj)
{
struct xdr_buf *snd_buf = &rqstp->rq_snd_buf;
u32 offset;
@ -1342,9 +1351,7 @@ gss_wrap_req_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
offset = (u8 *)p - (u8 *)snd_buf->head[0].iov_base;
*p++ = htonl(rqstp->rq_seqno);
status = encode(rqstp, p, obj);
if (status)
return status;
gss_wrap_req_encode(encode, rqstp, p, obj);
status = alloc_enc_pages(rqstp);
if (status)
@ -1394,7 +1401,7 @@ gss_wrap_req_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
static int
gss_wrap_req(struct rpc_task *task,
kxdrproc_t encode, void *rqstp, __be32 *p, void *obj)
kxdreproc_t encode, void *rqstp, __be32 *p, void *obj)
{
struct rpc_cred *cred = task->tk_rqstp->rq_cred;
struct gss_cred *gss_cred = container_of(cred, struct gss_cred,
@ -1407,12 +1414,14 @@ gss_wrap_req(struct rpc_task *task,
/* The spec seems a little ambiguous here, but I think that not
* wrapping context destruction requests makes the most sense.
*/
status = encode(rqstp, p, obj);
gss_wrap_req_encode(encode, rqstp, p, obj);
status = 0;
goto out;
}
switch (gss_cred->gc_service) {
case RPC_GSS_SVC_NONE:
status = encode(rqstp, p, obj);
gss_wrap_req_encode(encode, rqstp, p, obj);
status = 0;
break;
case RPC_GSS_SVC_INTEGRITY:
status = gss_wrap_req_integ(cred, ctx, encode,

5
net/sunrpc/clnt.c
View File

@ -1095,7 +1095,7 @@ static void
rpc_xdr_encode(struct rpc_task *task)
{
struct rpc_rqst *req = task->tk_rqstp;
kxdrproc_t encode;
kxdreproc_t encode;
__be32 *p;
dprint_status(task);
@ -1776,9 +1776,8 @@ out_overflow:
goto out_garbage;
}
static int rpcproc_encode_null(void *rqstp, __be32 *data, void *obj)
static void rpcproc_encode_null(void *rqstp, struct xdr_stream *xdr, void *obj)
{
return 0;
}
static int rpcproc_decode_null(void *rqstp, __be32 *data, void *obj)

47
net/sunrpc/rpcb_clnt.c
View File

@ -689,25 +689,21 @@ static void rpcb_getport_done(struct rpc_task *child, void *data)
* XDR functions for rpcbind
*/
static int rpcb_enc_mapping(struct rpc_rqst *req, __be32 *p,
const struct rpcbind_args *rpcb)
static void rpcb_enc_mapping(struct rpc_rqst *req, struct xdr_stream *xdr,
const struct rpcbind_args *rpcb)
{
struct rpc_task *task = req->rq_task;
struct xdr_stream xdr;
__be32 *p;
dprintk("RPC: %5u encoding PMAP_%s call (%u, %u, %d, %u)\n",
task->tk_pid, task->tk_msg.rpc_proc->p_name,
rpcb->r_prog, rpcb->r_vers, rpcb->r_prot, rpcb->r_port);
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
p = xdr_reserve_space(&xdr, RPCB_mappingargs_sz << 2);
p = xdr_reserve_space(xdr, RPCB_mappingargs_sz << 2);
*p++ = cpu_to_be32(rpcb->r_prog);
*p++ = cpu_to_be32(rpcb->r_vers);
*p++ = cpu_to_be32(rpcb->r_prot);
*p = cpu_to_be32(rpcb->r_port);
return 0;
}
static int rpcb_dec_getport(struct rpc_rqst *req, __be32 *p,
@ -769,27 +765,24 @@ static void encode_rpcb_string(struct xdr_stream *xdr, const char *string,
xdr_encode_opaque(p, string, len);
}
static int rpcb_enc_getaddr(struct rpc_rqst *req, __be32 *p,
const struct rpcbind_args *rpcb)
static void rpcb_enc_getaddr(struct rpc_rqst *req, struct xdr_stream *xdr,
const struct rpcbind_args *rpcb)
{
struct rpc_task *task = req->rq_task;
struct xdr_stream xdr;
__be32 *p;
dprintk("RPC: %5u encoding RPCB_%s call (%u, %u, '%s', '%s')\n",
task->tk_pid, task->tk_msg.rpc_proc->p_name,
rpcb->r_prog, rpcb->r_vers,
rpcb->r_netid, rpcb->r_addr);
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
p = xdr_reserve_space(&xdr, (RPCB_program_sz + RPCB_version_sz) << 2);
p = xdr_reserve_space(xdr, (RPCB_program_sz + RPCB_version_sz) << 2);
*p++ = cpu_to_be32(rpcb->r_prog);
*p = cpu_to_be32(rpcb->r_vers);
encode_rpcb_string(&xdr, rpcb->r_netid, RPCBIND_MAXNETIDLEN);
encode_rpcb_string(&xdr, rpcb->r_addr, RPCBIND_MAXUADDRLEN);
encode_rpcb_string(&xdr, rpcb->r_owner, RPCB_MAXOWNERLEN);
return 0;
encode_rpcb_string(xdr, rpcb->r_netid, RPCBIND_MAXNETIDLEN);
encode_rpcb_string(xdr, rpcb->r_addr, RPCBIND_MAXUADDRLEN);
encode_rpcb_string(xdr, rpcb->r_owner, RPCB_MAXOWNERLEN);
}
static int rpcb_dec_getaddr(struct rpc_rqst *req, __be32 *p,
@ -849,7 +842,7 @@ out_fail:
static struct rpc_procinfo rpcb_procedures2[] = {
[RPCBPROC_SET] = {
.p_proc = RPCBPROC_SET,
.p_encode = (kxdrproc_t)rpcb_enc_mapping,
.p_encode = (kxdreproc_t)rpcb_enc_mapping,
.p_decode = (kxdrproc_t)rpcb_dec_set,
.p_arglen = RPCB_mappingargs_sz,
.p_replen = RPCB_setres_sz,
@ -859,7 +852,7 @@ static struct rpc_procinfo rpcb_procedures2[] = {
},
[RPCBPROC_UNSET] = {
.p_proc = RPCBPROC_UNSET,
.p_encode = (kxdrproc_t)rpcb_enc_mapping,
.p_encode = (kxdreproc_t)rpcb_enc_mapping,
.p_decode = (kxdrproc_t)rpcb_dec_set,
.p_arglen = RPCB_mappingargs_sz,
.p_replen = RPCB_setres_sz,
@ -869,7 +862,7 @@ static struct rpc_procinfo rpcb_procedures2[] = {
},
[RPCBPROC_GETPORT] = {
.p_proc = RPCBPROC_GETPORT,
.p_encode = (kxdrproc_t)rpcb_enc_mapping,
.p_encode = (kxdreproc_t)rpcb_enc_mapping,
.p_decode = (kxdrproc_t)rpcb_dec_getport,
.p_arglen = RPCB_mappingargs_sz,
.p_replen = RPCB_getportres_sz,
@ -882,7 +875,7 @@ static struct rpc_procinfo rpcb_procedures2[] = {
static struct rpc_procinfo rpcb_procedures3[] = {
[RPCBPROC_SET] = {
.p_proc = RPCBPROC_SET,
.p_encode = (kxdrproc_t)rpcb_enc_getaddr,
.p_encode = (kxdreproc_t)rpcb_enc_getaddr,
.p_decode = (kxdrproc_t)rpcb_dec_set,
.p_arglen = RPCB_getaddrargs_sz,
.p_replen = RPCB_setres_sz,
@ -892,7 +885,7 @@ static struct rpc_procinfo rpcb_procedures3[] = {
},
[RPCBPROC_UNSET] = {
.p_proc = RPCBPROC_UNSET,
.p_encode = (kxdrproc_t)rpcb_enc_getaddr,
.p_encode = (kxdreproc_t)rpcb_enc_getaddr,
.p_decode = (kxdrproc_t)rpcb_dec_set,
.p_arglen = RPCB_getaddrargs_sz,
.p_replen = RPCB_setres_sz,
@ -902,7 +895,7 @@ static struct rpc_procinfo rpcb_procedures3[] = {
},
[RPCBPROC_GETADDR] = {
.p_proc = RPCBPROC_GETADDR,
.p_encode = (kxdrproc_t)rpcb_enc_getaddr,
.p_encode = (kxdreproc_t)rpcb_enc_getaddr,
.p_decode = (kxdrproc_t)rpcb_dec_getaddr,
.p_arglen = RPCB_getaddrargs_sz,
.p_replen = RPCB_getaddrres_sz,
@ -915,7 +908,7 @@ static struct rpc_procinfo rpcb_procedures3[] = {
static struct rpc_procinfo rpcb_procedures4[] = {
[RPCBPROC_SET] = {
.p_proc = RPCBPROC_SET,
.p_encode = (kxdrproc_t)rpcb_enc_getaddr,
.p_encode = (kxdreproc_t)rpcb_enc_getaddr,
.p_decode = (kxdrproc_t)rpcb_dec_set,
.p_arglen = RPCB_getaddrargs_sz,
.p_replen = RPCB_setres_sz,
@ -925,7 +918,7 @@ static struct rpc_procinfo rpcb_procedures4[] = {
},
[RPCBPROC_UNSET] = {
.p_proc = RPCBPROC_UNSET,
.p_encode = (kxdrproc_t)rpcb_enc_getaddr,
.p_encode = (kxdreproc_t)rpcb_enc_getaddr,
.p_decode = (kxdrproc_t)rpcb_dec_set,
.p_arglen = RPCB_getaddrargs_sz,
.p_replen = RPCB_setres_sz,
@ -935,7 +928,7 @@ static struct rpc_procinfo rpcb_procedures4[] = {
},
[RPCBPROC_GETADDR] = {
.p_proc = RPCBPROC_GETADDR,
.p_encode = (kxdrproc_t)rpcb_enc_getaddr,
.p_encode = (kxdreproc_t)rpcb_enc_getaddr,
.p_decode = (kxdrproc_t)rpcb_dec_getaddr,
.p_arglen = RPCB_getaddrargs_sz,
.p_replen = RPCB_getaddrres_sz,