Merge tag 'nfsd-4.13' of git://linux-nfs.org/~bfields/linux
authorLinus Torvalds <torvalds@linux-foundation.org>
Thu, 13 Jul 2017 20:56:24 +0000 (13:56 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Thu, 13 Jul 2017 20:56:24 +0000 (13:56 -0700)
Pull nfsd updates from Bruce Fields:
 "Chuck's RDMA update overhauls the "call receive" side of the
  RPC-over-RDMA transport to use the new rdma_rw API.

  Christoph cleaned the way nfs operations are declared, removing a
  bunch of function-pointer casts and declaring the operation vectors as
  const.

  Christoph's changes touch both client and server, and both client and
  server pulls this time around should be based on the same commits from
  Christoph"

* tag 'nfsd-4.13' of git://linux-nfs.org/~bfields/linux: (53 commits)
  svcrdma: fix an incorrect check on -E2BIG and -EINVAL
  nfsd4: factor ctime into change attribute
  svcrdma: Remove svc_rdma_chunk_ctxt::cc_dir field
  svcrdma: use offset_in_page() macro
  svcrdma: Clean up after converting svc_rdma_recvfrom to rdma_rw API
  svcrdma: Clean-up svc_rdma_unmap_dma
  svcrdma: Remove frmr cache
  svcrdma: Remove unused Read completion handlers
  svcrdma: Properly compute .len and .buflen for received RPC Calls
  svcrdma: Use generic RDMA R/W API in RPC Call path
  svcrdma: Add recvfrom helpers to svc_rdma_rw.c
  sunrpc: Allocate up to RPCSVC_MAXPAGES per svc_rqst
  svcrdma: Don't account for Receive queue "starvation"
  svcrdma: Improve Reply chunk sanity checking
  svcrdma: Improve Write chunk sanity checking
  svcrdma: Improve Read chunk sanity checking
  svcrdma: Remove svc_rdma_marshal.c
  svcrdma: Avoid Send Queue overflow
  svcrdma: Squelch disconnection messages
  sunrpc: Disable splice for krb5i
  ...

59 files changed:
fs/lockd/clnt4xdr.c
fs/lockd/clntxdr.c
fs/lockd/mon.c
fs/lockd/svc.c
fs/lockd/svc4proc.c
fs/lockd/svcproc.c
fs/lockd/xdr.c
fs/lockd/xdr4.c
fs/nfs/callback.c
fs/nfs/callback.h
fs/nfs/callback_proc.c
fs/nfs/callback_xdr.c
fs/nfs/internal.h
fs/nfs/mount_clnt.c
fs/nfs/nfs2xdr.c
fs/nfs/nfs3xdr.c
fs/nfs/nfs42xdr.c
fs/nfs/nfs4_fs.h
fs/nfs/nfs4xdr.c
fs/nfsd/current_stateid.h
fs/nfsd/nfs2acl.c
fs/nfsd/nfs3acl.c
fs/nfsd/nfs3proc.c
fs/nfsd/nfs3xdr.c
fs/nfsd/nfs4callback.c
fs/nfsd/nfs4proc.c
fs/nfsd/nfs4state.c
fs/nfsd/nfs4xdr.c
fs/nfsd/nfsd.h
fs/nfsd/nfsfh.h
fs/nfsd/nfsproc.c
fs/nfsd/nfssvc.c
fs/nfsd/nfsxdr.c
fs/nfsd/xdr.h
fs/nfsd/xdr3.h
fs/nfsd/xdr4.h
include/linux/lockd/lockd.h
include/linux/lockd/xdr.h
include/linux/lockd/xdr4.h
include/linux/sunrpc/clnt.h
include/linux/sunrpc/sched.h
include/linux/sunrpc/svc.h
include/linux/sunrpc/svc_rdma.h
include/linux/sunrpc/xdr.h
net/sunrpc/auth_gss/gss_rpc_upcall.c
net/sunrpc/auth_gss/gss_rpc_xdr.c
net/sunrpc/auth_gss/gss_rpc_xdr.h
net/sunrpc/auth_gss/svcauth_gss.c
net/sunrpc/clnt.c
net/sunrpc/rpcb_clnt.c
net/sunrpc/stats.c
net/sunrpc/svc.c
net/sunrpc/svc_xprt.c
net/sunrpc/xprtrdma/Makefile
net/sunrpc/xprtrdma/svc_rdma_marshal.c [deleted file]
net/sunrpc/xprtrdma/svc_rdma_recvfrom.c
net/sunrpc/xprtrdma/svc_rdma_rw.c
net/sunrpc/xprtrdma/svc_rdma_sendto.c
net/sunrpc/xprtrdma/svc_rdma_transport.c

index d3e40db289302b6de209f32ee0fd7926372d3e16..c349fc0f9b80413f501bd0ea960e3a7eaefa8c92 100644 (file)
@@ -381,8 +381,9 @@ static void encode_nlm4_lock(struct xdr_stream *xdr,
  */
 static void nlm4_xdr_enc_testargs(struct rpc_rqst *req,
                                  struct xdr_stream *xdr,
-                                 const struct nlm_args *args)
+                                 const void *data)
 {
+       const struct nlm_args *args = data;
        const struct nlm_lock *lock = &args->lock;
 
        encode_cookie(xdr, &args->cookie);
@@ -402,8 +403,9 @@ static void nlm4_xdr_enc_testargs(struct rpc_rqst *req,
  */
 static void nlm4_xdr_enc_lockargs(struct rpc_rqst *req,
                                  struct xdr_stream *xdr,
-                                 const struct nlm_args *args)
+                                 const void *data)
 {
+       const struct nlm_args *args = data;
        const struct nlm_lock *lock = &args->lock;
 
        encode_cookie(xdr, &args->cookie);
@@ -424,8 +426,9 @@ static void nlm4_xdr_enc_lockargs(struct rpc_rqst *req,
  */
 static void nlm4_xdr_enc_cancargs(struct rpc_rqst *req,
                                  struct xdr_stream *xdr,
-                                 const struct nlm_args *args)
+                                 const void *data)
 {
+       const struct nlm_args *args = data;
        const struct nlm_lock *lock = &args->lock;
 
        encode_cookie(xdr, &args->cookie);
@@ -442,8 +445,9 @@ static void nlm4_xdr_enc_cancargs(struct rpc_rqst *req,
  */
 static void nlm4_xdr_enc_unlockargs(struct rpc_rqst *req,
                                    struct xdr_stream *xdr,
-                                   const struct nlm_args *args)
+                                   const void *data)
 {
+       const struct nlm_args *args = data;
        const struct nlm_lock *lock = &args->lock;
 
        encode_cookie(xdr, &args->cookie);
@@ -458,8 +462,10 @@ static void nlm4_xdr_enc_unlockargs(struct rpc_rqst *req,
  */
 static void nlm4_xdr_enc_res(struct rpc_rqst *req,
                             struct xdr_stream *xdr,
-                            const struct nlm_res *result)
+                            const void *data)
 {
+       const struct nlm_res *result = data;
+
        encode_cookie(xdr, &result->cookie);
        encode_nlm4_stat(xdr, result->status);
 }
@@ -479,8 +485,10 @@ static void nlm4_xdr_enc_res(struct rpc_rqst *req,
  */
 static void nlm4_xdr_enc_testres(struct rpc_rqst *req,
                                 struct xdr_stream *xdr,
-                                const struct nlm_res *result)
+                                const void *data)
 {
+       const struct nlm_res *result = data;
+
        encode_cookie(xdr, &result->cookie);
        encode_nlm4_stat(xdr, result->status);
        if (result->status == nlm_lck_denied)
@@ -525,8 +533,9 @@ out:
 
 static int nlm4_xdr_dec_testres(struct rpc_rqst *req,
                                struct xdr_stream *xdr,
-                               struct nlm_res *result)
+                               void *data)
 {
+       struct nlm_res *result = data;
        int error;
 
        error = decode_cookie(xdr, &result->cookie);
@@ -545,8 +554,9 @@ out:
  */
 static int nlm4_xdr_dec_res(struct rpc_rqst *req,
                            struct xdr_stream *xdr,
-                           struct nlm_res *result)
+                           void *data)
 {
+       struct nlm_res *result = data;
        int error;
 
        error = decode_cookie(xdr, &result->cookie);
@@ -566,15 +576,15 @@ out:
 #define PROC(proc, argtype, restype)                                   \
 [NLMPROC_##proc] = {                                                   \
        .p_proc      = NLMPROC_##proc,                                  \
-       .p_encode    = (kxdreproc_t)nlm4_xdr_enc_##argtype,             \
-       .p_decode    = (kxdrdproc_t)nlm4_xdr_dec_##restype,             \
+       .p_encode    = nlm4_xdr_enc_##argtype,                          \
+       .p_decode    = nlm4_xdr_dec_##restype,                          \
        .p_arglen    = NLM4_##argtype##_sz,                             \
        .p_replen    = NLM4_##restype##_sz,                             \
        .p_statidx   = NLMPROC_##proc,                                  \
        .p_name      = #proc,                                           \
        }
 
-static struct rpc_procinfo     nlm4_procedures[] = {
+static const struct rpc_procinfo nlm4_procedures[] = {
        PROC(TEST,              testargs,       testres),
        PROC(LOCK,              lockargs,       res),
        PROC(CANCEL,            cancargs,       res),
@@ -592,8 +602,10 @@ static struct rpc_procinfo nlm4_procedures[] = {
        PROC(GRANTED_RES,       res,            norep),
 };
 
+static unsigned int nlm_version4_counts[ARRAY_SIZE(nlm4_procedures)];
 const struct rpc_version nlm_version4 = {
        .number         = 4,
        .nrprocs        = ARRAY_SIZE(nlm4_procedures),
        .procs          = nlm4_procedures,
+       .counts         = nlm_version4_counts,
 };
index 3e9f7874b9755485952632757c74aad7389e5f56..3b4724a6c4eebc5087830d7e25bb2027c5b1907c 100644 (file)
@@ -374,8 +374,9 @@ static void encode_nlm_lock(struct xdr_stream *xdr,
  */
 static void nlm_xdr_enc_testargs(struct rpc_rqst *req,
                                 struct xdr_stream *xdr,
-                                const struct nlm_args *args)
+                                const void *data)
 {
+       const struct nlm_args *args = data;
        const struct nlm_lock *lock = &args->lock;
 
        encode_cookie(xdr, &args->cookie);
@@ -395,8 +396,9 @@ static void nlm_xdr_enc_testargs(struct rpc_rqst *req,
  */
 static void nlm_xdr_enc_lockargs(struct rpc_rqst *req,
                                 struct xdr_stream *xdr,
-                                const struct nlm_args *args)
+                                const void *data)
 {
+       const struct nlm_args *args = data;
        const struct nlm_lock *lock = &args->lock;
 
        encode_cookie(xdr, &args->cookie);
@@ -417,8 +419,9 @@ static void nlm_xdr_enc_lockargs(struct rpc_rqst *req,
  */
 static void nlm_xdr_enc_cancargs(struct rpc_rqst *req,
                                 struct xdr_stream *xdr,
-                                const struct nlm_args *args)
+                                const void *data)
 {
+       const struct nlm_args *args = data;
        const struct nlm_lock *lock = &args->lock;
 
        encode_cookie(xdr, &args->cookie);
@@ -435,8 +438,9 @@ static void nlm_xdr_enc_cancargs(struct rpc_rqst *req,
  */
 static void nlm_xdr_enc_unlockargs(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  const struct nlm_args *args)
+                                  const void *data)
 {
+       const struct nlm_args *args = data;
        const struct nlm_lock *lock = &args->lock;
 
        encode_cookie(xdr, &args->cookie);
@@ -451,8 +455,10 @@ static void nlm_xdr_enc_unlockargs(struct rpc_rqst *req,
  */
 static void nlm_xdr_enc_res(struct rpc_rqst *req,
                            struct xdr_stream *xdr,
-                           const struct nlm_res *result)
+                           const void *data)
 {
+       const struct nlm_res *result = data;
+
        encode_cookie(xdr, &result->cookie);
        encode_nlm_stat(xdr, result->status);
 }
@@ -479,8 +485,10 @@ static void encode_nlm_testrply(struct xdr_stream *xdr,
 
 static void nlm_xdr_enc_testres(struct rpc_rqst *req,
                                struct xdr_stream *xdr,
-                               const struct nlm_res *result)
+                               const void *data)
 {
+       const struct nlm_res *result = data;
+
        encode_cookie(xdr, &result->cookie);
        encode_nlm_stat(xdr, result->status);
        encode_nlm_testrply(xdr, result);
@@ -523,8 +531,9 @@ out:
 
 static int nlm_xdr_dec_testres(struct rpc_rqst *req,
                               struct xdr_stream *xdr,
-                              struct nlm_res *result)
+                              void *data)
 {
+       struct nlm_res *result = data;
        int error;
 
        error = decode_cookie(xdr, &result->cookie);
@@ -543,8 +552,9 @@ out:
  */
 static int nlm_xdr_dec_res(struct rpc_rqst *req,
                           struct xdr_stream *xdr,
-                          struct nlm_res *result)
+                          void *data)
 {
+       struct nlm_res *result = data;
        int error;
 
        error = decode_cookie(xdr, &result->cookie);
@@ -564,15 +574,15 @@ out:
 #define PROC(proc, argtype, restype)   \
 [NLMPROC_##proc] = {                                                   \
        .p_proc      = NLMPROC_##proc,                                  \
-       .p_encode    = (kxdreproc_t)nlm_xdr_enc_##argtype,              \
-       .p_decode    = (kxdrdproc_t)nlm_xdr_dec_##restype,              \
+       .p_encode    = nlm_xdr_enc_##argtype,           \
+       .p_decode    = nlm_xdr_dec_##restype,                           \
        .p_arglen    = NLM_##argtype##_sz,                              \
        .p_replen    = NLM_##restype##_sz,                              \
        .p_statidx   = NLMPROC_##proc,                                  \
        .p_name      = #proc,                                           \
        }
 
-static struct rpc_procinfo     nlm_procedures[] = {
+static const struct rpc_procinfo nlm_procedures[] = {
        PROC(TEST,              testargs,       testres),
        PROC(LOCK,              lockargs,       res),
        PROC(CANCEL,            cancargs,       res),
@@ -590,16 +600,20 @@ static struct rpc_procinfo        nlm_procedures[] = {
        PROC(GRANTED_RES,       res,            norep),
 };
 
+static unsigned int nlm_version1_counts[ARRAY_SIZE(nlm_procedures)];
 static const struct rpc_version        nlm_version1 = {
-               .number         = 1,
-               .nrprocs        = ARRAY_SIZE(nlm_procedures),
-               .procs          = nlm_procedures,
+       .number         = 1,
+       .nrprocs        = ARRAY_SIZE(nlm_procedures),
+       .procs          = nlm_procedures,
+       .counts         = nlm_version1_counts,
 };
 
+static unsigned int nlm_version3_counts[ARRAY_SIZE(nlm_procedures)];
 static const struct rpc_version        nlm_version3 = {
-               .number         = 3,
-               .nrprocs        = ARRAY_SIZE(nlm_procedures),
-               .procs          = nlm_procedures,
+       .number         = 3,
+       .nrprocs        = ARRAY_SIZE(nlm_procedures),
+       .procs          = nlm_procedures,
+       .counts         = nlm_version3_counts,
 };
 
 static const struct rpc_version        *nlm_versions[] = {
@@ -613,9 +627,9 @@ static const struct rpc_version     *nlm_versions[] = {
 static struct rpc_stat         nlm_rpc_stats;
 
 const struct rpc_program       nlm_program = {
-               .name           = "lockd",
-               .number         = NLM_PROGRAM,
-               .nrvers         = ARRAY_SIZE(nlm_versions),
-               .version        = nlm_versions,
-               .stats          = &nlm_rpc_stats,
+       .name           = "lockd",
+       .number         = NLM_PROGRAM,
+       .nrvers         = ARRAY_SIZE(nlm_versions),
+       .version        = nlm_versions,
+       .stats          = &nlm_rpc_stats,
 };
index 19166d4a8d313b73424d5668bcffa3c3baee2683..9d8166c39c549a88c38892e2db54e2d9783ac59d 100644 (file)
@@ -476,22 +476,23 @@ static void encode_priv(struct xdr_stream *xdr, const struct nsm_args *argp)
 }
 
 static void nsm_xdr_enc_mon(struct rpc_rqst *req, struct xdr_stream *xdr,
-                           const struct nsm_args *argp)
+                           const void *argp)
 {
        encode_mon_id(xdr, argp);
        encode_priv(xdr, argp);
 }
 
 static void nsm_xdr_enc_unmon(struct rpc_rqst *req, struct xdr_stream *xdr,
-                             const struct nsm_args *argp)
+                             const void *argp)
 {
        encode_mon_id(xdr, argp);
 }
 
 static int nsm_xdr_dec_stat_res(struct rpc_rqst *rqstp,
                                struct xdr_stream *xdr,
-                               struct nsm_res *resp)
+                               void *data)
 {
+       struct nsm_res *resp = data;
        __be32 *p;
 
        p = xdr_inline_decode(xdr, 4 + 4);
@@ -507,8 +508,9 @@ static int nsm_xdr_dec_stat_res(struct rpc_rqst *rqstp,
 
 static int nsm_xdr_dec_stat(struct rpc_rqst *rqstp,
                            struct xdr_stream *xdr,
-                           struct nsm_res *resp)
+                           void *data)
 {
+       struct nsm_res *resp = data;
        __be32 *p;
 
        p = xdr_inline_decode(xdr, 4);
@@ -529,11 +531,11 @@ static int nsm_xdr_dec_stat(struct rpc_rqst *rqstp,
 #define SM_monres_sz   2
 #define SM_unmonres_sz 1
 
-static struct rpc_procinfo     nsm_procedures[] = {
+static const struct rpc_procinfo nsm_procedures[] = {
 [NSMPROC_MON] = {
                .p_proc         = NSMPROC_MON,
-               .p_encode       = (kxdreproc_t)nsm_xdr_enc_mon,
-               .p_decode       = (kxdrdproc_t)nsm_xdr_dec_stat_res,
+               .p_encode       = nsm_xdr_enc_mon,
+               .p_decode       = nsm_xdr_dec_stat_res,
                .p_arglen       = SM_mon_sz,
                .p_replen       = SM_monres_sz,
                .p_statidx      = NSMPROC_MON,
@@ -541,8 +543,8 @@ static struct rpc_procinfo  nsm_procedures[] = {
        },
 [NSMPROC_UNMON] = {
                .p_proc         = NSMPROC_UNMON,
-               .p_encode       = (kxdreproc_t)nsm_xdr_enc_unmon,
-               .p_decode       = (kxdrdproc_t)nsm_xdr_dec_stat,
+               .p_encode       = nsm_xdr_enc_unmon,
+               .p_decode       = nsm_xdr_dec_stat,
                .p_arglen       = SM_mon_id_sz,
                .p_replen       = SM_unmonres_sz,
                .p_statidx      = NSMPROC_UNMON,
@@ -550,10 +552,12 @@ static struct rpc_procinfo        nsm_procedures[] = {
        },
 };
 
+static unsigned int nsm_version1_counts[ARRAY_SIZE(nsm_procedures)];
 static const struct rpc_version nsm_version1 = {
-               .number         = 1,
-               .nrprocs        = ARRAY_SIZE(nsm_procedures),
-               .procs          = nsm_procedures
+       .number         = 1,
+       .nrprocs        = ARRAY_SIZE(nsm_procedures),
+       .procs          = nsm_procedures,
+       .counts         = nsm_version1_counts,
 };
 
 static const struct rpc_version *nsm_version[] = {
@@ -563,9 +567,9 @@ static const struct rpc_version *nsm_version[] = {
 static struct rpc_stat         nsm_stats;
 
 static const struct rpc_program nsm_program = {
-               .name           = "statd",
-               .number         = NSM_PROGRAM,
-               .nrvers         = ARRAY_SIZE(nsm_version),
-               .version        = nsm_version,
-               .stats          = &nsm_stats
+       .name           = "statd",
+       .number         = NSM_PROGRAM,
+       .nrvers         = ARRAY_SIZE(nsm_version),
+       .version        = nsm_version,
+       .stats          = &nsm_stats
 };
index 5d481e8a1b5d0c732207c4a583027ec084d7a0db..726b6cecf430d8d9cd522338436562df71efe6dc 100644 (file)
@@ -739,27 +739,33 @@ module_exit(exit_nlm);
 /*
  * Define NLM program and procedures
  */
-static struct svc_version      nlmsvc_version1 = {
-               .vs_vers        = 1,
-               .vs_nproc       = 17,
-               .vs_proc        = nlmsvc_procedures,
-               .vs_xdrsize     = NLMSVC_XDRSIZE,
+static unsigned int nlmsvc_version1_count[17];
+static const struct svc_version        nlmsvc_version1 = {
+       .vs_vers        = 1,
+       .vs_nproc       = 17,
+       .vs_proc        = nlmsvc_procedures,
+       .vs_count       = nlmsvc_version1_count,
+       .vs_xdrsize     = NLMSVC_XDRSIZE,
 };
-static struct svc_version      nlmsvc_version3 = {
-               .vs_vers        = 3,
-               .vs_nproc       = 24,
-               .vs_proc        = nlmsvc_procedures,
-               .vs_xdrsize     = NLMSVC_XDRSIZE,
+static unsigned int nlmsvc_version3_count[24];
+static const struct svc_version        nlmsvc_version3 = {
+       .vs_vers        = 3,
+       .vs_nproc       = 24,
+       .vs_proc        = nlmsvc_procedures,
+       .vs_count       = nlmsvc_version3_count,
+       .vs_xdrsize     = NLMSVC_XDRSIZE,
 };
 #ifdef CONFIG_LOCKD_V4
-static struct svc_version      nlmsvc_version4 = {
-               .vs_vers        = 4,
-               .vs_nproc       = 24,
-               .vs_proc        = nlmsvc_procedures4,
-               .vs_xdrsize     = NLMSVC_XDRSIZE,
+static unsigned int nlmsvc_version4_count[24];
+static const struct svc_version        nlmsvc_version4 = {
+       .vs_vers        = 4,
+       .vs_nproc       = 24,
+       .vs_proc        = nlmsvc_procedures4,
+       .vs_count       = nlmsvc_version4_count,
+       .vs_xdrsize     = NLMSVC_XDRSIZE,
 };
 #endif
-static struct svc_version *    nlmsvc_version[] = {
+static const struct svc_version *nlmsvc_version[] = {
        [1] = &nlmsvc_version1,
        [3] = &nlmsvc_version3,
 #ifdef CONFIG_LOCKD_V4
index 09c576f26c7b76f5f39a6f7e98a37f297d09e533..82925f17ec45f554378696cfcb3faacb4f0544b8 100644 (file)
@@ -62,7 +62,7 @@ no_locks:
  * NULL: Test for presence of service
  */
 static __be32
-nlm4svc_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
+nlm4svc_proc_null(struct svc_rqst *rqstp)
 {
        dprintk("lockd: NULL          called\n");
        return rpc_success;
@@ -72,9 +72,9 @@ nlm4svc_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
  * TEST: Check for conflicting lock
  */
 static __be32
-nlm4svc_proc_test(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                        struct nlm_res  *resp)
+__nlm4svc_proc_test(struct svc_rqst *rqstp, struct nlm_res *resp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        struct nlm_host *host;
        struct nlm_file *file;
        __be32 rc = rpc_success;
@@ -99,9 +99,15 @@ nlm4svc_proc_test(struct svc_rqst *rqstp, struct nlm_args *argp,
 }
 
 static __be32
-nlm4svc_proc_lock(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                        struct nlm_res  *resp)
+nlm4svc_proc_test(struct svc_rqst *rqstp)
 {
+       return __nlm4svc_proc_test(rqstp, rqstp->rq_resp);
+}
+
+static __be32
+__nlm4svc_proc_lock(struct svc_rqst *rqstp, struct nlm_res *resp)
+{
+       struct nlm_args *argp = rqstp->rq_argp;
        struct nlm_host *host;
        struct nlm_file *file;
        __be32 rc = rpc_success;
@@ -141,9 +147,15 @@ nlm4svc_proc_lock(struct svc_rqst *rqstp, struct nlm_args *argp,
 }
 
 static __be32
-nlm4svc_proc_cancel(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                          struct nlm_res  *resp)
+nlm4svc_proc_lock(struct svc_rqst *rqstp)
+{
+       return __nlm4svc_proc_lock(rqstp, rqstp->rq_resp);
+}
+
+static __be32
+__nlm4svc_proc_cancel(struct svc_rqst *rqstp, struct nlm_res *resp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        struct nlm_host *host;
        struct nlm_file *file;
 
@@ -170,13 +182,19 @@ nlm4svc_proc_cancel(struct svc_rqst *rqstp, struct nlm_args *argp,
        return rpc_success;
 }
 
+static __be32
+nlm4svc_proc_cancel(struct svc_rqst *rqstp)
+{
+       return __nlm4svc_proc_cancel(rqstp, rqstp->rq_resp);
+}
+
 /*
  * UNLOCK: release a lock
  */
 static __be32
-nlm4svc_proc_unlock(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                          struct nlm_res  *resp)
+__nlm4svc_proc_unlock(struct svc_rqst *rqstp, struct nlm_res *resp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        struct nlm_host *host;
        struct nlm_file *file;
 
@@ -203,14 +221,21 @@ nlm4svc_proc_unlock(struct svc_rqst *rqstp, struct nlm_args *argp,
        return rpc_success;
 }
 
+static __be32
+nlm4svc_proc_unlock(struct svc_rqst *rqstp)
+{
+       return __nlm4svc_proc_unlock(rqstp, rqstp->rq_resp);
+}
+
 /*
  * GRANTED: A server calls us to tell that a process' lock request
  * was granted
  */
 static __be32
-nlm4svc_proc_granted(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                           struct nlm_res  *resp)
+__nlm4svc_proc_granted(struct svc_rqst *rqstp, struct nlm_res *resp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
+
        resp->cookie = argp->cookie;
 
        dprintk("lockd: GRANTED       called\n");
@@ -219,6 +244,12 @@ nlm4svc_proc_granted(struct svc_rqst *rqstp, struct nlm_args *argp,
        return rpc_success;
 }
 
+static __be32
+nlm4svc_proc_granted(struct svc_rqst *rqstp)
+{
+       return __nlm4svc_proc_granted(rqstp, rqstp->rq_resp);
+}
+
 /*
  * This is the generic lockd callback for async RPC calls
  */
@@ -243,9 +274,10 @@ static const struct rpc_call_ops nlm4svc_callback_ops = {
  * because we send the callback before the reply proper. I hope this
  * doesn't break any clients.
  */
-static __be32 nlm4svc_callback(struct svc_rqst *rqstp, u32 proc, struct nlm_args *argp,
-               __be32 (*func)(struct svc_rqst *, struct nlm_args *, struct nlm_res  *))
+static __be32 nlm4svc_callback(struct svc_rqst *rqstp, u32 proc,
+               __be32 (*func)(struct svc_rqst *,  struct nlm_res *))
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        struct nlm_host *host;
        struct nlm_rqst *call;
        __be32 stat;
@@ -261,7 +293,7 @@ static __be32 nlm4svc_callback(struct svc_rqst *rqstp, u32 proc, struct nlm_args
        if (call == NULL)
                return rpc_system_err;
 
-       stat = func(rqstp, argp, &call->a_res);
+       stat = func(rqstp, &call->a_res);
        if (stat != 0) {
                nlmsvc_release_call(call);
                return stat;
@@ -273,48 +305,44 @@ static __be32 nlm4svc_callback(struct svc_rqst *rqstp, u32 proc, struct nlm_args
        return rpc_success;
 }
 
-static __be32 nlm4svc_proc_test_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                            void            *resp)
+static __be32 nlm4svc_proc_test_msg(struct svc_rqst *rqstp)
 {
        dprintk("lockd: TEST_MSG      called\n");
-       return nlm4svc_callback(rqstp, NLMPROC_TEST_RES, argp, nlm4svc_proc_test);
+       return nlm4svc_callback(rqstp, NLMPROC_TEST_RES, __nlm4svc_proc_test);
 }
 
-static __be32 nlm4svc_proc_lock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                            void            *resp)
+static __be32 nlm4svc_proc_lock_msg(struct svc_rqst *rqstp)
 {
        dprintk("lockd: LOCK_MSG      called\n");
-       return nlm4svc_callback(rqstp, NLMPROC_LOCK_RES, argp, nlm4svc_proc_lock);
+       return nlm4svc_callback(rqstp, NLMPROC_LOCK_RES, __nlm4svc_proc_lock);
 }
 
-static __be32 nlm4svc_proc_cancel_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                              void            *resp)
+static __be32 nlm4svc_proc_cancel_msg(struct svc_rqst *rqstp)
 {
        dprintk("lockd: CANCEL_MSG    called\n");
-       return nlm4svc_callback(rqstp, NLMPROC_CANCEL_RES, argp, nlm4svc_proc_cancel);
+       return nlm4svc_callback(rqstp, NLMPROC_CANCEL_RES, __nlm4svc_proc_cancel);
 }
 
-static __be32 nlm4svc_proc_unlock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                               void            *resp)
+static __be32 nlm4svc_proc_unlock_msg(struct svc_rqst *rqstp)
 {
        dprintk("lockd: UNLOCK_MSG    called\n");
-       return nlm4svc_callback(rqstp, NLMPROC_UNLOCK_RES, argp, nlm4svc_proc_unlock);
+       return nlm4svc_callback(rqstp, NLMPROC_UNLOCK_RES, __nlm4svc_proc_unlock);
 }
 
-static __be32 nlm4svc_proc_granted_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                                void            *resp)
+static __be32 nlm4svc_proc_granted_msg(struct svc_rqst *rqstp)
 {
        dprintk("lockd: GRANTED_MSG   called\n");
-       return nlm4svc_callback(rqstp, NLMPROC_GRANTED_RES, argp, nlm4svc_proc_granted);
+       return nlm4svc_callback(rqstp, NLMPROC_GRANTED_RES, __nlm4svc_proc_granted);
 }
 
 /*
  * SHARE: create a DOS share or alter existing share.
  */
 static __be32
-nlm4svc_proc_share(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                         struct nlm_res  *resp)
+nlm4svc_proc_share(struct svc_rqst *rqstp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
+       struct nlm_res *resp = rqstp->rq_resp;
        struct nlm_host *host;
        struct nlm_file *file;
 
@@ -345,9 +373,10 @@ nlm4svc_proc_share(struct svc_rqst *rqstp, struct nlm_args *argp,
  * UNSHARE: Release a DOS share.
  */
 static __be32
-nlm4svc_proc_unshare(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                           struct nlm_res  *resp)
+nlm4svc_proc_unshare(struct svc_rqst *rqstp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
+       struct nlm_res *resp = rqstp->rq_resp;
        struct nlm_host *host;
        struct nlm_file *file;
 
@@ -378,22 +407,23 @@ nlm4svc_proc_unshare(struct svc_rqst *rqstp, struct nlm_args *argp,
  * NM_LOCK: Create an unmonitored lock
  */
 static __be32
-nlm4svc_proc_nm_lock(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                           struct nlm_res  *resp)
+nlm4svc_proc_nm_lock(struct svc_rqst *rqstp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
+
        dprintk("lockd: NM_LOCK       called\n");
 
        argp->monitor = 0;              /* just clean the monitor flag */
-       return nlm4svc_proc_lock(rqstp, argp, resp);
+       return nlm4svc_proc_lock(rqstp);
 }
 
 /*
  * FREE_ALL: Release all locks and shares held by client
  */
 static __be32
-nlm4svc_proc_free_all(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                            void            *resp)
+nlm4svc_proc_free_all(struct svc_rqst *rqstp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        struct nlm_host *host;
 
        /* Obtain client */
@@ -409,9 +439,10 @@ nlm4svc_proc_free_all(struct svc_rqst *rqstp, struct nlm_args *argp,
  * SM_NOTIFY: private callback from statd (not part of official NLM proto)
  */
 static __be32
-nlm4svc_proc_sm_notify(struct svc_rqst *rqstp, struct nlm_reboot *argp,
-                                             void              *resp)
+nlm4svc_proc_sm_notify(struct svc_rqst *rqstp)
 {
+       struct nlm_reboot *argp = rqstp->rq_argp;
+
        dprintk("lockd: SM_NOTIFY     called\n");
 
        if (!nlm_privileged_requester(rqstp)) {
@@ -429,9 +460,10 @@ nlm4svc_proc_sm_notify(struct svc_rqst *rqstp, struct nlm_reboot *argp,
  * client sent a GRANTED_RES, let's remove the associated block
  */
 static __be32
-nlm4svc_proc_granted_res(struct svc_rqst *rqstp, struct nlm_res  *argp,
-                                                void            *resp)
+nlm4svc_proc_granted_res(struct svc_rqst *rqstp)
 {
+       struct nlm_res *argp = rqstp->rq_argp;
+
         if (!nlmsvc_ops)
                 return rpc_success;
 
@@ -463,9 +495,9 @@ nlm4svc_proc_granted_res(struct svc_rqst *rqstp, struct nlm_res  *argp,
 struct nlm_void                        { int dummy; };
 
 #define PROC(name, xargt, xrest, argt, rest, respsize) \
- { .pc_func    = (svc_procfunc) nlm4svc_proc_##name,   \
-   .pc_decode  = (kxdrproc_t) nlm4svc_decode_##xargt,  \
-   .pc_encode  = (kxdrproc_t) nlm4svc_encode_##xrest,  \
+ { .pc_func    = nlm4svc_proc_##name,  \
+   .pc_decode  = nlm4svc_decode_##xargt,       \
+   .pc_encode  = nlm4svc_encode_##xrest,       \
    .pc_release = NULL,                                 \
    .pc_argsize = sizeof(struct nlm_##argt),            \
    .pc_ressize = sizeof(struct nlm_##rest),            \
@@ -475,7 +507,7 @@ struct nlm_void                     { int dummy; };
 #define        No      (1+1024/4)                              /* netobj */
 #define        St      1                                       /* status */
 #define        Rg      4                                       /* range (offset + length) */
-struct svc_procedure           nlmsvc_procedures4[] = {
+const struct svc_procedure nlmsvc_procedures4[] = {
   PROC(null,           void,           void,           void,   void, 1),
   PROC(test,           testargs,       testres,        args,   res, Ck+St+2+No+Rg),
   PROC(lock,           lockargs,       res,            args,   res, Ck+St),
index fb26b9f522e74df4529b59c55b02502284f37dbc..07915162581d62fcb58538dbf147d72ef8dcc81e 100644 (file)
@@ -92,7 +92,7 @@ no_locks:
  * NULL: Test for presence of service
  */
 static __be32
-nlmsvc_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
+nlmsvc_proc_null(struct svc_rqst *rqstp)
 {
        dprintk("lockd: NULL          called\n");
        return rpc_success;
@@ -102,9 +102,9 @@ nlmsvc_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
  * TEST: Check for conflicting lock
  */
 static __be32
-nlmsvc_proc_test(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                        struct nlm_res  *resp)
+__nlmsvc_proc_test(struct svc_rqst *rqstp, struct nlm_res *resp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        struct nlm_host *host;
        struct nlm_file *file;
        __be32 rc = rpc_success;
@@ -130,9 +130,15 @@ nlmsvc_proc_test(struct svc_rqst *rqstp, struct nlm_args *argp,
 }
 
 static __be32
-nlmsvc_proc_lock(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                        struct nlm_res  *resp)
+nlmsvc_proc_test(struct svc_rqst *rqstp)
 {
+       return __nlmsvc_proc_test(rqstp, rqstp->rq_resp);
+}
+
+static __be32
+__nlmsvc_proc_lock(struct svc_rqst *rqstp, struct nlm_res *resp)
+{
+       struct nlm_args *argp = rqstp->rq_argp;
        struct nlm_host *host;
        struct nlm_file *file;
        __be32 rc = rpc_success;
@@ -172,9 +178,15 @@ nlmsvc_proc_lock(struct svc_rqst *rqstp, struct nlm_args *argp,
 }
 
 static __be32
-nlmsvc_proc_cancel(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                          struct nlm_res  *resp)
+nlmsvc_proc_lock(struct svc_rqst *rqstp)
+{
+       return __nlmsvc_proc_lock(rqstp, rqstp->rq_resp);
+}
+
+static __be32
+__nlmsvc_proc_cancel(struct svc_rqst *rqstp, struct nlm_res *resp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        struct nlm_host *host;
        struct nlm_file *file;
        struct net *net = SVC_NET(rqstp);
@@ -202,13 +214,19 @@ nlmsvc_proc_cancel(struct svc_rqst *rqstp, struct nlm_args *argp,
        return rpc_success;
 }
 
+static __be32
+nlmsvc_proc_cancel(struct svc_rqst *rqstp)
+{
+       return __nlmsvc_proc_cancel(rqstp, rqstp->rq_resp);
+}
+
 /*
  * UNLOCK: release a lock
  */
 static __be32
-nlmsvc_proc_unlock(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                          struct nlm_res  *resp)
+__nlmsvc_proc_unlock(struct svc_rqst *rqstp, struct nlm_res *resp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        struct nlm_host *host;
        struct nlm_file *file;
        struct net *net = SVC_NET(rqstp);
@@ -236,14 +254,21 @@ nlmsvc_proc_unlock(struct svc_rqst *rqstp, struct nlm_args *argp,
        return rpc_success;
 }
 
+static __be32
+nlmsvc_proc_unlock(struct svc_rqst *rqstp)
+{
+       return __nlmsvc_proc_unlock(rqstp, rqstp->rq_resp);
+}
+
 /*
  * GRANTED: A server calls us to tell that a process' lock request
  * was granted
  */
 static __be32
-nlmsvc_proc_granted(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                           struct nlm_res  *resp)
+__nlmsvc_proc_granted(struct svc_rqst *rqstp, struct nlm_res *resp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
+
        resp->cookie = argp->cookie;
 
        dprintk("lockd: GRANTED       called\n");
@@ -252,6 +277,12 @@ nlmsvc_proc_granted(struct svc_rqst *rqstp, struct nlm_args *argp,
        return rpc_success;
 }
 
+static __be32
+nlmsvc_proc_granted(struct svc_rqst *rqstp)
+{
+       return __nlmsvc_proc_granted(rqstp, rqstp->rq_resp);
+}
+
 /*
  * This is the generic lockd callback for async RPC calls
  */
@@ -284,9 +315,10 @@ static const struct rpc_call_ops nlmsvc_callback_ops = {
  * because we send the callback before the reply proper. I hope this
  * doesn't break any clients.
  */
-static __be32 nlmsvc_callback(struct svc_rqst *rqstp, u32 proc, struct nlm_args *argp,
-               __be32 (*func)(struct svc_rqst *, struct nlm_args *, struct nlm_res  *))
+static __be32 nlmsvc_callback(struct svc_rqst *rqstp, u32 proc,
+               __be32 (*func)(struct svc_rqst *, struct nlm_res *))
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        struct nlm_host *host;
        struct nlm_rqst *call;
        __be32 stat;
@@ -302,7 +334,7 @@ static __be32 nlmsvc_callback(struct svc_rqst *rqstp, u32 proc, struct nlm_args
        if (call == NULL)
                return rpc_system_err;
 
-       stat = func(rqstp, argp, &call->a_res);
+       stat = func(rqstp, &call->a_res);
        if (stat != 0) {
                nlmsvc_release_call(call);
                return stat;
@@ -314,50 +346,46 @@ static __be32 nlmsvc_callback(struct svc_rqst *rqstp, u32 proc, struct nlm_args
        return rpc_success;
 }
 
-static __be32 nlmsvc_proc_test_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                            void            *resp)
+static __be32 nlmsvc_proc_test_msg(struct svc_rqst *rqstp)
 {
        dprintk("lockd: TEST_MSG      called\n");
-       return nlmsvc_callback(rqstp, NLMPROC_TEST_RES, argp, nlmsvc_proc_test);
+       return nlmsvc_callback(rqstp, NLMPROC_TEST_RES, __nlmsvc_proc_test);
 }
 
-static __be32 nlmsvc_proc_lock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                            void            *resp)
+static __be32 nlmsvc_proc_lock_msg(struct svc_rqst *rqstp)
 {
        dprintk("lockd: LOCK_MSG      called\n");
-       return nlmsvc_callback(rqstp, NLMPROC_LOCK_RES, argp, nlmsvc_proc_lock);
+       return nlmsvc_callback(rqstp, NLMPROC_LOCK_RES, __nlmsvc_proc_lock);
 }
 
-static __be32 nlmsvc_proc_cancel_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                              void            *resp)
+static __be32 nlmsvc_proc_cancel_msg(struct svc_rqst *rqstp)
 {
        dprintk("lockd: CANCEL_MSG    called\n");
-       return nlmsvc_callback(rqstp, NLMPROC_CANCEL_RES, argp, nlmsvc_proc_cancel);
+       return nlmsvc_callback(rqstp, NLMPROC_CANCEL_RES, __nlmsvc_proc_cancel);
 }
 
 static __be32
-nlmsvc_proc_unlock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                               void            *resp)
+nlmsvc_proc_unlock_msg(struct svc_rqst *rqstp)
 {
        dprintk("lockd: UNLOCK_MSG    called\n");
-       return nlmsvc_callback(rqstp, NLMPROC_UNLOCK_RES, argp, nlmsvc_proc_unlock);
+       return nlmsvc_callback(rqstp, NLMPROC_UNLOCK_RES, __nlmsvc_proc_unlock);
 }
 
 static __be32
-nlmsvc_proc_granted_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                                void            *resp)
+nlmsvc_proc_granted_msg(struct svc_rqst *rqstp)
 {
        dprintk("lockd: GRANTED_MSG   called\n");
-       return nlmsvc_callback(rqstp, NLMPROC_GRANTED_RES, argp, nlmsvc_proc_granted);
+       return nlmsvc_callback(rqstp, NLMPROC_GRANTED_RES, __nlmsvc_proc_granted);
 }
 
 /*
  * SHARE: create a DOS share or alter existing share.
  */
 static __be32
-nlmsvc_proc_share(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                         struct nlm_res  *resp)
+nlmsvc_proc_share(struct svc_rqst *rqstp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
+       struct nlm_res *resp = rqstp->rq_resp;
        struct nlm_host *host;
        struct nlm_file *file;
 
@@ -388,9 +416,10 @@ nlmsvc_proc_share(struct svc_rqst *rqstp, struct nlm_args *argp,
  * UNSHARE: Release a DOS share.
  */
 static __be32
-nlmsvc_proc_unshare(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                           struct nlm_res  *resp)
+nlmsvc_proc_unshare(struct svc_rqst *rqstp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
+       struct nlm_res *resp = rqstp->rq_resp;
        struct nlm_host *host;
        struct nlm_file *file;
 
@@ -421,22 +450,23 @@ nlmsvc_proc_unshare(struct svc_rqst *rqstp, struct nlm_args *argp,
  * NM_LOCK: Create an unmonitored lock
  */
 static __be32
-nlmsvc_proc_nm_lock(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                           struct nlm_res  *resp)
+nlmsvc_proc_nm_lock(struct svc_rqst *rqstp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
+
        dprintk("lockd: NM_LOCK       called\n");
 
        argp->monitor = 0;              /* just clean the monitor flag */
-       return nlmsvc_proc_lock(rqstp, argp, resp);
+       return nlmsvc_proc_lock(rqstp);
 }
 
 /*
  * FREE_ALL: Release all locks and shares held by client
  */
 static __be32
-nlmsvc_proc_free_all(struct svc_rqst *rqstp, struct nlm_args *argp,
-                                            void            *resp)
+nlmsvc_proc_free_all(struct svc_rqst *rqstp)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        struct nlm_host *host;
 
        /* Obtain client */
@@ -452,9 +482,10 @@ nlmsvc_proc_free_all(struct svc_rqst *rqstp, struct nlm_args *argp,
  * SM_NOTIFY: private callback from statd (not part of official NLM proto)
  */
 static __be32
-nlmsvc_proc_sm_notify(struct svc_rqst *rqstp, struct nlm_reboot *argp,
-                                             void              *resp)
+nlmsvc_proc_sm_notify(struct svc_rqst *rqstp)
 {
+       struct nlm_reboot *argp = rqstp->rq_argp;
+
        dprintk("lockd: SM_NOTIFY     called\n");
 
        if (!nlm_privileged_requester(rqstp)) {
@@ -472,9 +503,10 @@ nlmsvc_proc_sm_notify(struct svc_rqst *rqstp, struct nlm_reboot *argp,
  * client sent a GRANTED_RES, let's remove the associated block
  */
 static __be32
-nlmsvc_proc_granted_res(struct svc_rqst *rqstp, struct nlm_res  *argp,
-                                                void            *resp)
+nlmsvc_proc_granted_res(struct svc_rqst *rqstp)
 {
+       struct nlm_res *argp = rqstp->rq_argp;
+
        if (!nlmsvc_ops)
                return rpc_success;
 
@@ -505,9 +537,9 @@ nlmsvc_proc_granted_res(struct svc_rqst *rqstp, struct nlm_res  *argp,
 struct nlm_void                        { int dummy; };
 
 #define PROC(name, xargt, xrest, argt, rest, respsize) \
- { .pc_func    = (svc_procfunc) nlmsvc_proc_##name,    \
-   .pc_decode  = (kxdrproc_t) nlmsvc_decode_##xargt,   \
-   .pc_encode  = (kxdrproc_t) nlmsvc_encode_##xrest,   \
+ { .pc_func    = nlmsvc_proc_##name,                   \
+   .pc_decode  = nlmsvc_decode_##xargt,                \
+   .pc_encode  = nlmsvc_encode_##xrest,                \
    .pc_release = NULL,                                 \
    .pc_argsize = sizeof(struct nlm_##argt),            \
    .pc_ressize = sizeof(struct nlm_##rest),            \
@@ -519,7 +551,7 @@ struct nlm_void                     { int dummy; };
 #define        No      (1+1024/4)                      /* Net Obj */
 #define        Rg      2                               /* range - offset + size */
 
-struct svc_procedure           nlmsvc_procedures[] = {
+const struct svc_procedure nlmsvc_procedures[] = {
   PROC(null,           void,           void,           void,   void, 1),
   PROC(test,           testargs,       testres,        args,   res, Ck+St+2+No+Rg),
   PROC(lock,           lockargs,       res,            args,   res, Ck+St),
index 5b651daad5183c8e7b31c75340bfce42f8ad28d7..442bbd0b0b293bf8b8a6a3b9c3d58040d1c5478d 100644 (file)
@@ -182,8 +182,9 @@ nlm_encode_testres(__be32 *p, struct nlm_res *resp)
  * First, the server side XDR functions
  */
 int
-nlmsvc_decode_testargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
+nlmsvc_decode_testargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        u32     exclusive;
 
        if (!(p = nlm_decode_cookie(p, &argp->cookie)))
@@ -199,16 +200,19 @@ nlmsvc_decode_testargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
 }
 
 int
-nlmsvc_encode_testres(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
+nlmsvc_encode_testres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_res *resp = rqstp->rq_resp;
+
        if (!(p = nlm_encode_testres(p, resp)))
                return 0;
        return xdr_ressize_check(rqstp, p);
 }
 
 int
-nlmsvc_decode_lockargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
+nlmsvc_decode_lockargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        u32     exclusive;
 
        if (!(p = nlm_decode_cookie(p, &argp->cookie)))
@@ -227,8 +231,9 @@ nlmsvc_decode_lockargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
 }
 
 int
-nlmsvc_decode_cancargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
+nlmsvc_decode_cancargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        u32     exclusive;
 
        if (!(p = nlm_decode_cookie(p, &argp->cookie)))
@@ -243,8 +248,10 @@ nlmsvc_decode_cancargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
 }
 
 int
-nlmsvc_decode_unlockargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
+nlmsvc_decode_unlockargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
+
        if (!(p = nlm_decode_cookie(p, &argp->cookie))
         || !(p = nlm_decode_lock(p, &argp->lock)))
                return 0;
@@ -253,8 +260,9 @@ nlmsvc_decode_unlockargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
 }
 
 int
-nlmsvc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
+nlmsvc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        struct nlm_lock *lock = &argp->lock;
 
        memset(lock, 0, sizeof(*lock));
@@ -274,8 +282,10 @@ nlmsvc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
 }
 
 int
-nlmsvc_encode_shareres(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
+nlmsvc_encode_shareres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_res *resp = rqstp->rq_resp;
+
        if (!(p = nlm_encode_cookie(p, &resp->cookie)))
                return 0;
        *p++ = resp->status;
@@ -284,8 +294,10 @@ nlmsvc_encode_shareres(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
 }
 
 int
-nlmsvc_encode_res(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
+nlmsvc_encode_res(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_res *resp = rqstp->rq_resp;
+
        if (!(p = nlm_encode_cookie(p, &resp->cookie)))
                return 0;
        *p++ = resp->status;
@@ -293,8 +305,9 @@ nlmsvc_encode_res(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
 }
 
 int
-nlmsvc_decode_notify(struct svc_rqst *rqstp, __be32 *p, struct nlm_args *argp)
+nlmsvc_decode_notify(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        struct nlm_lock *lock = &argp->lock;
 
        if (!(p = xdr_decode_string_inplace(p, &lock->caller,
@@ -305,8 +318,10 @@ nlmsvc_decode_notify(struct svc_rqst *rqstp, __be32 *p, struct nlm_args *argp)
 }
 
 int
-nlmsvc_decode_reboot(struct svc_rqst *rqstp, __be32 *p, struct nlm_reboot *argp)
+nlmsvc_decode_reboot(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_reboot *argp = rqstp->rq_argp;
+
        if (!(p = xdr_decode_string_inplace(p, &argp->mon, &argp->len, SM_MAXSTRLEN)))
                return 0;
        argp->state = ntohl(*p++);
@@ -316,8 +331,10 @@ nlmsvc_decode_reboot(struct svc_rqst *rqstp, __be32 *p, struct nlm_reboot *argp)
 }
 
 int
-nlmsvc_decode_res(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
+nlmsvc_decode_res(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_res *resp = rqstp->rq_argp;
+
        if (!(p = nlm_decode_cookie(p, &resp->cookie)))
                return 0;
        resp->status = *p++;
@@ -325,13 +342,13 @@ nlmsvc_decode_res(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
 }
 
 int
-nlmsvc_decode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy)
+nlmsvc_decode_void(struct svc_rqst *rqstp, __be32 *p)
 {
        return xdr_argsize_check(rqstp, p);
 }
 
 int
-nlmsvc_encode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy)
+nlmsvc_encode_void(struct svc_rqst *rqstp, __be32 *p)
 {
        return xdr_ressize_check(rqstp, p);
 }
index dfa4789cd4605c520be1d96d3fc44dae81279a96..2a0cd5679c49ddc2580e1dcea885d93ecd79e1b5 100644 (file)
@@ -179,8 +179,9 @@ nlm4_encode_testres(__be32 *p, struct nlm_res *resp)
  * First, the server side XDR functions
  */
 int
-nlm4svc_decode_testargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
+nlm4svc_decode_testargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        u32     exclusive;
 
        if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
@@ -196,16 +197,19 @@ nlm4svc_decode_testargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
 }
 
 int
-nlm4svc_encode_testres(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
+nlm4svc_encode_testres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_res *resp = rqstp->rq_resp;
+
        if (!(p = nlm4_encode_testres(p, resp)))
                return 0;
        return xdr_ressize_check(rqstp, p);
 }
 
 int
-nlm4svc_decode_lockargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
+nlm4svc_decode_lockargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        u32     exclusive;
 
        if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
@@ -224,8 +228,9 @@ nlm4svc_decode_lockargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
 }
 
 int
-nlm4svc_decode_cancargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
+nlm4svc_decode_cancargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        u32     exclusive;
 
        if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
@@ -240,8 +245,10 @@ nlm4svc_decode_cancargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
 }
 
 int
-nlm4svc_decode_unlockargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
+nlm4svc_decode_unlockargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
+
        if (!(p = nlm4_decode_cookie(p, &argp->cookie))
         || !(p = nlm4_decode_lock(p, &argp->lock)))
                return 0;
@@ -250,8 +257,9 @@ nlm4svc_decode_unlockargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
 }
 
 int
-nlm4svc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
+nlm4svc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        struct nlm_lock *lock = &argp->lock;
 
        memset(lock, 0, sizeof(*lock));
@@ -271,8 +279,10 @@ nlm4svc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
 }
 
 int
-nlm4svc_encode_shareres(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
+nlm4svc_encode_shareres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_res *resp = rqstp->rq_resp;
+
        if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
                return 0;
        *p++ = resp->status;
@@ -281,8 +291,10 @@ nlm4svc_encode_shareres(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
 }
 
 int
-nlm4svc_encode_res(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
+nlm4svc_encode_res(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_res *resp = rqstp->rq_resp;
+
        if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
                return 0;
        *p++ = resp->status;
@@ -290,8 +302,9 @@ nlm4svc_encode_res(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
 }
 
 int
-nlm4svc_decode_notify(struct svc_rqst *rqstp, __be32 *p, struct nlm_args *argp)
+nlm4svc_decode_notify(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_args *argp = rqstp->rq_argp;
        struct nlm_lock *lock = &argp->lock;
 
        if (!(p = xdr_decode_string_inplace(p, &lock->caller,
@@ -302,8 +315,10 @@ nlm4svc_decode_notify(struct svc_rqst *rqstp, __be32 *p, struct nlm_args *argp)
 }
 
 int
-nlm4svc_decode_reboot(struct svc_rqst *rqstp, __be32 *p, struct nlm_reboot *argp)
+nlm4svc_decode_reboot(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_reboot *argp = rqstp->rq_argp;
+
        if (!(p = xdr_decode_string_inplace(p, &argp->mon, &argp->len, SM_MAXSTRLEN)))
                return 0;
        argp->state = ntohl(*p++);
@@ -313,8 +328,10 @@ nlm4svc_decode_reboot(struct svc_rqst *rqstp, __be32 *p, struct nlm_reboot *argp
 }
 
 int
-nlm4svc_decode_res(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
+nlm4svc_decode_res(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nlm_res *resp = rqstp->rq_argp;
+
        if (!(p = nlm4_decode_cookie(p, &resp->cookie)))
                return 0;
        resp->status = *p++;
@@ -322,13 +339,13 @@ nlm4svc_decode_res(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
 }
 
 int
-nlm4svc_decode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy)
+nlm4svc_decode_void(struct svc_rqst *rqstp, __be32 *p)
 {
        return xdr_argsize_check(rqstp, p);
 }
 
 int
-nlm4svc_encode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy)
+nlm4svc_encode_void(struct svc_rqst *rqstp, __be32 *p)
 {
        return xdr_ressize_check(rqstp, p);
 }
index 73a1f928226c05706bab82a37468973bff7b185c..34323877ec132f8b163d2c1118e45ab8c319fe71 100644 (file)
@@ -439,7 +439,7 @@ static int nfs_callback_authenticate(struct svc_rqst *rqstp)
 /*
  * Define NFS4 callback program
  */
-static struct svc_version *nfs4_callback_version[] = {
+static const struct svc_version *nfs4_callback_version[] = {
        [1] = &nfs4_callback_version1,
        [4] = &nfs4_callback_version4,
 };
index c701c308fac52b16dc87d4b357d0b84f0627aa11..3dc54d7cb19c0e1c97f9c82e67105495a9c12553 100644 (file)
@@ -114,8 +114,7 @@ struct cb_sequenceres {
        uint32_t                        csr_target_highestslotid;
 };
 
-extern __be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
-                                      struct cb_sequenceres *res,
+extern __be32 nfs4_callback_sequence(void *argp, void *resp,
                                       struct cb_process_state *cps);
 
 #define RCA4_TYPE_MASK_RDATA_DLG       0
@@ -134,15 +133,13 @@ struct cb_recallanyargs {
        uint32_t        craa_type_mask;
 };
 
-extern __be32 nfs4_callback_recallany(struct cb_recallanyargs *args,
-                                       void *dummy,
+extern __be32 nfs4_callback_recallany(void *argp, void *resp,
                                        struct cb_process_state *cps);
 
 struct cb_recallslotargs {
        uint32_t        crsa_target_highest_slotid;
 };
-extern __be32 nfs4_callback_recallslot(struct cb_recallslotargs *args,
-                                        void *dummy,
+extern __be32 nfs4_callback_recallslot(void *argp, void *resp,
                                         struct cb_process_state *cps);
 
 struct cb_layoutrecallargs {
@@ -159,9 +156,8 @@ struct cb_layoutrecallargs {
        };
 };
 
-extern __be32 nfs4_callback_layoutrecall(
-       struct cb_layoutrecallargs *args,
-       void *dummy, struct cb_process_state *cps);
+extern __be32 nfs4_callback_layoutrecall(void *argp, void *resp,
+               struct cb_process_state *cps);
 
 struct cb_devicenotifyitem {
        uint32_t                cbd_notify_type;
@@ -175,9 +171,8 @@ struct cb_devicenotifyargs {
        struct cb_devicenotifyitem       *devs;
 };
 
-extern __be32 nfs4_callback_devicenotify(
-       struct cb_devicenotifyargs *args,
-       void *dummy, struct cb_process_state *cps);
+extern __be32 nfs4_callback_devicenotify(void *argp, void *resp,
+               struct cb_process_state *cps);
 
 struct cb_notify_lock_args {
        struct nfs_fh                   cbnl_fh;
@@ -185,15 +180,13 @@ struct cb_notify_lock_args {
        bool                            cbnl_valid;
 };
 
-extern __be32 nfs4_callback_notify_lock(struct cb_notify_lock_args *args,
-                                        void *dummy,
+extern __be32 nfs4_callback_notify_lock(void *argp, void *resp,
                                         struct cb_process_state *cps);
 #endif /* CONFIG_NFS_V4_1 */
 extern int check_gss_callback_principal(struct nfs_client *, struct svc_rqst *);
-extern __be32 nfs4_callback_getattr(struct cb_getattrargs *args,
-                                   struct cb_getattrres *res,
+extern __be32 nfs4_callback_getattr(void *argp, void *resp,
                                    struct cb_process_state *cps);
-extern __be32 nfs4_callback_recall(struct cb_recallargs *args, void *dummy,
+extern __be32 nfs4_callback_recall(void *argp, void *resp,
                                   struct cb_process_state *cps);
 #if IS_ENABLED(CONFIG_NFS_V4)
 extern int nfs_callback_up(u32 minorversion, struct rpc_xprt *xprt);
index 52479f180ea1497af4f8a250db4d8c222ce8bfaa..5427cdf04c5a1611934848c78455b299412dd185 100644 (file)
 
 #define NFSDBG_FACILITY NFSDBG_CALLBACK
 
-__be32 nfs4_callback_getattr(struct cb_getattrargs *args,
-                            struct cb_getattrres *res,
+__be32 nfs4_callback_getattr(void *argp, void *resp,
                             struct cb_process_state *cps)
 {
+       struct cb_getattrargs *args = argp;
+       struct cb_getattrres *res = resp;
        struct nfs_delegation *delegation;
        struct nfs_inode *nfsi;
        struct inode *inode;
@@ -68,9 +69,10 @@ out:
        return res->status;
 }
 
-__be32 nfs4_callback_recall(struct cb_recallargs *args, void *dummy,
+__be32 nfs4_callback_recall(void *argp, void *resp,
                            struct cb_process_state *cps)
 {
+       struct cb_recallargs *args = argp;
        struct inode *inode;
        __be32 res;
        
@@ -324,9 +326,10 @@ static u32 do_callback_layoutrecall(struct nfs_client *clp,
        return initiate_bulk_draining(clp, args);
 }
 
-__be32 nfs4_callback_layoutrecall(struct cb_layoutrecallargs *args,
-                                 void *dummy, struct cb_process_state *cps)
+__be32 nfs4_callback_layoutrecall(void *argp, void *resp,
+                                 struct cb_process_state *cps)
 {
+       struct cb_layoutrecallargs *args = argp;
        u32 res = NFS4ERR_OP_NOT_IN_SESSION;
 
        if (cps->clp)
@@ -345,9 +348,10 @@ static void pnfs_recall_all_layouts(struct nfs_client *clp)
        do_callback_layoutrecall(clp, &args);
 }
 
-__be32 nfs4_callback_devicenotify(struct cb_devicenotifyargs *args,
-                                 void *dummy, struct cb_process_state *cps)
+__be32 nfs4_callback_devicenotify(void *argp, void *resp,
+                                 struct cb_process_state *cps)
 {
+       struct cb_devicenotifyargs *args = argp;
        int i;
        __be32 res = 0;
        struct nfs_client *clp = cps->clp;
@@ -469,10 +473,11 @@ out:
        return status;
 }
 
-__be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
-                             struct cb_sequenceres *res,
+__be32 nfs4_callback_sequence(void *argp, void *resp,
                              struct cb_process_state *cps)
 {
+       struct cb_sequenceargs *args = argp;
+       struct cb_sequenceres *res = resp;
        struct nfs4_slot_table *tbl;
        struct nfs4_slot *slot;
        struct nfs_client *clp;
@@ -571,9 +576,10 @@ validate_bitmap_values(unsigned long mask)
        return (mask & ~RCA4_TYPE_MASK_ALL) == 0;
 }
 
-__be32 nfs4_callback_recallany(struct cb_recallanyargs *args, void *dummy,
+__be32 nfs4_callback_recallany(void *argp, void *resp,
                               struct cb_process_state *cps)
 {
+       struct cb_recallanyargs *args = argp;
        __be32 status;
        fmode_t flags = 0;
 
@@ -606,9 +612,10 @@ out:
 }
 
 /* Reduce the fore channel's max_slots to the target value */
-__be32 nfs4_callback_recallslot(struct cb_recallslotargs *args, void *dummy,
+__be32 nfs4_callback_recallslot(void *argp, void *resp,
                                struct cb_process_state *cps)
 {
+       struct cb_recallslotargs *args = argp;
        struct nfs4_slot_table *fc_tbl;
        __be32 status;
 
@@ -631,9 +638,11 @@ out:
        return status;
 }
 
-__be32 nfs4_callback_notify_lock(struct cb_notify_lock_args *args, void *dummy,
+__be32 nfs4_callback_notify_lock(void *argp, void *resp,
                                 struct cb_process_state *cps)
 {
+       struct cb_notify_lock_args *args = argp;
+
        if (!cps->clp) /* set in cb_sequence */
                return htonl(NFS4ERR_OP_NOT_IN_SESSION);
 
index 390ac9c39c5932ef93f3ae8d3a5615f2737848af..681dd642f1195a0ebe253f8c57cb3fa81888f0c7 100644 (file)
 /* Internal error code */
 #define NFS4ERR_RESOURCE_HDR   11050
 
-typedef __be32 (*callback_process_op_t)(void *, void *,
-                                       struct cb_process_state *);
-typedef __be32 (*callback_decode_arg_t)(struct svc_rqst *, struct xdr_stream *, void *);
-typedef __be32 (*callback_encode_res_t)(struct svc_rqst *, struct xdr_stream *, void *);
-
-
 struct callback_op {
-       callback_process_op_t process_op;
-       callback_decode_arg_t decode_args;
-       callback_encode_res_t encode_res;
+       __be32 (*process_op)(void *, void *, struct cb_process_state *);
+       __be32 (*decode_args)(struct svc_rqst *, struct xdr_stream *, void *);
+       __be32 (*encode_res)(struct svc_rqst *, struct xdr_stream *,
+                       const void *);
        long res_maxsize;
 };
 
 static struct callback_op callback_ops[];
 
-static __be32 nfs4_callback_null(struct svc_rqst *rqstp, void *argp, void *resp)
+static __be32 nfs4_callback_null(struct svc_rqst *rqstp)
 {
        return htonl(NFS4_OK);
 }
 
-static int nfs4_decode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy)
+static int nfs4_decode_void(struct svc_rqst *rqstp, __be32 *p)
 {
        return xdr_argsize_check(rqstp, p);
 }
 
-static int nfs4_encode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy)
+static int nfs4_encode_void(struct svc_rqst *rqstp, __be32 *p)
 {
        return xdr_ressize_check(rqstp, p);
 }
@@ -184,8 +179,10 @@ static __be32 decode_op_hdr(struct xdr_stream *xdr, unsigned int *op)
        return 0;
 }
 
-static __be32 decode_getattr_args(struct svc_rqst *rqstp, struct xdr_stream *xdr, struct cb_getattrargs *args)
+static __be32 decode_getattr_args(struct svc_rqst *rqstp,
+               struct xdr_stream *xdr, void *argp)
 {
+       struct cb_getattrargs *args = argp;
        __be32 status;
 
        status = decode_fh(xdr, &args->fh);
@@ -194,8 +191,10 @@ static __be32 decode_getattr_args(struct svc_rqst *rqstp, struct xdr_stream *xdr
        return decode_bitmap(xdr, args->bitmap);
 }
 
-static __be32 decode_recall_args(struct svc_rqst *rqstp, struct xdr_stream *xdr, struct cb_recallargs *args)
+static __be32 decode_recall_args(struct svc_rqst *rqstp,
+               struct xdr_stream *xdr, void *argp)
 {
+       struct cb_recallargs *args = argp;
        __be32 *p;
        __be32 status;
 
@@ -217,9 +216,9 @@ static __be32 decode_layout_stateid(struct xdr_stream *xdr, nfs4_stateid *statei
 }
 
 static __be32 decode_layoutrecall_args(struct svc_rqst *rqstp,
-                                      struct xdr_stream *xdr,
-                                      struct cb_layoutrecallargs *args)
+                                      struct xdr_stream *xdr, void *argp)
 {
+       struct cb_layoutrecallargs *args = argp;
        __be32 *p;
        __be32 status = 0;
        uint32_t iomode;
@@ -262,8 +261,9 @@ static __be32 decode_layoutrecall_args(struct svc_rqst *rqstp,
 static
 __be32 decode_devicenotify_args(struct svc_rqst *rqstp,
                                struct xdr_stream *xdr,
-                               struct cb_devicenotifyargs *args)
+                               void *argp)
 {
+       struct cb_devicenotifyargs *args = argp;
        __be32 *p;
        __be32 status = 0;
        u32 tmp;
@@ -403,8 +403,9 @@ out:
 
 static __be32 decode_cb_sequence_args(struct svc_rqst *rqstp,
                                        struct xdr_stream *xdr,
-                                       struct cb_sequenceargs *args)
+                                       void *argp)
 {
+       struct cb_sequenceargs *args = argp;
        __be32 *p;
        int i;
        __be32 status;
@@ -450,8 +451,9 @@ out_free:
 
 static __be32 decode_recallany_args(struct svc_rqst *rqstp,
                                      struct xdr_stream *xdr,
-                                     struct cb_recallanyargs *args)
+                                     void *argp)
 {
+       struct cb_recallanyargs *args = argp;
        uint32_t bitmap[2];
        __be32 *p, status;
 
@@ -469,8 +471,9 @@ static __be32 decode_recallany_args(struct svc_rqst *rqstp,
 
 static __be32 decode_recallslot_args(struct svc_rqst *rqstp,
                                        struct xdr_stream *xdr,
-                                       struct cb_recallslotargs *args)
+                                       void *argp)
 {
+       struct cb_recallslotargs *args = argp;
        __be32 *p;
 
        p = read_buf(xdr, 4);
@@ -510,8 +513,10 @@ static __be32 decode_lockowner(struct xdr_stream *xdr, struct cb_notify_lock_arg
        return 0;
 }
 
-static __be32 decode_notify_lock_args(struct svc_rqst *rqstp, struct xdr_stream *xdr, struct cb_notify_lock_args *args)
+static __be32 decode_notify_lock_args(struct svc_rqst *rqstp,
+               struct xdr_stream *xdr, void *argp)
 {
+       struct cb_notify_lock_args *args = argp;
        __be32 status;
 
        status = decode_fh(xdr, &args->cbnl_fh);
@@ -641,8 +646,10 @@ static __be32 encode_op_hdr(struct xdr_stream *xdr, uint32_t op, __be32 res)
        return 0;
 }
 
-static __be32 encode_getattr_res(struct svc_rqst *rqstp, struct xdr_stream *xdr, const struct cb_getattrres *res)
+static __be32 encode_getattr_res(struct svc_rqst *rqstp, struct xdr_stream *xdr,
+               const void *resp)
 {
+       const struct cb_getattrres *res = resp;
        __be32 *savep = NULL;
        __be32 status = res->status;
        
@@ -683,8 +690,9 @@ static __be32 encode_sessionid(struct xdr_stream *xdr,
 
 static __be32 encode_cb_sequence_res(struct svc_rqst *rqstp,
                                       struct xdr_stream *xdr,
-                                      const struct cb_sequenceres *res)
+                                      const void *resp)
 {
+       const struct cb_sequenceres *res = resp;
        __be32 *p;
        __be32 status = res->csr_status;
 
@@ -871,7 +879,7 @@ encode_hdr:
 /*
  * Decode, process and encode a COMPOUND
  */
-static __be32 nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *resp)
+static __be32 nfs4_callback_compound(struct svc_rqst *rqstp)
 {
        struct cb_compound_hdr_arg hdr_arg = { 0 };
        struct cb_compound_hdr_res hdr_res = { NULL };
@@ -907,7 +915,8 @@ static __be32 nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *r
 
        while (status == 0 && nops != hdr_arg.nops) {
                status = process_op(nops, rqstp, &xdr_in,
-                                   argp, &xdr_out, resp, &cps);
+                                   rqstp->rq_argp, &xdr_out, rqstp->rq_resp,
+                                   &cps);
                nops++;
        }
 
@@ -937,48 +946,46 @@ static struct callback_op callback_ops[] = {
                .res_maxsize = CB_OP_HDR_RES_MAXSZ,
        },
        [OP_CB_GETATTR] = {
-               .process_op = (callback_process_op_t)nfs4_callback_getattr,
-               .decode_args = (callback_decode_arg_t)decode_getattr_args,
-               .encode_res = (callback_encode_res_t)encode_getattr_res,
+               .process_op = nfs4_callback_getattr,
+               .decode_args = decode_getattr_args,
+               .encode_res = encode_getattr_res,
                .res_maxsize = CB_OP_GETATTR_RES_MAXSZ,
        },
        [OP_CB_RECALL] = {
-               .process_op = (callback_process_op_t)nfs4_callback_recall,
-               .decode_args = (callback_decode_arg_t)decode_recall_args,
+               .process_op = nfs4_callback_recall,
+               .decode_args = decode_recall_args,
                .res_maxsize = CB_OP_RECALL_RES_MAXSZ,
        },
 #if defined(CONFIG_NFS_V4_1)
        [OP_CB_LAYOUTRECALL] = {
-               .process_op = (callback_process_op_t)nfs4_callback_layoutrecall,
-               .decode_args =
-                       (callback_decode_arg_t)decode_layoutrecall_args,
+               .process_op = nfs4_callback_layoutrecall,
+               .decode_args = decode_layoutrecall_args,
                .res_maxsize = CB_OP_LAYOUTRECALL_RES_MAXSZ,
        },
        [OP_CB_NOTIFY_DEVICEID] = {
-               .process_op = (callback_process_op_t)nfs4_callback_devicenotify,
-               .decode_args =
-                       (callback_decode_arg_t)decode_devicenotify_args,
+               .process_op = nfs4_callback_devicenotify,
+               .decode_args = decode_devicenotify_args,
                .res_maxsize = CB_OP_DEVICENOTIFY_RES_MAXSZ,
        },
        [OP_CB_SEQUENCE] = {
-               .process_op = (callback_process_op_t)nfs4_callback_sequence,
-               .decode_args = (callback_decode_arg_t)decode_cb_sequence_args,
-               .encode_res = (callback_encode_res_t)encode_cb_sequence_res,
+               .process_op = nfs4_callback_sequence,
+               .decode_args = decode_cb_sequence_args,
+               .encode_res = encode_cb_sequence_res,
                .res_maxsize = CB_OP_SEQUENCE_RES_MAXSZ,
        },
        [OP_CB_RECALL_ANY] = {
-               .process_op = (callback_process_op_t)nfs4_callback_recallany,
-               .decode_args = (callback_decode_arg_t)decode_recallany_args,
+               .process_op = nfs4_callback_recallany,
+               .decode_args = decode_recallany_args,
                .res_maxsize = CB_OP_RECALLANY_RES_MAXSZ,
        },
        [OP_CB_RECALL_SLOT] = {
-               .process_op = (callback_process_op_t)nfs4_callback_recallslot,
-               .decode_args = (callback_decode_arg_t)decode_recallslot_args,
+               .process_op = nfs4_callback_recallslot,
+               .decode_args = decode_recallslot_args,
                .res_maxsize = CB_OP_RECALLSLOT_RES_MAXSZ,
        },
        [OP_CB_NOTIFY_LOCK] = {
-               .process_op = (callback_process_op_t)nfs4_callback_notify_lock,
-               .decode_args = (callback_decode_arg_t)decode_notify_lock_args,
+               .process_op = nfs4_callback_notify_lock,
+               .decode_args = decode_notify_lock_args,
                .res_maxsize = CB_OP_NOTIFY_LOCK_RES_MAXSZ,
        },
 #endif /* CONFIG_NFS_V4_1 */
@@ -987,36 +994,40 @@ static struct callback_op callback_ops[] = {
 /*
  * Define NFS4 callback procedures
  */
-static struct svc_procedure nfs4_callback_procedures1[] = {
+static const struct svc_procedure nfs4_callback_procedures1[] = {
        [CB_NULL] = {
                .pc_func = nfs4_callback_null,
-               .pc_decode = (kxdrproc_t)nfs4_decode_void,
-               .pc_encode = (kxdrproc_t)nfs4_encode_void,
+               .pc_decode = nfs4_decode_void,
+               .pc_encode = nfs4_encode_void,
                .pc_xdrressize = 1,
        },
        [CB_COMPOUND] = {
                .pc_func = nfs4_callback_compound,
-               .pc_encode = (kxdrproc_t)nfs4_encode_void,
+               .pc_encode = nfs4_encode_void,
                .pc_argsize = 256,
                .pc_ressize = 256,
                .pc_xdrressize = NFS4_CALLBACK_BUFSIZE,
        }
 };
 
-struct svc_version nfs4_callback_version1 = {
+static unsigned int nfs4_callback_count1[ARRAY_SIZE(nfs4_callback_procedures1)];
+const struct svc_version nfs4_callback_version1 = {
        .vs_vers = 1,
        .vs_nproc = ARRAY_SIZE(nfs4_callback_procedures1),
        .vs_proc = nfs4_callback_procedures1,
+       .vs_count = nfs4_callback_count1,
        .vs_xdrsize = NFS4_CALLBACK_XDRSIZE,
        .vs_dispatch = NULL,
        .vs_hidden = true,
        .vs_need_cong_ctrl = true,
 };
 
-struct svc_version nfs4_callback_version4 = {
+static unsigned int nfs4_callback_count4[ARRAY_SIZE(nfs4_callback_procedures1)];
+const struct svc_version nfs4_callback_version4 = {
        .vs_vers = 4,
        .vs_nproc = ARRAY_SIZE(nfs4_callback_procedures1),
        .vs_proc = nfs4_callback_procedures1,
+       .vs_count = nfs4_callback_count4,
        .vs_xdrsize = NFS4_CALLBACK_XDRSIZE,
        .vs_dispatch = NULL,
        .vs_hidden = true,
index 8701d761796495aa93d7b999af0735841d66008f..c7ebba9eb6111ca1c834500a2c6f778b1c5e47ee 100644 (file)
@@ -226,8 +226,8 @@ static inline void nfs_fs_proc_exit(void)
 #endif
 
 /* callback_xdr.c */
-extern struct svc_version nfs4_callback_version1;
-extern struct svc_version nfs4_callback_version4;
+extern const struct svc_version nfs4_callback_version1;
+extern const struct svc_version nfs4_callback_version4;
 
 struct nfs_pageio_descriptor;
 /* pagelist.c */
@@ -271,12 +271,12 @@ static inline bool nfs_match_open_context(const struct nfs_open_context *ctx1,
 }
 
 /* nfs2xdr.c */
-extern struct rpc_procinfo nfs_procedures[];
+extern const struct rpc_procinfo nfs_procedures[];
 extern int nfs2_decode_dirent(struct xdr_stream *,
                                struct nfs_entry *, int);
 
 /* nfs3xdr.c */
-extern struct rpc_procinfo nfs3_procedures[];
+extern const struct rpc_procinfo nfs3_procedures[];
 extern int nfs3_decode_dirent(struct xdr_stream *,
                                struct nfs_entry *, int);
 
@@ -293,7 +293,7 @@ extern const u32 nfs41_maxgetdevinfo_overhead;
 
 /* nfs4proc.c */
 #if IS_ENABLED(CONFIG_NFS_V4)
-extern struct rpc_procinfo nfs4_procedures[];
+extern const struct rpc_procinfo nfs4_procedures[];
 #endif
 
 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
index 09b190015df41b4b1a36380011b59c4a8853c0af..3efe946672beb0b23cb7b7fbf0da79842b801cd5 100644 (file)
@@ -304,7 +304,7 @@ static void encode_mntdirpath(struct xdr_stream *xdr, const char *pathname)
 }
 
 static void mnt_xdr_enc_dirpath(struct rpc_rqst *req, struct xdr_stream *xdr,
-                               const char *dirpath)
+                               const void *dirpath)
 {
        encode_mntdirpath(xdr, dirpath);
 }
@@ -357,8 +357,9 @@ static int decode_fhandle(struct xdr_stream *xdr, struct mountres *res)
 
 static int mnt_xdr_dec_mountres(struct rpc_rqst *req,
                                struct xdr_stream *xdr,
-                               struct mountres *res)
+                               void *data)
 {
+       struct mountres *res = data;
        int status;
 
        status = decode_status(xdr, res);
@@ -449,8 +450,9 @@ static int decode_auth_flavors(struct xdr_stream *xdr, struct mountres *res)
 
 static int mnt_xdr_dec_mountres3(struct rpc_rqst *req,
                                 struct xdr_stream *xdr,
-                                struct mountres *res)
+                                void *data)
 {
+       struct mountres *res = data;
        int status;
 
        status = decode_fhs_status(xdr, res);
@@ -464,11 +466,11 @@ static int mnt_xdr_dec_mountres3(struct rpc_rqst *req,
        return decode_auth_flavors(xdr, res);
 }
 
-static struct rpc_procinfo mnt_procedures[] = {
+static const struct rpc_procinfo mnt_procedures[] = {
        [MOUNTPROC_MNT] = {
                .p_proc         = MOUNTPROC_MNT,
-               .p_encode       = (kxdreproc_t)mnt_xdr_enc_dirpath,
-               .p_decode       = (kxdrdproc_t)mnt_xdr_dec_mountres,
+               .p_encode       = mnt_xdr_enc_dirpath,
+               .p_decode       = mnt_xdr_dec_mountres,
                .p_arglen       = MNT_enc_dirpath_sz,
                .p_replen       = MNT_dec_mountres_sz,
                .p_statidx      = MOUNTPROC_MNT,
@@ -476,18 +478,18 @@ static struct rpc_procinfo mnt_procedures[] = {
        },
        [MOUNTPROC_UMNT] = {
                .p_proc         = MOUNTPROC_UMNT,
-               .p_encode       = (kxdreproc_t)mnt_xdr_enc_dirpath,
+               .p_encode       = mnt_xdr_enc_dirpath,
                .p_arglen       = MNT_enc_dirpath_sz,
                .p_statidx      = MOUNTPROC_UMNT,
                .p_name         = "UMOUNT",
        },
 };
 
-static struct rpc_procinfo mnt3_procedures[] = {
+static const struct rpc_procinfo mnt3_procedures[] = {
        [MOUNTPROC3_MNT] = {
                .p_proc         = MOUNTPROC3_MNT,
-               .p_encode       = (kxdreproc_t)mnt_xdr_enc_dirpath,
-               .p_decode       = (kxdrdproc_t)mnt_xdr_dec_mountres3,
+               .p_encode       = mnt_xdr_enc_dirpath,
+               .p_decode       = mnt_xdr_dec_mountres3,
                .p_arglen       = MNT_enc_dirpath_sz,
                .p_replen       = MNT_dec_mountres3_sz,
                .p_statidx      = MOUNTPROC3_MNT,
@@ -495,24 +497,27 @@ static struct rpc_procinfo mnt3_procedures[] = {
        },
        [MOUNTPROC3_UMNT] = {
                .p_proc         = MOUNTPROC3_UMNT,
-               .p_encode       = (kxdreproc_t)mnt_xdr_enc_dirpath,
+               .p_encode       = mnt_xdr_enc_dirpath,
                .p_arglen       = MNT_enc_dirpath_sz,
                .p_statidx      = MOUNTPROC3_UMNT,
                .p_name         = "UMOUNT",
        },
 };
 
-
+static unsigned int mnt_counts[ARRAY_SIZE(mnt_procedures)];
 static const struct rpc_version mnt_version1 = {
        .number         = 1,
        .nrprocs        = ARRAY_SIZE(mnt_procedures),
        .procs          = mnt_procedures,
+       .counts         = mnt_counts,
 };
 
+static unsigned int mnt3_counts[ARRAY_SIZE(mnt_procedures)];
 static const struct rpc_version mnt_version3 = {
        .number         = 3,
        .nrprocs        = ARRAY_SIZE(mnt3_procedures),
        .procs          = mnt3_procedures,
+       .counts         = mnt3_counts,
 };
 
 static const struct rpc_version *mnt_version[] = {
index b4e03ed8599de5da394f2ae8eed8bbc78a7ed82a..c8a7e98c1371afc879ef28d1acc2f0f17c884401 100644 (file)
@@ -568,8 +568,10 @@ out_default:
 
 static void nfs2_xdr_enc_fhandle(struct rpc_rqst *req,
                                 struct xdr_stream *xdr,
-                                const struct nfs_fh *fh)
+                                const void *data)
 {
+       const struct nfs_fh *fh = data;
+
        encode_fhandle(xdr, fh);
 }
 
@@ -583,23 +585,29 @@ static void nfs2_xdr_enc_fhandle(struct rpc_rqst *req,
  */
 static void nfs2_xdr_enc_sattrargs(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  const struct nfs_sattrargs *args)
+                                  const void *data)
 {
+       const struct nfs_sattrargs *args = data;
+
        encode_fhandle(xdr, args->fh);
        encode_sattr(xdr, args->sattr);
 }
 
 static void nfs2_xdr_enc_diropargs(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  const struct nfs_diropargs *args)
+                                  const void *data)
 {
+       const struct nfs_diropargs *args = data;
+
        encode_diropargs(xdr, args->fh, args->name, args->len);
 }
 
 static void nfs2_xdr_enc_readlinkargs(struct rpc_rqst *req,
                                      struct xdr_stream *xdr,
-                                     const struct nfs_readlinkargs *args)
+                                     const void *data)
 {
+       const struct nfs_readlinkargs *args = data;
+
        encode_fhandle(xdr, args->fh);
        prepare_reply_buffer(req, args->pages, args->pgbase,
                                        args->pglen, NFS_readlinkres_sz);
@@ -632,8 +640,10 @@ static void encode_readargs(struct xdr_stream *xdr,
 
 static void nfs2_xdr_enc_readargs(struct rpc_rqst *req,
                                  struct xdr_stream *xdr,
-                                 const struct nfs_pgio_args *args)
+                                 const void *data)
 {
+       const struct nfs_pgio_args *args = data;
+
        encode_readargs(xdr, args);
        prepare_reply_buffer(req, args->pages, args->pgbase,
                                        args->count, NFS_readres_sz);
@@ -672,8 +682,10 @@ static void encode_writeargs(struct xdr_stream *xdr,
 
 static void nfs2_xdr_enc_writeargs(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  const struct nfs_pgio_args *args)
+                                  const void *data)
 {
+       const struct nfs_pgio_args *args = data;
+
        encode_writeargs(xdr, args);
        xdr->buf->flags |= XDRBUF_WRITE;
 }
@@ -688,16 +700,20 @@ static void nfs2_xdr_enc_writeargs(struct rpc_rqst *req,
  */
 static void nfs2_xdr_enc_createargs(struct rpc_rqst *req,
                                    struct xdr_stream *xdr,
-                                   const struct nfs_createargs *args)
+                                   const void *data)
 {
+       const struct nfs_createargs *args = data;
+
        encode_diropargs(xdr, args->fh, args->name, args->len);
        encode_sattr(xdr, args->sattr);
 }
 
 static void nfs2_xdr_enc_removeargs(struct rpc_rqst *req,
                                    struct xdr_stream *xdr,
-                                   const struct nfs_removeargs *args)
+                                   const void *data)
 {
+       const struct nfs_removeargs *args = data;
+
        encode_diropargs(xdr, args->fh, args->name.name, args->name.len);
 }
 
@@ -711,8 +727,9 @@ static void nfs2_xdr_enc_removeargs(struct rpc_rqst *req,
  */
 static void nfs2_xdr_enc_renameargs(struct rpc_rqst *req,
                                    struct xdr_stream *xdr,
-                                   const struct nfs_renameargs *args)
+                                   const void *data)
 {
+       const struct nfs_renameargs *args = data;
        const struct qstr *old = args->old_name;
        const struct qstr *new = args->new_name;
 
@@ -730,8 +747,10 @@ static void nfs2_xdr_enc_renameargs(struct rpc_rqst *req,
  */
 static void nfs2_xdr_enc_linkargs(struct rpc_rqst *req,
                                  struct xdr_stream *xdr,
-                                 const struct nfs_linkargs *args)
+                                 const void *data)
 {
+       const struct nfs_linkargs *args = data;
+
        encode_fhandle(xdr, args->fromfh);
        encode_diropargs(xdr, args->tofh, args->toname, args->tolen);
 }
@@ -747,8 +766,10 @@ static void nfs2_xdr_enc_linkargs(struct rpc_rqst *req,
  */
 static void nfs2_xdr_enc_symlinkargs(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    const struct nfs_symlinkargs *args)
+                                    const void *data)
 {
+       const struct nfs_symlinkargs *args = data;
+
        encode_diropargs(xdr, args->fromfh, args->fromname, args->fromlen);
        encode_path(xdr, args->pages, args->pathlen);
        encode_sattr(xdr, args->sattr);
@@ -777,8 +798,10 @@ static void encode_readdirargs(struct xdr_stream *xdr,
 
 static void nfs2_xdr_enc_readdirargs(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    const struct nfs_readdirargs *args)
+                                    const void *data)
 {
+       const struct nfs_readdirargs *args = data;
+
        encode_readdirargs(xdr, args);
        prepare_reply_buffer(req, args->pages, 0,
                                        args->count, NFS_readdirres_sz);
@@ -809,13 +832,13 @@ out_default:
 }
 
 static int nfs2_xdr_dec_attrstat(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                struct nfs_fattr *result)
+                                void *result)
 {
        return decode_attrstat(xdr, result, NULL);
 }
 
 static int nfs2_xdr_dec_diropres(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                struct nfs_diropok *result)
+                                void *result)
 {
        return decode_diropres(xdr, result);
 }
@@ -860,8 +883,9 @@ out_default:
  *     };
  */
 static int nfs2_xdr_dec_readres(struct rpc_rqst *req, struct xdr_stream *xdr,
-                               struct nfs_pgio_res *result)
+                               void *data)
 {
+       struct nfs_pgio_res *result = data;
        enum nfs_stat status;
        int error;
 
@@ -882,8 +906,10 @@ out_default:
 }
 
 static int nfs2_xdr_dec_writeres(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                struct nfs_pgio_res *result)
+                                void *data)
 {
+       struct nfs_pgio_res *result = data;
+
        /* All NFSv2 writes are "file sync" writes */
        result->verf->committed = NFS_FILE_SYNC;
        return decode_attrstat(xdr, result->fattr, &result->op_status);
@@ -1034,7 +1060,7 @@ out_overflow:
 }
 
 static int nfs2_xdr_dec_statfsres(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                 struct nfs2_fsstat *result)
+                                 void *result)
 {
        enum nfs_stat status;
        int error;
@@ -1118,15 +1144,15 @@ static int nfs_stat_to_errno(enum nfs_stat status)
 #define PROC(proc, argtype, restype, timer)                            \
 [NFSPROC_##proc] = {                                                   \
        .p_proc     =  NFSPROC_##proc,                                  \
-       .p_encode   =  (kxdreproc_t)nfs2_xdr_enc_##argtype,             \
-       .p_decode   =  (kxdrdproc_t)nfs2_xdr_dec_##restype,             \
+       .p_encode   =  nfs2_xdr_enc_##argtype,                          \
+       .p_decode   =  nfs2_xdr_dec_##restype,                          \
        .p_arglen   =  NFS_##argtype##_sz,                              \
        .p_replen   =  NFS_##restype##_sz,                              \
        .p_timer    =  timer,                                           \
        .p_statidx  =  NFSPROC_##proc,                                  \
        .p_name     =  #proc,                                           \
        }
-struct rpc_procinfo    nfs_procedures[] = {
+const struct rpc_procinfo nfs_procedures[] = {
        PROC(GETATTR,   fhandle,        attrstat,       1),
        PROC(SETATTR,   sattrargs,      attrstat,       0),
        PROC(LOOKUP,    diropargs,      diropres,       2),
@@ -1144,8 +1170,10 @@ struct rpc_procinfo      nfs_procedures[] = {
        PROC(STATFS,    fhandle,        statfsres,      0),
 };
 
+static unsigned int nfs_version2_counts[ARRAY_SIZE(nfs_procedures)];
 const struct rpc_version nfs_version2 = {
        .number                 = 2,
        .nrprocs                = ARRAY_SIZE(nfs_procedures),
-       .procs                  = nfs_procedures
+       .procs                  = nfs_procedures,
+       .counts                 = nfs_version2_counts,
 };
index 267126d32ec0f6a1d5d09293ef9427585edca9c6..670eddb3ae36951c5453d7884fb12b0c44ececed 100644 (file)
@@ -846,8 +846,10 @@ static void encode_diropargs3(struct xdr_stream *xdr, const struct nfs_fh *fh,
  */
 static void nfs3_xdr_enc_getattr3args(struct rpc_rqst *req,
                                      struct xdr_stream *xdr,
-                                     const struct nfs_fh *fh)
+                                     const void *data)
 {
+       const struct nfs_fh *fh = data;
+
        encode_nfs_fh3(xdr, fh);
 }
 
@@ -884,8 +886,9 @@ static void encode_sattrguard3(struct xdr_stream *xdr,
 
 static void nfs3_xdr_enc_setattr3args(struct rpc_rqst *req,
                                      struct xdr_stream *xdr,
-                                     const struct nfs3_sattrargs *args)
+                                     const void *data)
 {
+       const struct nfs3_sattrargs *args = data;
        encode_nfs_fh3(xdr, args->fh);
        encode_sattr3(xdr, args->sattr);
        encode_sattrguard3(xdr, args);
@@ -900,8 +903,10 @@ static void nfs3_xdr_enc_setattr3args(struct rpc_rqst *req,
  */
 static void nfs3_xdr_enc_lookup3args(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    const struct nfs3_diropargs *args)
+                                    const void *data)
 {
+       const struct nfs3_diropargs *args = data;
+
        encode_diropargs3(xdr, args->fh, args->name, args->len);
 }
 
@@ -922,8 +927,10 @@ static void encode_access3args(struct xdr_stream *xdr,
 
 static void nfs3_xdr_enc_access3args(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    const struct nfs3_accessargs *args)
+                                    const void *data)
 {
+       const struct nfs3_accessargs *args = data;
+
        encode_access3args(xdr, args);
 }
 
@@ -936,8 +943,10 @@ static void nfs3_xdr_enc_access3args(struct rpc_rqst *req,
  */
 static void nfs3_xdr_enc_readlink3args(struct rpc_rqst *req,
                                       struct xdr_stream *xdr,
-                                      const struct nfs3_readlinkargs *args)
+                                      const void *data)
 {
+       const struct nfs3_readlinkargs *args = data;
+
        encode_nfs_fh3(xdr, args->fh);
        prepare_reply_buffer(req, args->pages, args->pgbase,
                                        args->pglen, NFS3_readlinkres_sz);
@@ -966,8 +975,10 @@ static void encode_read3args(struct xdr_stream *xdr,
 
 static void nfs3_xdr_enc_read3args(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  const struct nfs_pgio_args *args)
+                                  const void *data)
 {
+       const struct nfs_pgio_args *args = data;
+
        encode_read3args(xdr, args);
        prepare_reply_buffer(req, args->pages, args->pgbase,
                                        args->count, NFS3_readres_sz);
@@ -1008,8 +1019,10 @@ static void encode_write3args(struct xdr_stream *xdr,
 
 static void nfs3_xdr_enc_write3args(struct rpc_rqst *req,
                                    struct xdr_stream *xdr,
-                                   const struct nfs_pgio_args *args)
+                                   const void *data)
 {
+       const struct nfs_pgio_args *args = data;
+
        encode_write3args(xdr, args);
        xdr->buf->flags |= XDRBUF_WRITE;
 }
@@ -1055,8 +1068,10 @@ static void encode_createhow3(struct xdr_stream *xdr,
 
 static void nfs3_xdr_enc_create3args(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    const struct nfs3_createargs *args)
+                                    const void *data)
 {
+       const struct nfs3_createargs *args = data;
+
        encode_diropargs3(xdr, args->fh, args->name, args->len);
        encode_createhow3(xdr, args);
 }
@@ -1071,8 +1086,10 @@ static void nfs3_xdr_enc_create3args(struct rpc_rqst *req,
  */
 static void nfs3_xdr_enc_mkdir3args(struct rpc_rqst *req,
                                    struct xdr_stream *xdr,
-                                   const struct nfs3_mkdirargs *args)
+                                   const void *data)
 {
+       const struct nfs3_mkdirargs *args = data;
+
        encode_diropargs3(xdr, args->fh, args->name, args->len);
        encode_sattr3(xdr, args->sattr);
 }
@@ -1091,16 +1108,20 @@ static void nfs3_xdr_enc_mkdir3args(struct rpc_rqst *req,
  *     };
  */
 static void encode_symlinkdata3(struct xdr_stream *xdr,
-                               const struct nfs3_symlinkargs *args)
+                               const void *data)
 {
+       const struct nfs3_symlinkargs *args = data;
+
        encode_sattr3(xdr, args->sattr);
        encode_nfspath3(xdr, args->pages, args->pathlen);
 }
 
 static void nfs3_xdr_enc_symlink3args(struct rpc_rqst *req,
                                      struct xdr_stream *xdr,
-                                     const struct nfs3_symlinkargs *args)
+                                     const void *data)
 {
+       const struct nfs3_symlinkargs *args = data;
+
        encode_diropargs3(xdr, args->fromfh, args->fromname, args->fromlen);
        encode_symlinkdata3(xdr, args);
        xdr->buf->flags |= XDRBUF_WRITE;
@@ -1160,8 +1181,10 @@ static void encode_mknoddata3(struct xdr_stream *xdr,
 
 static void nfs3_xdr_enc_mknod3args(struct rpc_rqst *req,
                                    struct xdr_stream *xdr,
-                                   const struct nfs3_mknodargs *args)
+                                   const void *data)
 {
+       const struct nfs3_mknodargs *args = data;
+
        encode_diropargs3(xdr, args->fh, args->name, args->len);
        encode_mknoddata3(xdr, args);
 }
@@ -1175,8 +1198,10 @@ static void nfs3_xdr_enc_mknod3args(struct rpc_rqst *req,
  */
 static void nfs3_xdr_enc_remove3args(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    const struct nfs_removeargs *args)
+                                    const void *data)
 {
+       const struct nfs_removeargs *args = data;
+
        encode_diropargs3(xdr, args->fh, args->name.name, args->name.len);
 }
 
@@ -1190,8 +1215,9 @@ static void nfs3_xdr_enc_remove3args(struct rpc_rqst *req,
  */
 static void nfs3_xdr_enc_rename3args(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    const struct nfs_renameargs *args)
+                                    const void *data)
 {
+       const struct nfs_renameargs *args = data;
        const struct qstr *old = args->old_name;
        const struct qstr *new = args->new_name;
 
@@ -1209,8 +1235,10 @@ static void nfs3_xdr_enc_rename3args(struct rpc_rqst *req,
  */
 static void nfs3_xdr_enc_link3args(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  const struct nfs3_linkargs *args)
+                                  const void *data)
 {
+       const struct nfs3_linkargs *args = data;
+
        encode_nfs_fh3(xdr, args->fromfh);
        encode_diropargs3(xdr, args->tofh, args->toname, args->tolen);
 }
@@ -1240,8 +1268,10 @@ static void encode_readdir3args(struct xdr_stream *xdr,
 
 static void nfs3_xdr_enc_readdir3args(struct rpc_rqst *req,
                                      struct xdr_stream *xdr,
-                                     const struct nfs3_readdirargs *args)
+                                     const void *data)
 {
+       const struct nfs3_readdirargs *args = data;
+
        encode_readdir3args(xdr, args);
        prepare_reply_buffer(req, args->pages, 0,
                                args->count, NFS3_readdirres_sz);
@@ -1280,8 +1310,10 @@ static void encode_readdirplus3args(struct xdr_stream *xdr,
 
 static void nfs3_xdr_enc_readdirplus3args(struct rpc_rqst *req,
                                          struct xdr_stream *xdr,
-                                         const struct nfs3_readdirargs *args)
+                                         const void *data)
 {
+       const struct nfs3_readdirargs *args = data;
+
        encode_readdirplus3args(xdr, args);
        prepare_reply_buffer(req, args->pages, 0,
                                args->count, NFS3_readdirres_sz);
@@ -1310,8 +1342,10 @@ static void encode_commit3args(struct xdr_stream *xdr,
 
 static void nfs3_xdr_enc_commit3args(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    const struct nfs_commitargs *args)
+                                    const void *data)
 {
+       const struct nfs_commitargs *args = data;
+
        encode_commit3args(xdr, args);
 }
 
@@ -1319,8 +1353,10 @@ static void nfs3_xdr_enc_commit3args(struct rpc_rqst *req,
 
 static void nfs3_xdr_enc_getacl3args(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    const struct nfs3_getaclargs *args)
+                                    const void *data)
 {
+       const struct nfs3_getaclargs *args = data;
+
        encode_nfs_fh3(xdr, args->fh);
        encode_uint32(xdr, args->mask);
        if (args->mask & (NFS_ACL | NFS_DFACL))
@@ -1331,8 +1367,9 @@ static void nfs3_xdr_enc_getacl3args(struct rpc_rqst *req,
 
 static void nfs3_xdr_enc_setacl3args(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    const struct nfs3_setaclargs *args)
+                                    const void *data)
 {
+       const struct nfs3_setaclargs *args = data;
        unsigned int base;
        int error;
 
@@ -1382,7 +1419,7 @@ static void nfs3_xdr_enc_setacl3args(struct rpc_rqst *req,
  */
 static int nfs3_xdr_dec_getattr3res(struct rpc_rqst *req,
                                    struct xdr_stream *xdr,
-                                   struct nfs_fattr *result)
+                                   void *result)
 {
        enum nfs_stat status;
        int error;
@@ -1419,7 +1456,7 @@ out_default:
  */
 static int nfs3_xdr_dec_setattr3res(struct rpc_rqst *req,
                                    struct xdr_stream *xdr,
-                                   struct nfs_fattr *result)
+                                   void *result)
 {
        enum nfs_stat status;
        int error;
@@ -1460,8 +1497,9 @@ out_status:
  */
 static int nfs3_xdr_dec_lookup3res(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  struct nfs3_diropres *result)
+                                  void *data)
 {
+       struct nfs3_diropres *result = data;
        enum nfs_stat status;
        int error;
 
@@ -1507,8 +1545,9 @@ out_default:
  */
 static int nfs3_xdr_dec_access3res(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  struct nfs3_accessres *result)
+                                  void *data)
 {
+       struct nfs3_accessres *result = data;
        enum nfs_stat status;
        int error;
 
@@ -1548,7 +1587,7 @@ out_default:
  */
 static int nfs3_xdr_dec_readlink3res(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    struct nfs_fattr *result)
+                                    void *result)
 {
        enum nfs_stat status;
        int error;
@@ -1626,8 +1665,9 @@ out_overflow:
 }
 
 static int nfs3_xdr_dec_read3res(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                struct nfs_pgio_res *result)
+                                void *data)
 {
+       struct nfs_pgio_res *result = data;
        enum nfs_stat status;
        int error;
 
@@ -1699,8 +1739,9 @@ out_eio:
 }
 
 static int nfs3_xdr_dec_write3res(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                 struct nfs_pgio_res *result)
+                                 void *data)
 {
+       struct nfs_pgio_res *result = data;
        enum nfs_stat status;
        int error;
 
@@ -1764,8 +1805,9 @@ out:
 
 static int nfs3_xdr_dec_create3res(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  struct nfs3_diropres *result)
+                                  void *data)
 {
+       struct nfs3_diropres *result = data;
        enum nfs_stat status;
        int error;
 
@@ -1804,8 +1846,9 @@ out_default:
  */
 static int nfs3_xdr_dec_remove3res(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  struct nfs_removeres *result)
+                                  void *data)
 {
+       struct nfs_removeres *result = data;
        enum nfs_stat status;
        int error;
 
@@ -1845,8 +1888,9 @@ out_status:
  */
 static int nfs3_xdr_dec_rename3res(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  struct nfs_renameres *result)
+                                  void *data)
 {
+       struct nfs_renameres *result = data;
        enum nfs_stat status;
        int error;
 
@@ -1888,8 +1932,9 @@ out_status:
  *     };
  */
 static int nfs3_xdr_dec_link3res(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                struct nfs3_linkres *result)
+                                void *data)
 {
+       struct nfs3_linkres *result = data;
        enum nfs_stat status;
        int error;
 
@@ -2072,8 +2117,9 @@ out:
 
 static int nfs3_xdr_dec_readdir3res(struct rpc_rqst *req,
                                    struct xdr_stream *xdr,
-                                   struct nfs3_readdirres *result)
+                                   void *data)
 {
+       struct nfs3_readdirres *result = data;
        enum nfs_stat status;
        int error;
 
@@ -2140,8 +2186,9 @@ out_overflow:
 
 static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  struct nfs_fsstat *result)
+                                  void *data)
 {
+       struct nfs_fsstat *result = data;
        enum nfs_stat status;
        int error;
 
@@ -2216,8 +2263,9 @@ out_overflow:
 
 static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  struct nfs_fsinfo *result)
+                                  void *data)
 {
+       struct nfs_fsinfo *result = data;
        enum nfs_stat status;
        int error;
 
@@ -2279,8 +2327,9 @@ out_overflow:
 
 static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    struct nfs_pathconf *result)
+                                    void *data)
 {
+       struct nfs_pathconf *result = data;
        enum nfs_stat status;
        int error;
 
@@ -2320,8 +2369,9 @@ out_status:
  */
 static int nfs3_xdr_dec_commit3res(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  struct nfs_commitres *result)
+                                  void *data)
 {
+       struct nfs_commitres *result = data;
        enum nfs_stat status;
        int error;
 
@@ -2389,7 +2439,7 @@ out:
 
 static int nfs3_xdr_dec_getacl3res(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  struct nfs3_getaclres *result)
+                                  void *result)
 {
        enum nfs_stat status;
        int error;
@@ -2408,7 +2458,7 @@ out_default:
 
 static int nfs3_xdr_dec_setacl3res(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  struct nfs_fattr *result)
+                                  void *result)
 {
        enum nfs_stat status;
        int error;
@@ -2495,8 +2545,8 @@ static int nfs3_stat_to_errno(enum nfs_stat status)
 #define PROC(proc, argtype, restype, timer)                            \
 [NFS3PROC_##proc] = {                                                  \
        .p_proc      = NFS3PROC_##proc,                                 \
-       .p_encode    = (kxdreproc_t)nfs3_xdr_enc_##argtype##3args,      \
-       .p_decode    = (kxdrdproc_t)nfs3_xdr_dec_##restype##3res,       \
+       .p_encode    = nfs3_xdr_enc_##argtype##3args,                   \
+       .p_decode    = nfs3_xdr_dec_##restype##3res,                    \
        .p_arglen    = NFS3_##argtype##args_sz,                         \
        .p_replen    = NFS3_##restype##res_sz,                          \
        .p_timer     = timer,                                           \
@@ -2504,7 +2554,7 @@ static int nfs3_stat_to_errno(enum nfs_stat status)
        .p_name      = #proc,                                           \
        }
 
-struct rpc_procinfo    nfs3_procedures[] = {
+const struct rpc_procinfo nfs3_procedures[] = {
        PROC(GETATTR,           getattr,        getattr,        1),
        PROC(SETATTR,           setattr,        setattr,        0),
        PROC(LOOKUP,            lookup,         lookup,         2),
@@ -2528,18 +2578,20 @@ struct rpc_procinfo     nfs3_procedures[] = {
        PROC(COMMIT,            commit,         commit,         5),
 };
 
+static unsigned int nfs_version3_counts[ARRAY_SIZE(nfs3_procedures)];
 const struct rpc_version nfs_version3 = {
        .number                 = 3,
        .nrprocs                = ARRAY_SIZE(nfs3_procedures),
-       .procs                  = nfs3_procedures
+       .procs                  = nfs3_procedures,
+       .counts                 = nfs_version3_counts,
 };
 
 #ifdef CONFIG_NFS_V3_ACL
-static struct rpc_procinfo     nfs3_acl_procedures[] = {
+static const struct rpc_procinfo nfs3_acl_procedures[] = {
        [ACLPROC3_GETACL] = {
                .p_proc = ACLPROC3_GETACL,
-               .p_encode = (kxdreproc_t)nfs3_xdr_enc_getacl3args,
-               .p_decode = (kxdrdproc_t)nfs3_xdr_dec_getacl3res,
+               .p_encode = nfs3_xdr_enc_getacl3args,
+               .p_decode = nfs3_xdr_dec_getacl3res,
                .p_arglen = ACL3_getaclargs_sz,
                .p_replen = ACL3_getaclres_sz,
                .p_timer = 1,
@@ -2547,8 +2599,8 @@ static struct rpc_procinfo        nfs3_acl_procedures[] = {
        },
        [ACLPROC3_SETACL] = {
                .p_proc = ACLPROC3_SETACL,
-               .p_encode = (kxdreproc_t)nfs3_xdr_enc_setacl3args,
-               .p_decode = (kxdrdproc_t)nfs3_xdr_dec_setacl3res,
+               .p_encode = nfs3_xdr_enc_setacl3args,
+               .p_decode = nfs3_xdr_dec_setacl3res,
                .p_arglen = ACL3_setaclargs_sz,
                .p_replen = ACL3_setaclres_sz,
                .p_timer = 0,
@@ -2556,10 +2608,11 @@ static struct rpc_procinfo      nfs3_acl_procedures[] = {
        },
 };
 
+static unsigned int nfs3_acl_counts[ARRAY_SIZE(nfs3_acl_procedures)];
 const struct rpc_version nfsacl_version3 = {
        .number                 = 3,
-       .nrprocs                = sizeof(nfs3_acl_procedures)/
-                                 sizeof(nfs3_acl_procedures[0]),
+       .nrprocs                = ARRAY_SIZE(nfs3_acl_procedures),
        .procs                  = nfs3_acl_procedures,
+       .counts                 = nfs3_acl_counts,
 };
 #endif  /* CONFIG_NFS_V3_ACL */
index 528362f69cc1ba6156102b113fdd5ba18c566c71..5ee1b0f0d904490bb0a08478101ae49cd09acb57 100644 (file)
                                         decode_getattr_maxsz)
 
 static void encode_fallocate(struct xdr_stream *xdr,
-                            struct nfs42_falloc_args *args)
+                            const struct nfs42_falloc_args *args)
 {
        encode_nfs4_stateid(xdr, &args->falloc_stateid);
        encode_uint64(xdr, args->falloc_offset);
@@ -120,7 +120,7 @@ static void encode_fallocate(struct xdr_stream *xdr,
 }
 
 static void encode_allocate(struct xdr_stream *xdr,
-                           struct nfs42_falloc_args *args,
+                           const struct nfs42_falloc_args *args,
                            struct compound_hdr *hdr)
 {
        encode_op_hdr(xdr, OP_ALLOCATE, decode_allocate_maxsz, hdr);
@@ -128,7 +128,7 @@ static void encode_allocate(struct xdr_stream *xdr,
 }
 
 static void encode_copy(struct xdr_stream *xdr,
-                       struct nfs42_copy_args *args,
+                       const struct nfs42_copy_args *args,
                        struct compound_hdr *hdr)
 {
        encode_op_hdr(xdr, OP_COPY, decode_copy_maxsz, hdr);
@@ -145,7 +145,7 @@ static void encode_copy(struct xdr_stream *xdr,
 }
 
 static void encode_deallocate(struct xdr_stream *xdr,
-                             struct nfs42_falloc_args *args,
+                             const struct nfs42_falloc_args *args,
                              struct compound_hdr *hdr)
 {
        encode_op_hdr(xdr, OP_DEALLOCATE, decode_deallocate_maxsz, hdr);
@@ -153,7 +153,7 @@ static void encode_deallocate(struct xdr_stream *xdr,
 }
 
 static void encode_seek(struct xdr_stream *xdr,
-                       struct nfs42_seek_args *args,
+                       const struct nfs42_seek_args *args,
                        struct compound_hdr *hdr)
 {
        encode_op_hdr(xdr, OP_SEEK, decode_seek_maxsz, hdr);
@@ -163,7 +163,7 @@ static void encode_seek(struct xdr_stream *xdr,
 }
 
 static void encode_layoutstats(struct xdr_stream *xdr,
-                              struct nfs42_layoutstat_args *args,
+                              const struct nfs42_layoutstat_args *args,
                               struct nfs42_layoutstat_devinfo *devinfo,
                               struct compound_hdr *hdr)
 {
@@ -191,7 +191,7 @@ static void encode_layoutstats(struct xdr_stream *xdr,
 }
 
 static void encode_clone(struct xdr_stream *xdr,
-                        struct nfs42_clone_args *args,
+                        const struct nfs42_clone_args *args,
                         struct compound_hdr *hdr)
 {
        __be32 *p;
@@ -210,8 +210,9 @@ static void encode_clone(struct xdr_stream *xdr,
  */
 static void nfs4_xdr_enc_allocate(struct rpc_rqst *req,
                                  struct xdr_stream *xdr,
-                                 struct nfs42_falloc_args *args)
+                                 const void *data)
 {
+       const struct nfs42_falloc_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -225,7 +226,7 @@ static void nfs4_xdr_enc_allocate(struct rpc_rqst *req,
 }
 
 static void encode_copy_commit(struct xdr_stream *xdr,
-                         struct nfs42_copy_args *args,
+                         const struct nfs42_copy_args *args,
                          struct compound_hdr *hdr)
 {
        __be32 *p;
@@ -241,8 +242,9 @@ static void encode_copy_commit(struct xdr_stream *xdr,
  */
 static void nfs4_xdr_enc_copy(struct rpc_rqst *req,
                              struct xdr_stream *xdr,
-                             struct nfs42_copy_args *args)
+                             const void *data)
 {
+       const struct nfs42_copy_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -262,8 +264,9 @@ static void nfs4_xdr_enc_copy(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_deallocate(struct rpc_rqst *req,
                                    struct xdr_stream *xdr,
-                                   struct nfs42_falloc_args *args)
+                                   const void *data)
 {
+       const struct nfs42_falloc_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -281,8 +284,9 @@ static void nfs4_xdr_enc_deallocate(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_seek(struct rpc_rqst *req,
                              struct xdr_stream *xdr,
-                             struct nfs42_seek_args *args)
+                             const void *data)
 {
+       const struct nfs42_seek_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -299,8 +303,9 @@ static void nfs4_xdr_enc_seek(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_layoutstats(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    struct nfs42_layoutstat_args *args)
+                                    const void *data)
 {
+       const struct nfs42_layoutstat_args *args = data;
        int i;
 
        struct compound_hdr hdr = {
@@ -321,8 +326,9 @@ static void nfs4_xdr_enc_layoutstats(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_clone(struct rpc_rqst *req,
                               struct xdr_stream *xdr,
-                              struct nfs42_clone_args *args)
+                              const void *data)
 {
+       const struct nfs42_clone_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -448,8 +454,9 @@ static int decode_clone(struct xdr_stream *xdr)
  */
 static int nfs4_xdr_dec_allocate(struct rpc_rqst *rqstp,
                                 struct xdr_stream *xdr,
-                                struct nfs42_falloc_res *res)
+                                void *data)
 {
+       struct nfs42_falloc_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -475,8 +482,9 @@ out:
  */
 static int nfs4_xdr_dec_copy(struct rpc_rqst *rqstp,
                             struct xdr_stream *xdr,
-                            struct nfs42_copy_res *res)
+                            void *data)
 {
+       struct nfs42_copy_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -508,8 +516,9 @@ out:
  */
 static int nfs4_xdr_dec_deallocate(struct rpc_rqst *rqstp,
                                   struct xdr_stream *xdr,
-                                  struct nfs42_falloc_res *res)
+                                  void *data)
 {
+       struct nfs42_falloc_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -535,8 +544,9 @@ out:
  */
 static int nfs4_xdr_dec_seek(struct rpc_rqst *rqstp,
                             struct xdr_stream *xdr,
-                            struct nfs42_seek_res *res)
+                            void *data)
 {
+       struct nfs42_seek_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -559,8 +569,9 @@ out:
  */
 static int nfs4_xdr_dec_layoutstats(struct rpc_rqst *rqstp,
                                    struct xdr_stream *xdr,
-                                   struct nfs42_layoutstat_res *res)
+                                   void *data)
 {
+       struct nfs42_layoutstat_res *res = data;
        struct compound_hdr hdr;
        int status, i;
 
@@ -589,8 +600,9 @@ out:
  */
 static int nfs4_xdr_dec_clone(struct rpc_rqst *rqstp,
                              struct xdr_stream *xdr,
-                             struct nfs42_clone_res *res)
+                             void *data)
 {
+       struct nfs42_clone_res *res = data;
        struct compound_hdr hdr;
        int status;
 
index af285cc27ccf8c8457dee080cccbf75df77f0fcb..40bd05f05e743f01228d09b7d9d23d8fbe7bb213 100644 (file)
@@ -493,13 +493,13 @@ static inline void nfs4_unregister_sysctl(void)
 #endif
 
 /* nfs4xdr.c */
-extern struct rpc_procinfo nfs4_procedures[];
+extern const struct rpc_procinfo nfs4_procedures[];
 
 struct nfs4_mount_data;
 
 /* callback_xdr.c */
-extern struct svc_version nfs4_callback_version1;
-extern struct svc_version nfs4_callback_version4;
+extern const struct svc_version nfs4_callback_version1;
+extern const struct svc_version nfs4_callback_version4;
 
 static inline void nfs4_stateid_copy(nfs4_stateid *dst, const nfs4_stateid *src)
 {
index 3aebfdc82b30320625b0011b4f968207e436fb48..0f1f290c97cd0fb6e4b7e9258321deb7c67d4f65 100644 (file)
@@ -1651,7 +1651,8 @@ encode_restorefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
 }
 
 static void
-encode_setacl(struct xdr_stream *xdr, struct nfs_setaclargs *arg, struct compound_hdr *hdr)
+encode_setacl(struct xdr_stream *xdr, const struct nfs_setaclargs *arg,
+               struct compound_hdr *hdr)
 {
        __be32 *p;
 
@@ -1735,7 +1736,7 @@ static void encode_secinfo(struct xdr_stream *xdr, const struct qstr *name, stru
 #if defined(CONFIG_NFS_V4_1)
 /* NFSv4.1 operations */
 static void encode_bind_conn_to_session(struct xdr_stream *xdr,
-                                  struct nfs41_bind_conn_to_session_args *args,
+                                  const struct nfs41_bind_conn_to_session_args *args,
                                   struct compound_hdr *hdr)
 {
        __be32 *p;
@@ -1748,7 +1749,7 @@ static void encode_bind_conn_to_session(struct xdr_stream *xdr,
        *p = (args->use_conn_in_rdma_mode) ? cpu_to_be32(1) : cpu_to_be32(0);
 }
 
-static void encode_op_map(struct xdr_stream *xdr, struct nfs4_op_map *op_map)
+static void encode_op_map(struct xdr_stream *xdr, const struct nfs4_op_map *op_map)
 {
        unsigned int i;
        encode_uint32(xdr, NFS4_OP_MAP_NUM_WORDS);
@@ -1757,7 +1758,7 @@ static void encode_op_map(struct xdr_stream *xdr, struct nfs4_op_map *op_map)
 }
 
 static void encode_exchange_id(struct xdr_stream *xdr,
-                              struct nfs41_exchange_id_args *args,
+                              const struct nfs41_exchange_id_args *args,
                               struct compound_hdr *hdr)
 {
        __be32 *p;
@@ -1809,7 +1810,7 @@ static void encode_exchange_id(struct xdr_stream *xdr,
 }
 
 static void encode_create_session(struct xdr_stream *xdr,
-                                 struct nfs41_create_session_args *args,
+                                 const struct nfs41_create_session_args *args,
                                  struct compound_hdr *hdr)
 {
        __be32 *p;
@@ -1862,7 +1863,7 @@ static void encode_create_session(struct xdr_stream *xdr,
 }
 
 static void encode_destroy_session(struct xdr_stream *xdr,
-                                  struct nfs4_session *session,
+                                  const struct nfs4_session *session,
                                   struct compound_hdr *hdr)
 {
        encode_op_hdr(xdr, OP_DESTROY_SESSION, decode_destroy_session_maxsz, hdr);
@@ -1878,7 +1879,7 @@ static void encode_destroy_clientid(struct xdr_stream *xdr,
 }
 
 static void encode_reclaim_complete(struct xdr_stream *xdr,
-                                   struct nfs41_reclaim_complete_args *args,
+                                   const struct nfs41_reclaim_complete_args *args,
                                    struct compound_hdr *hdr)
 {
        encode_op_hdr(xdr, OP_RECLAIM_COMPLETE, decode_reclaim_complete_maxsz, hdr);
@@ -1974,7 +1975,7 @@ encode_layoutget(struct xdr_stream *xdr,
 static int
 encode_layoutcommit(struct xdr_stream *xdr,
                    struct inode *inode,
-                   struct nfs4_layoutcommit_args *args,
+                   const struct nfs4_layoutcommit_args *args,
                    struct compound_hdr *hdr)
 {
        __be32 *p;
@@ -2044,7 +2045,7 @@ encode_secinfo_no_name(struct xdr_stream *xdr,
 }
 
 static void encode_test_stateid(struct xdr_stream *xdr,
-                               struct nfs41_test_stateid_args *args,
+                               const struct nfs41_test_stateid_args *args,
                                struct compound_hdr *hdr)
 {
        encode_op_hdr(xdr, OP_TEST_STATEID, decode_test_stateid_maxsz, hdr);
@@ -2053,7 +2054,7 @@ static void encode_test_stateid(struct xdr_stream *xdr,
 }
 
 static void encode_free_stateid(struct xdr_stream *xdr,
-                               struct nfs41_free_stateid_args *args,
+                               const struct nfs41_free_stateid_args *args,
                                struct compound_hdr *hdr)
 {
        encode_op_hdr(xdr, OP_FREE_STATEID, decode_free_stateid_maxsz, hdr);
@@ -2086,8 +2087,9 @@ static u32 nfs4_xdr_minorversion(const struct nfs4_sequence_args *args)
  * Encode an ACCESS request
  */
 static void nfs4_xdr_enc_access(struct rpc_rqst *req, struct xdr_stream *xdr,
-                               const struct nfs4_accessargs *args)
+                               const void *data)
 {
+       const struct nfs4_accessargs *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2104,8 +2106,9 @@ static void nfs4_xdr_enc_access(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Encode LOOKUP request
  */
 static void nfs4_xdr_enc_lookup(struct rpc_rqst *req, struct xdr_stream *xdr,
-                               const struct nfs4_lookup_arg *args)
+                               const void *data)
 {
+       const struct nfs4_lookup_arg *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2124,8 +2127,9 @@ static void nfs4_xdr_enc_lookup(struct rpc_rqst *req, struct xdr_stream *xdr,
  */
 static void nfs4_xdr_enc_lookup_root(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    const struct nfs4_lookup_root_arg *args)
+                                    const void *data)
 {
+       const struct nfs4_lookup_root_arg *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2142,8 +2146,9 @@ static void nfs4_xdr_enc_lookup_root(struct rpc_rqst *req,
  * Encode REMOVE request
  */
 static void nfs4_xdr_enc_remove(struct rpc_rqst *req, struct xdr_stream *xdr,
-                               const struct nfs_removeargs *args)
+                               const void *data)
 {
+       const struct nfs_removeargs *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2159,8 +2164,9 @@ static void nfs4_xdr_enc_remove(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Encode RENAME request
  */
 static void nfs4_xdr_enc_rename(struct rpc_rqst *req, struct xdr_stream *xdr,
-                               const struct nfs_renameargs *args)
+                               const void *data)
 {
+       const struct nfs_renameargs *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2178,8 +2184,9 @@ static void nfs4_xdr_enc_rename(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Encode LINK request
  */
 static void nfs4_xdr_enc_link(struct rpc_rqst *req, struct xdr_stream *xdr,
-                            const struct nfs4_link_arg *args)
+                             const void *data)
 {
+       const struct nfs4_link_arg *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2199,8 +2206,9 @@ static void nfs4_xdr_enc_link(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Encode CREATE request
  */
 static void nfs4_xdr_enc_create(struct rpc_rqst *req, struct xdr_stream *xdr,
-                               const struct nfs4_create_arg *args)
+                               const void *data)
 {
+       const struct nfs4_create_arg *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2218,8 +2226,10 @@ static void nfs4_xdr_enc_create(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Encode SYMLINK request
  */
 static void nfs4_xdr_enc_symlink(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                const struct nfs4_create_arg *args)
+                                const void *data)
 {
+       const struct nfs4_create_arg *args = data;
+
        nfs4_xdr_enc_create(req, xdr, args);
 }
 
@@ -2227,8 +2237,9 @@ static void nfs4_xdr_enc_symlink(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Encode GETATTR request
  */
 static void nfs4_xdr_enc_getattr(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                const struct nfs4_getattr_arg *args)
+                                const void *data)
 {
+       const struct nfs4_getattr_arg *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2244,8 +2255,9 @@ static void nfs4_xdr_enc_getattr(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Encode a CLOSE request
  */
 static void nfs4_xdr_enc_close(struct rpc_rqst *req, struct xdr_stream *xdr,
-                              struct nfs_closeargs *args)
+                              const void *data)
 {
+       const struct nfs_closeargs *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2265,8 +2277,9 @@ static void nfs4_xdr_enc_close(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Encode an OPEN request
  */
 static void nfs4_xdr_enc_open(struct rpc_rqst *req, struct xdr_stream *xdr,
-                             struct nfs_openargs *args)
+                             const void *data)
 {
+       const struct nfs_openargs *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2287,8 +2300,9 @@ static void nfs4_xdr_enc_open(struct rpc_rqst *req, struct xdr_stream *xdr,
  */
 static void nfs4_xdr_enc_open_confirm(struct rpc_rqst *req,
                                      struct xdr_stream *xdr,
-                                     struct nfs_open_confirmargs *args)
+                                     const void *data)
 {
+       const struct nfs_open_confirmargs *args = data;
        struct compound_hdr hdr = {
                .nops   = 0,
        };
@@ -2304,8 +2318,9 @@ static void nfs4_xdr_enc_open_confirm(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_open_noattr(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    struct nfs_openargs *args)
+                                    const void *data)
 {
+       const struct nfs_openargs *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2325,8 +2340,9 @@ static void nfs4_xdr_enc_open_noattr(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_open_downgrade(struct rpc_rqst *req,
                                        struct xdr_stream *xdr,
-                                       struct nfs_closeargs *args)
+                                       const void *data)
 {
+       const struct nfs_closeargs *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2344,8 +2360,9 @@ static void nfs4_xdr_enc_open_downgrade(struct rpc_rqst *req,
  * Encode a LOCK request
  */
 static void nfs4_xdr_enc_lock(struct rpc_rqst *req, struct xdr_stream *xdr,
-                             struct nfs_lock_args *args)
+                             const void *data)
 {
+       const struct nfs_lock_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2361,8 +2378,9 @@ static void nfs4_xdr_enc_lock(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Encode a LOCKT request
  */
 static void nfs4_xdr_enc_lockt(struct rpc_rqst *req, struct xdr_stream *xdr,
-                              struct nfs_lockt_args *args)
+                              const void *data)
 {
+       const struct nfs_lockt_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2378,8 +2396,9 @@ static void nfs4_xdr_enc_lockt(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Encode a LOCKU request
  */
 static void nfs4_xdr_enc_locku(struct rpc_rqst *req, struct xdr_stream *xdr,
-                              struct nfs_locku_args *args)
+                              const void *data)
 {
+       const struct nfs_locku_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2393,8 +2412,9 @@ static void nfs4_xdr_enc_locku(struct rpc_rqst *req, struct xdr_stream *xdr,
 
 static void nfs4_xdr_enc_release_lockowner(struct rpc_rqst *req,
                                           struct xdr_stream *xdr,
-                                       struct nfs_release_lockowner_args *args)
+                                          const void *data)
 {
+       const struct nfs_release_lockowner_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = 0,
        };
@@ -2408,8 +2428,9 @@ static void nfs4_xdr_enc_release_lockowner(struct rpc_rqst *req,
  * Encode a READLINK request
  */
 static void nfs4_xdr_enc_readlink(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                 const struct nfs4_readlink *args)
+                                 const void *data)
 {
+       const struct nfs4_readlink *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2428,8 +2449,9 @@ static void nfs4_xdr_enc_readlink(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Encode a READDIR request
  */
 static void nfs4_xdr_enc_readdir(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                const struct nfs4_readdir_arg *args)
+                                const void *data)
 {
+       const struct nfs4_readdir_arg *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2451,8 +2473,9 @@ static void nfs4_xdr_enc_readdir(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Encode a READ request
  */
 static void nfs4_xdr_enc_read(struct rpc_rqst *req, struct xdr_stream *xdr,
-                             struct nfs_pgio_args *args)
+                             const void *data)
 {
+       const struct nfs_pgio_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2472,8 +2495,9 @@ static void nfs4_xdr_enc_read(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Encode an SETATTR request
  */
 static void nfs4_xdr_enc_setattr(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                struct nfs_setattrargs *args)
+                                const void *data)
 {
+       const struct nfs_setattrargs *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2490,8 +2514,9 @@ static void nfs4_xdr_enc_setattr(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Encode a GETACL request
  */
 static void nfs4_xdr_enc_getacl(struct rpc_rqst *req, struct xdr_stream *xdr,
-                               struct nfs_getaclargs *args)
+                               const void *data)
 {
+       const struct nfs_getaclargs *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2513,8 +2538,9 @@ static void nfs4_xdr_enc_getacl(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Encode a WRITE request
  */
 static void nfs4_xdr_enc_write(struct rpc_rqst *req, struct xdr_stream *xdr,
-                              struct nfs_pgio_args *args)
+                              const void *data)
 {
+       const struct nfs_pgio_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2533,8 +2559,9 @@ static void nfs4_xdr_enc_write(struct rpc_rqst *req, struct xdr_stream *xdr,
  *  a COMMIT request
  */
 static void nfs4_xdr_enc_commit(struct rpc_rqst *req, struct xdr_stream *xdr,
-                               struct nfs_commitargs *args)
+                               const void *data)
 {
+       const struct nfs_commitargs *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2550,8 +2577,9 @@ static void nfs4_xdr_enc_commit(struct rpc_rqst *req, struct xdr_stream *xdr,
  * FSINFO request
  */
 static void nfs4_xdr_enc_fsinfo(struct rpc_rqst *req, struct xdr_stream *xdr,
-                               struct nfs4_fsinfo_arg *args)
+                               const void *data)
 {
+       const struct nfs4_fsinfo_arg *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2567,8 +2595,9 @@ static void nfs4_xdr_enc_fsinfo(struct rpc_rqst *req, struct xdr_stream *xdr,
  * a PATHCONF request
  */
 static void nfs4_xdr_enc_pathconf(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                 const struct nfs4_pathconf_arg *args)
+                                 const void *data)
 {
+       const struct nfs4_pathconf_arg *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2585,8 +2614,9 @@ static void nfs4_xdr_enc_pathconf(struct rpc_rqst *req, struct xdr_stream *xdr,
  * a STATFS request
  */
 static void nfs4_xdr_enc_statfs(struct rpc_rqst *req, struct xdr_stream *xdr,
-                               const struct nfs4_statfs_arg *args)
+                               const void *data)
 {
+       const struct nfs4_statfs_arg *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2604,8 +2634,9 @@ static void nfs4_xdr_enc_statfs(struct rpc_rqst *req, struct xdr_stream *xdr,
  */
 static void nfs4_xdr_enc_server_caps(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    struct nfs4_server_caps_arg *args)
+                                    const void *data)
 {
+       const struct nfs4_server_caps_arg *args = data;
        const u32 *bitmask = args->bitmask;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
@@ -2622,8 +2653,10 @@ static void nfs4_xdr_enc_server_caps(struct rpc_rqst *req,
  * a RENEW request
  */
 static void nfs4_xdr_enc_renew(struct rpc_rqst *req, struct xdr_stream *xdr,
-                              struct nfs_client *clp)
+                              const void *data)
+
 {
+       const struct nfs_client *clp = data;
        struct compound_hdr hdr = {
                .nops   = 0,
        };
@@ -2638,8 +2671,9 @@ static void nfs4_xdr_enc_renew(struct rpc_rqst *req, struct xdr_stream *xdr,
  */
 static void nfs4_xdr_enc_setclientid(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    struct nfs4_setclientid *sc)
+                                    const void *data)
 {
+       const struct nfs4_setclientid *sc = data;
        struct compound_hdr hdr = {
                .nops   = 0,
        };
@@ -2654,8 +2688,9 @@ static void nfs4_xdr_enc_setclientid(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_setclientid_confirm(struct rpc_rqst *req,
                                             struct xdr_stream *xdr,
-                                            struct nfs4_setclientid_res *arg)
+                                            const void *data)
 {
+       const struct nfs4_setclientid_res *arg = data;
        struct compound_hdr hdr = {
                .nops   = 0,
        };
@@ -2670,8 +2705,9 @@ static void nfs4_xdr_enc_setclientid_confirm(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_delegreturn(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    const struct nfs4_delegreturnargs *args)
+                                    const void *data)
 {
+       const struct nfs4_delegreturnargs *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2692,8 +2728,9 @@ static void nfs4_xdr_enc_delegreturn(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_fs_locations(struct rpc_rqst *req,
                                      struct xdr_stream *xdr,
-                                     struct nfs4_fs_locations_arg *args)
+                                     const void *data)
 {
+       const struct nfs4_fs_locations_arg *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2715,8 +2752,8 @@ static void nfs4_xdr_enc_fs_locations(struct rpc_rqst *req,
        }
 
        /* Set up reply kvec to capture returned fs_locations array. */
-       xdr_inline_pages(&req->rq_rcv_buf, replen << 2, &args->page,
-                       0, PAGE_SIZE);
+       xdr_inline_pages(&req->rq_rcv_buf, replen << 2,
+                        (struct page **)&args->page, 0, PAGE_SIZE);
        encode_nops(&hdr);
 }
 
@@ -2725,8 +2762,9 @@ static void nfs4_xdr_enc_fs_locations(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_secinfo(struct rpc_rqst *req,
                                struct xdr_stream *xdr,
-                               struct nfs4_secinfo_arg *args)
+                               const void *data)
 {
+       const struct nfs4_secinfo_arg *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2743,8 +2781,9 @@ static void nfs4_xdr_enc_secinfo(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_fsid_present(struct rpc_rqst *req,
                                      struct xdr_stream *xdr,
-                                     struct nfs4_fsid_present_arg *args)
+                                     const void *data)
 {
+       const struct nfs4_fsid_present_arg *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2764,8 +2803,9 @@ static void nfs4_xdr_enc_fsid_present(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_bind_conn_to_session(struct rpc_rqst *req,
                                struct xdr_stream *xdr,
-                               struct nfs41_bind_conn_to_session_args *args)
+                               const void *data)
 {
+       const struct nfs41_bind_conn_to_session_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = args->client->cl_mvops->minor_version,
        };
@@ -2780,8 +2820,9 @@ static void nfs4_xdr_enc_bind_conn_to_session(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_exchange_id(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    struct nfs41_exchange_id_args *args)
+                                    const void *data)
 {
+       const struct nfs41_exchange_id_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = args->client->cl_mvops->minor_version,
        };
@@ -2796,8 +2837,9 @@ static void nfs4_xdr_enc_exchange_id(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_create_session(struct rpc_rqst *req,
                                        struct xdr_stream *xdr,
-                                       struct nfs41_create_session_args *args)
+                                       const void *data)
 {
+       const struct nfs41_create_session_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = args->client->cl_mvops->minor_version,
        };
@@ -2812,8 +2854,9 @@ static void nfs4_xdr_enc_create_session(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_destroy_session(struct rpc_rqst *req,
                                         struct xdr_stream *xdr,
-                                        struct nfs4_session *session)
+                                        const void *data)
 {
+       const struct nfs4_session *session = data;
        struct compound_hdr hdr = {
                .minorversion = session->clp->cl_mvops->minor_version,
        };
@@ -2828,8 +2871,9 @@ static void nfs4_xdr_enc_destroy_session(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_destroy_clientid(struct rpc_rqst *req,
                                         struct xdr_stream *xdr,
-                                        struct nfs_client *clp)
+                                        const void *data)
 {
+       const struct nfs_client *clp = data;
        struct compound_hdr hdr = {
                .minorversion = clp->cl_mvops->minor_version,
        };
@@ -2843,8 +2887,9 @@ static void nfs4_xdr_enc_destroy_clientid(struct rpc_rqst *req,
  * a SEQUENCE request
  */
 static void nfs4_xdr_enc_sequence(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                 struct nfs4_sequence_args *args)
+                                 const void *data)
 {
+       const struct nfs4_sequence_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(args),
        };
@@ -2859,8 +2904,9 @@ static void nfs4_xdr_enc_sequence(struct rpc_rqst *req, struct xdr_stream *xdr,
  */
 static void nfs4_xdr_enc_get_lease_time(struct rpc_rqst *req,
                                        struct xdr_stream *xdr,
-                                       struct nfs4_get_lease_time_args *args)
+                                       const void *data)
 {
+       const struct nfs4_get_lease_time_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->la_seq_args),
        };
@@ -2878,8 +2924,9 @@ static void nfs4_xdr_enc_get_lease_time(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_reclaim_complete(struct rpc_rqst *req,
                                          struct xdr_stream *xdr,
-                               struct nfs41_reclaim_complete_args *args)
+                                         const void *data)
 {
+       const struct nfs41_reclaim_complete_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args)
        };
@@ -2895,8 +2942,9 @@ static void nfs4_xdr_enc_reclaim_complete(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_getdeviceinfo(struct rpc_rqst *req,
                                       struct xdr_stream *xdr,
-                                      struct nfs4_getdeviceinfo_args *args)
+                                      const void *data)
 {
+       const struct nfs4_getdeviceinfo_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2919,8 +2967,9 @@ static void nfs4_xdr_enc_getdeviceinfo(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_layoutget(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  struct nfs4_layoutget_args *args)
+                                  const void *data)
 {
+       const struct nfs4_layoutget_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2941,8 +2990,9 @@ static void nfs4_xdr_enc_layoutget(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_layoutcommit(struct rpc_rqst *req,
                                      struct xdr_stream *xdr,
-                                     struct nfs4_layoutcommit_args *args)
+                                     const void *priv)
 {
+       const struct nfs4_layoutcommit_args *args = priv;
        struct nfs4_layoutcommit_data *data =
                container_of(args, struct nfs4_layoutcommit_data, args);
        struct compound_hdr hdr = {
@@ -2962,8 +3012,9 @@ static void nfs4_xdr_enc_layoutcommit(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_layoutreturn(struct rpc_rqst *req,
                                      struct xdr_stream *xdr,
-                                     struct nfs4_layoutreturn_args *args)
+                                     const void *data)
 {
+       const struct nfs4_layoutreturn_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2978,10 +3029,11 @@ static void nfs4_xdr_enc_layoutreturn(struct rpc_rqst *req,
 /*
  * Encode SECINFO_NO_NAME request
  */
-static int nfs4_xdr_enc_secinfo_no_name(struct rpc_rqst *req,
+static void nfs4_xdr_enc_secinfo_no_name(struct rpc_rqst *req,
                                        struct xdr_stream *xdr,
-                                       struct nfs41_secinfo_no_name_args *args)
+                                       const void *data)
 {
+       const struct nfs41_secinfo_no_name_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -2991,7 +3043,6 @@ static int nfs4_xdr_enc_secinfo_no_name(struct rpc_rqst *req,
        encode_putrootfh(xdr, &hdr);
        encode_secinfo_no_name(xdr, args, &hdr);
        encode_nops(&hdr);
-       return 0;
 }
 
 /*
@@ -2999,8 +3050,9 @@ static int nfs4_xdr_enc_secinfo_no_name(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_test_stateid(struct rpc_rqst *req,
                                      struct xdr_stream *xdr,
-                                     struct nfs41_test_stateid_args *args)
+                                     const void *data)
 {
+       const struct nfs41_test_stateid_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -3016,8 +3068,9 @@ static void nfs4_xdr_enc_test_stateid(struct rpc_rqst *req,
  */
 static void nfs4_xdr_enc_free_stateid(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    struct nfs41_free_stateid_args *args)
+                                    const void *data)
 {
+       const struct nfs41_free_stateid_args *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -6101,8 +6154,9 @@ int decode_layoutreturn(struct xdr_stream *xdr,
  */
 static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst *rqstp,
                                       struct xdr_stream *xdr,
-                                      struct nfs_closeres *res)
+                                      void *data)
 {
+       struct nfs_closeres *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6130,8 +6184,9 @@ out:
  * Decode ACCESS response
  */
 static int nfs4_xdr_dec_access(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                              struct nfs4_accessres *res)
+                              void *data)
 {
+       struct nfs4_accessres *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6156,8 +6211,9 @@ out:
  * Decode LOOKUP response
  */
 static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                              struct nfs4_lookup_res *res)
+                              void *data)
 {
+       struct nfs4_lookup_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6186,8 +6242,9 @@ out:
  */
 static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp,
                                    struct xdr_stream *xdr,
-                                   struct nfs4_lookup_res *res)
+                                   void *data)
 {
+       struct nfs4_lookup_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6212,8 +6269,9 @@ out:
  * Decode REMOVE response
  */
 static int nfs4_xdr_dec_remove(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                              struct nfs_removeres *res)
+                              void *data)
 {
+       struct nfs_removeres *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6235,8 +6293,9 @@ out:
  * Decode RENAME response
  */
 static int nfs4_xdr_dec_rename(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                              struct nfs_renameres *res)
+                              void *data)
 {
+       struct nfs_renameres *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6264,8 +6323,9 @@ out:
  * Decode LINK response
  */
 static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                            struct nfs4_link_res *res)
+                            void *data)
 {
+       struct nfs4_link_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6303,8 +6363,9 @@ out:
  * Decode CREATE response
  */
 static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                              struct nfs4_create_res *res)
+                              void *data)
 {
+       struct nfs4_create_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6332,7 +6393,7 @@ out:
  * Decode SYMLINK response
  */
 static int nfs4_xdr_dec_symlink(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                               struct nfs4_create_res *res)
+                               void *res)
 {
        return nfs4_xdr_dec_create(rqstp, xdr, res);
 }
@@ -6341,8 +6402,9 @@ static int nfs4_xdr_dec_symlink(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
  * Decode GETATTR response
  */
 static int nfs4_xdr_dec_getattr(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                               struct nfs4_getattr_res *res)
+                               void *data)
 {
+       struct nfs4_getattr_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6364,8 +6426,9 @@ out:
  * Encode an SETACL request
  */
 static void nfs4_xdr_enc_setacl(struct rpc_rqst *req, struct xdr_stream *xdr,
-                               struct nfs_setaclargs *args)
+                               const void *data)
 {
+       const struct nfs_setaclargs *args = data;
        struct compound_hdr hdr = {
                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
        };
@@ -6382,8 +6445,9 @@ static void nfs4_xdr_enc_setacl(struct rpc_rqst *req, struct xdr_stream *xdr,
  */
 static int
 nfs4_xdr_dec_setacl(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                   struct nfs_setaclres *res)
+                   void *data)
 {
+       struct nfs_setaclres *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6406,8 +6470,9 @@ out:
  */
 static int
 nfs4_xdr_dec_getacl(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                   struct nfs_getaclres *res)
+                   void *data)
 {
+       struct nfs_getaclres *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6434,8 +6499,9 @@ out:
  * Decode CLOSE response
  */
 static int nfs4_xdr_dec_close(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                             struct nfs_closeres *res)
+                             void *data)
 {
+       struct nfs_closeres *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6468,8 +6534,9 @@ out:
  * Decode OPEN response
  */
 static int nfs4_xdr_dec_open(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                            struct nfs_openres *res)
+                            void *data)
 {
+       struct nfs_openres *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6500,8 +6567,9 @@ out:
  */
 static int nfs4_xdr_dec_open_confirm(struct rpc_rqst *rqstp,
                                     struct xdr_stream *xdr,
-                                    struct nfs_open_confirmres *res)
+                                    void *data)
 {
+       struct nfs_open_confirmres *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6521,8 +6589,9 @@ out:
  */
 static int nfs4_xdr_dec_open_noattr(struct rpc_rqst *rqstp,
                                    struct xdr_stream *xdr,
-                                   struct nfs_openres *res)
+                                   void *data)
 {
+       struct nfs_openres *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6550,8 +6619,9 @@ out:
  */
 static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp,
                                struct xdr_stream *xdr,
-                               struct nfs_setattrres *res)
+                               void *data)
 {
+       struct nfs_setattrres *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6576,8 +6646,9 @@ out:
  * Decode LOCK response
  */
 static int nfs4_xdr_dec_lock(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                            struct nfs_lock_res *res)
+                            void *data)
 {
+       struct nfs_lock_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6599,8 +6670,9 @@ out:
  * Decode LOCKT response
  */
 static int nfs4_xdr_dec_lockt(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                             struct nfs_lockt_res *res)
+                             void *data)
 {
+       struct nfs_lockt_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6622,8 +6694,9 @@ out:
  * Decode LOCKU response
  */
 static int nfs4_xdr_dec_locku(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                             struct nfs_locku_res *res)
+                             void *data)
 {
+       struct nfs_locku_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6658,8 +6731,9 @@ static int nfs4_xdr_dec_release_lockowner(struct rpc_rqst *rqstp,
  */
 static int nfs4_xdr_dec_readlink(struct rpc_rqst *rqstp,
                                 struct xdr_stream *xdr,
-                                struct nfs4_readlink_res *res)
+                                void *data)
 {
+       struct nfs4_readlink_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6681,8 +6755,9 @@ out:
  * Decode READDIR response
  */
 static int nfs4_xdr_dec_readdir(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                               struct nfs4_readdir_res *res)
+                               void *data)
 {
+       struct nfs4_readdir_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6704,8 +6779,9 @@ out:
  * Decode Read response
  */
 static int nfs4_xdr_dec_read(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                            struct nfs_pgio_res *res)
+                            void *data)
 {
+       struct nfs_pgio_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6730,8 +6806,9 @@ out:
  * Decode WRITE response
  */
 static int nfs4_xdr_dec_write(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                             struct nfs_pgio_res *res)
+                             void *data)
 {
+       struct nfs_pgio_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6760,8 +6837,9 @@ out:
  * Decode COMMIT response
  */
 static int nfs4_xdr_dec_commit(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
-                              struct nfs_commitres *res)
+                              void *data)
 {
+       struct nfs_commitres *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6784,8 +6862,9 @@ out:
  * Decode FSINFO response
  */
 static int nfs4_xdr_dec_fsinfo(struct rpc_rqst *req, struct xdr_stream *xdr,
-                              struct nfs4_fsinfo_res *res)
+                              void *data)
 {
+       struct nfs4_fsinfo_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6803,8 +6882,9 @@ static int nfs4_xdr_dec_fsinfo(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Decode PATHCONF response
  */
 static int nfs4_xdr_dec_pathconf(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                struct nfs4_pathconf_res *res)
+                                void *data)
 {
+       struct nfs4_pathconf_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6822,8 +6902,9 @@ static int nfs4_xdr_dec_pathconf(struct rpc_rqst *req, struct xdr_stream *xdr,
  * Decode STATFS response
  */
 static int nfs4_xdr_dec_statfs(struct rpc_rqst *req, struct xdr_stream *xdr,
-                              struct nfs4_statfs_res *res)
+                              void *data)
 {
+       struct nfs4_statfs_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6842,8 +6923,9 @@ static int nfs4_xdr_dec_statfs(struct rpc_rqst *req, struct xdr_stream *xdr,
  */
 static int nfs4_xdr_dec_server_caps(struct rpc_rqst *req,
                                    struct xdr_stream *xdr,
-                                   struct nfs4_server_caps_res *res)
+                                   void *data)
 {
+       struct nfs4_server_caps_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6881,8 +6963,9 @@ static int nfs4_xdr_dec_renew(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
  */
 static int nfs4_xdr_dec_setclientid(struct rpc_rqst *req,
                                    struct xdr_stream *xdr,
-                                   struct nfs4_setclientid_res *res)
+                                   void *data)
 {
+       struct nfs4_setclientid_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6896,7 +6979,8 @@ static int nfs4_xdr_dec_setclientid(struct rpc_rqst *req,
  * Decode SETCLIENTID_CONFIRM response
  */
 static int nfs4_xdr_dec_setclientid_confirm(struct rpc_rqst *req,
-                                           struct xdr_stream *xdr)
+                                           struct xdr_stream *xdr,
+                                           void *data)
 {
        struct compound_hdr hdr;
        int status;
@@ -6912,8 +6996,9 @@ static int nfs4_xdr_dec_setclientid_confirm(struct rpc_rqst *req,
  */
 static int nfs4_xdr_dec_delegreturn(struct rpc_rqst *rqstp,
                                    struct xdr_stream *xdr,
-                                   struct nfs4_delegreturnres *res)
+                                   void *data)
 {
+       struct nfs4_delegreturnres *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6947,8 +7032,9 @@ out:
  */
 static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req,
                                     struct xdr_stream *xdr,
-                                    struct nfs4_fs_locations_res *res)
+                                    void *data)
 {
+       struct nfs4_fs_locations_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -6990,8 +7076,9 @@ out:
  */
 static int nfs4_xdr_dec_secinfo(struct rpc_rqst *rqstp,
                                struct xdr_stream *xdr,
-                               struct nfs4_secinfo_res *res)
+                               void *data)
 {
+       struct nfs4_secinfo_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -7014,8 +7101,9 @@ out:
  */
 static int nfs4_xdr_dec_fsid_present(struct rpc_rqst *rqstp,
                                     struct xdr_stream *xdr,
-                                    struct nfs4_fsid_present_res *res)
+                                    void *data)
 {
+       struct nfs4_fsid_present_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -7075,7 +7163,7 @@ static int nfs4_xdr_dec_exchange_id(struct rpc_rqst *rqstp,
  */
 static int nfs4_xdr_dec_create_session(struct rpc_rqst *rqstp,
                                       struct xdr_stream *xdr,
-                                      struct nfs41_create_session_res *res)
+                                      void *res)
 {
        struct compound_hdr hdr;
        int status;
@@ -7123,7 +7211,7 @@ static int nfs4_xdr_dec_destroy_clientid(struct rpc_rqst *rqstp,
  */
 static int nfs4_xdr_dec_sequence(struct rpc_rqst *rqstp,
                                 struct xdr_stream *xdr,
-                                struct nfs4_sequence_res *res)
+                                void *res)
 {
        struct compound_hdr hdr;
        int status;
@@ -7139,8 +7227,9 @@ static int nfs4_xdr_dec_sequence(struct rpc_rqst *rqstp,
  */
 static int nfs4_xdr_dec_get_lease_time(struct rpc_rqst *rqstp,
                                       struct xdr_stream *xdr,
-                                      struct nfs4_get_lease_time_res *res)
+                                      void *data)
 {
+       struct nfs4_get_lease_time_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -7159,8 +7248,9 @@ static int nfs4_xdr_dec_get_lease_time(struct rpc_rqst *rqstp,
  */
 static int nfs4_xdr_dec_reclaim_complete(struct rpc_rqst *rqstp,
                                         struct xdr_stream *xdr,
-                                        struct nfs41_reclaim_complete_res *res)
+                                        void *data)
 {
+       struct nfs41_reclaim_complete_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -7177,8 +7267,9 @@ static int nfs4_xdr_dec_reclaim_complete(struct rpc_rqst *rqstp,
  */
 static int nfs4_xdr_dec_getdeviceinfo(struct rpc_rqst *rqstp,
                                      struct xdr_stream *xdr,
-                                     struct nfs4_getdeviceinfo_res *res)
+                                     void *data)
 {
+       struct nfs4_getdeviceinfo_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -7198,8 +7289,9 @@ out:
  */
 static int nfs4_xdr_dec_layoutget(struct rpc_rqst *rqstp,
                                  struct xdr_stream *xdr,
-                                 struct nfs4_layoutget_res *res)
+                                 void *data)
 {
+       struct nfs4_layoutget_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -7222,8 +7314,9 @@ out:
  */
 static int nfs4_xdr_dec_layoutreturn(struct rpc_rqst *rqstp,
                                     struct xdr_stream *xdr,
-                                    struct nfs4_layoutreturn_res *res)
+                                    void *data)
 {
+       struct nfs4_layoutreturn_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -7246,8 +7339,9 @@ out:
  */
 static int nfs4_xdr_dec_layoutcommit(struct rpc_rqst *rqstp,
                                     struct xdr_stream *xdr,
-                                    struct nfs4_layoutcommit_res *res)
+                                    void *data)
 {
+       struct nfs4_layoutcommit_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -7273,8 +7367,9 @@ out:
  */
 static int nfs4_xdr_dec_secinfo_no_name(struct rpc_rqst *rqstp,
                                        struct xdr_stream *xdr,
-                                       struct nfs4_secinfo_res *res)
+                                       void *data)
 {
+       struct nfs4_secinfo_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -7297,8 +7392,9 @@ out:
  */
 static int nfs4_xdr_dec_test_stateid(struct rpc_rqst *rqstp,
                                     struct xdr_stream *xdr,
-                                    struct nfs41_test_stateid_res *res)
+                                    void *data)
 {
+       struct nfs41_test_stateid_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -7318,8 +7414,9 @@ out:
  */
 static int nfs4_xdr_dec_free_stateid(struct rpc_rqst *rqstp,
                                     struct xdr_stream *xdr,
-                                    struct nfs41_free_stateid_res *res)
+                                    void *data)
 {
+       struct nfs41_free_stateid_res *res = data;
        struct compound_hdr hdr;
        int status;
 
@@ -7484,8 +7581,8 @@ nfs4_stat_to_errno(int stat)
 #define PROC(proc, argtype, restype)                           \
 [NFSPROC4_CLNT_##proc] = {                                     \
        .p_proc   = NFSPROC4_COMPOUND,                          \
-       .p_encode = (kxdreproc_t)nfs4_xdr_##argtype,            \
-       .p_decode = (kxdrdproc_t)nfs4_xdr_##restype,            \
+       .p_encode = nfs4_xdr_##argtype,                         \
+       .p_decode = nfs4_xdr_##restype,                         \
        .p_arglen = NFS4_##argtype##_sz,                        \
        .p_replen = NFS4_##restype##_sz,                        \
        .p_statidx = NFSPROC4_CLNT_##proc,                      \
@@ -7497,7 +7594,7 @@ nfs4_stat_to_errno(int stat)
        .p_name = #proc,        \
 }
 
-struct rpc_procinfo    nfs4_procedures[] = {
+const struct rpc_procinfo nfs4_procedures[] = {
        PROC(READ,              enc_read,               dec_read),
        PROC(WRITE,             enc_write,              dec_write),
        PROC(COMMIT,            enc_commit,             dec_commit),
@@ -7564,10 +7661,12 @@ struct rpc_procinfo     nfs4_procedures[] = {
 #endif /* CONFIG_NFS_V4_2 */
 };
 
+static unsigned int nfs_version4_counts[ARRAY_SIZE(nfs4_procedures)];
 const struct rpc_version nfs_version4 = {
        .number                 = 4,
        .nrprocs                = ARRAY_SIZE(nfs4_procedures),
-       .procs                  = nfs4_procedures
+       .procs                  = nfs4_procedures,
+       .counts                 = nfs_version4_counts,
 };
 
 /*
index 4123551208d88d637593331d697f264fe77df908..34075cee573a0aa5b3d1c1041b5863c78f52b868 100644 (file)
@@ -8,21 +8,33 @@ extern void clear_current_stateid(struct nfsd4_compound_state *cstate);
 /*
  * functions to set current state id
  */
-extern void nfsd4_set_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *);
-extern void nfsd4_set_openstateid(struct nfsd4_compound_state *, struct nfsd4_open *);
-extern void nfsd4_set_lockstateid(struct nfsd4_compound_state *, struct nfsd4_lock *);
-extern void nfsd4_set_closestateid(struct nfsd4_compound_state *, struct nfsd4_close *);
+extern void nfsd4_set_opendowngradestateid(struct nfsd4_compound_state *,
+               union nfsd4_op_u *);
+extern void nfsd4_set_openstateid(struct nfsd4_compound_state *,
+               union nfsd4_op_u *);
+extern void nfsd4_set_lockstateid(struct nfsd4_compound_state *,
+               union nfsd4_op_u *);
+extern void nfsd4_set_closestateid(struct nfsd4_compound_state *,
+               union nfsd4_op_u *);
 
 /*
  * functions to consume current state id
  */
-extern void nfsd4_get_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *);
-extern void nfsd4_get_delegreturnstateid(struct nfsd4_compound_state *, struct nfsd4_delegreturn *);
-extern void nfsd4_get_freestateid(struct nfsd4_compound_state *, struct nfsd4_free_stateid *);
-extern void nfsd4_get_setattrstateid(struct nfsd4_compound_state *, struct nfsd4_setattr *);
-extern void nfsd4_get_closestateid(struct nfsd4_compound_state *, struct nfsd4_close *);
-extern void nfsd4_get_lockustateid(struct nfsd4_compound_state *, struct nfsd4_locku *);
-extern void nfsd4_get_readstateid(struct nfsd4_compound_state *, struct nfsd4_read *);
-extern void nfsd4_get_writestateid(struct nfsd4_compound_state *, struct nfsd4_write *);
+extern void nfsd4_get_opendowngradestateid(struct nfsd4_compound_state *,
+               union nfsd4_op_u *);
+extern void nfsd4_get_delegreturnstateid(struct nfsd4_compound_state *,
+               union nfsd4_op_u *);
+extern void nfsd4_get_freestateid(struct nfsd4_compound_state *,
+               union nfsd4_op_u *);
+extern void nfsd4_get_setattrstateid(struct nfsd4_compound_state *,
+               union nfsd4_op_u *);
+extern void nfsd4_get_closestateid(struct nfsd4_compound_state *,
+               union nfsd4_op_u *);
+extern void nfsd4_get_lockustateid(struct nfsd4_compound_state *,
+               union nfsd4_op_u *);
+extern void nfsd4_get_readstateid(struct nfsd4_compound_state *,
+               union nfsd4_op_u *);
+extern void nfsd4_get_writestateid(struct nfsd4_compound_state *,
+               union nfsd4_op_u *);
 
 #endif   /* _NFSD4_CURRENT_STATE_H */
index 838f90f3f890a00f0f0989e5c3abb79e20b273d0..6276ec8608b0674a5bcd9d35a1c271a4816b1613 100644 (file)
@@ -19,7 +19,7 @@
  * NULL call.
  */
 static __be32
-nfsacld_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
+nfsacld_proc_null(struct svc_rqst *rqstp)
 {
        return nfs_ok;
 }
@@ -27,9 +27,10 @@ nfsacld_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
 /*
  * Get the Access and/or Default ACL of a file.
  */
-static __be32 nfsacld_proc_getacl(struct svc_rqst * rqstp,
-               struct nfsd3_getaclargs *argp, struct nfsd3_getaclres *resp)
+static __be32 nfsacld_proc_getacl(struct svc_rqst *rqstp)
 {
+       struct nfsd3_getaclargs *argp = rqstp->rq_argp;
+       struct nfsd3_getaclres *resp = rqstp->rq_resp;
        struct posix_acl *acl;
        struct inode *inode;
        svc_fh *fh;
@@ -87,10 +88,10 @@ fail:
 /*
  * Set the Access and/or Default ACL of a file.
  */
-static __be32 nfsacld_proc_setacl(struct svc_rqst * rqstp,
-               struct nfsd3_setaclargs *argp,
-               struct nfsd_attrstat *resp)
+static __be32 nfsacld_proc_setacl(struct svc_rqst *rqstp)
 {
+       struct nfsd3_setaclargs *argp = rqstp->rq_argp;
+       struct nfsd_attrstat *resp = rqstp->rq_resp;
        struct inode *inode;
        svc_fh *fh;
        __be32 nfserr = 0;
@@ -141,9 +142,10 @@ out_errno:
 /*
  * Check file attributes
  */
-static __be32 nfsacld_proc_getattr(struct svc_rqst * rqstp,
-               struct nfsd_fhandle *argp, struct nfsd_attrstat *resp)
+static __be32 nfsacld_proc_getattr(struct svc_rqst *rqstp)
 {
+       struct nfsd_fhandle *argp = rqstp->rq_argp;
+       struct nfsd_attrstat *resp = rqstp->rq_resp;
        __be32 nfserr;
        dprintk("nfsd: GETATTR  %s\n", SVCFH_fmt(&argp->fh));
 
@@ -158,9 +160,10 @@ static __be32 nfsacld_proc_getattr(struct svc_rqst * rqstp,
 /*
  * Check file access
  */
-static __be32 nfsacld_proc_access(struct svc_rqst *rqstp, struct nfsd3_accessargs *argp,
-               struct nfsd3_accessres *resp)
+static __be32 nfsacld_proc_access(struct svc_rqst *rqstp)
 {
+       struct nfsd3_accessargs *argp = rqstp->rq_argp;
+       struct nfsd3_accessres *resp = rqstp->rq_resp;
        __be32 nfserr;
 
        dprintk("nfsd: ACCESS(2acl)   %s 0x%x\n",
@@ -179,9 +182,10 @@ static __be32 nfsacld_proc_access(struct svc_rqst *rqstp, struct nfsd3_accessarg
 /*
  * XDR decode functions
  */
-static int nfsaclsvc_decode_getaclargs(struct svc_rqst *rqstp, __be32 *p,
-               struct nfsd3_getaclargs *argp)
+static int nfsaclsvc_decode_getaclargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_getaclargs *argp = rqstp->rq_argp;
+
        p = nfs2svc_decode_fh(p, &argp->fh);
        if (!p)
                return 0;
@@ -191,9 +195,9 @@ static int nfsaclsvc_decode_getaclargs(struct svc_rqst *rqstp, __be32 *p,
 }
 
 
-static int nfsaclsvc_decode_setaclargs(struct svc_rqst *rqstp, __be32 *p,
-               struct nfsd3_setaclargs *argp)
+static int nfsaclsvc_decode_setaclargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_setaclargs *argp = rqstp->rq_argp;
        struct kvec *head = rqstp->rq_arg.head;
        unsigned int base;
        int n;
@@ -217,18 +221,20 @@ static int nfsaclsvc_decode_setaclargs(struct svc_rqst *rqstp, __be32 *p,
        return (n > 0);
 }
 
-static int nfsaclsvc_decode_fhandleargs(struct svc_rqst *rqstp, __be32 *p,
-               struct nfsd_fhandle *argp)
+static int nfsaclsvc_decode_fhandleargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd_fhandle *argp = rqstp->rq_argp;
+
        p = nfs2svc_decode_fh(p, &argp->fh);
        if (!p)
                return 0;
        return xdr_argsize_check(rqstp, p);
 }
 
-static int nfsaclsvc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p,
-               struct nfsd3_accessargs *argp)
+static int nfsaclsvc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_accessargs *argp = rqstp->rq_argp;
+
        p = nfs2svc_decode_fh(p, &argp->fh);
        if (!p)
                return 0;
@@ -245,15 +251,15 @@ static int nfsaclsvc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p,
  * There must be an encoding function for void results so svc_process
  * will work properly.
  */
-static int nfsaclsvc_encode_voidres(struct svc_rqst *rqstp, __be32 *p, void *dummy)
+static int nfsaclsvc_encode_voidres(struct svc_rqst *rqstp, __be32 *p)
 {
        return xdr_ressize_check(rqstp, p);
 }
 
 /* GETACL */
-static int nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p,
-               struct nfsd3_getaclres *resp)
+static int nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_getaclres *resp = rqstp->rq_resp;
        struct dentry *dentry = resp->fh.fh_dentry;
        struct inode *inode;
        struct kvec *head = rqstp->rq_res.head;
@@ -296,17 +302,19 @@ static int nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p,
        return (n > 0);
 }
 
-static int nfsaclsvc_encode_attrstatres(struct svc_rqst *rqstp, __be32 *p,
-               struct nfsd_attrstat *resp)
+static int nfsaclsvc_encode_attrstatres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd_attrstat *resp = rqstp->rq_resp;
+
        p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
        return xdr_ressize_check(rqstp, p);
 }
 
 /* ACCESS */
-static int nfsaclsvc_encode_accessres(struct svc_rqst *rqstp, __be32 *p,
-               struct nfsd3_accessres *resp)
+static int nfsaclsvc_encode_accessres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_accessres *resp = rqstp->rq_resp;
+
        p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
        *p++ = htonl(resp->access);
        return xdr_ressize_check(rqstp, p);
@@ -315,27 +323,27 @@ static int nfsaclsvc_encode_accessres(struct svc_rqst *rqstp, __be32 *p,
 /*
  * XDR release functions
  */
-static int nfsaclsvc_release_getacl(struct svc_rqst *rqstp, __be32 *p,
-               struct nfsd3_getaclres *resp)
+static void nfsaclsvc_release_getacl(struct svc_rqst *rqstp)
 {
+       struct nfsd3_getaclres *resp = rqstp->rq_resp;
+
        fh_put(&resp->fh);
        posix_acl_release(resp->acl_access);
        posix_acl_release(resp->acl_default);
-       return 1;
 }
 
-static int nfsaclsvc_release_attrstat(struct svc_rqst *rqstp, __be32 *p,
-               struct nfsd_attrstat *resp)
+static void nfsaclsvc_release_attrstat(struct svc_rqst *rqstp)
 {
+       struct nfsd_attrstat *resp = rqstp->rq_resp;
+
        fh_put(&resp->fh);
-       return 1;
 }
 
-static int nfsaclsvc_release_access(struct svc_rqst *rqstp, __be32 *p,
-               struct nfsd3_accessres *resp)
+static void nfsaclsvc_release_access(struct svc_rqst *rqstp)
 {
-       fh_put(&resp->fh);
-       return 1;
+       struct nfsd3_accessres *resp = rqstp->rq_resp;
+
+       fh_put(&resp->fh);
 }
 
 #define nfsaclsvc_decode_voidargs      NULL
@@ -345,24 +353,24 @@ static int nfsaclsvc_release_access(struct svc_rqst *rqstp, __be32 *p,
 #define nfsd3_voidres          nfsd3_voidargs
 struct nfsd3_voidargs { int dummy; };
 
-#define PROC(name, argt, rest, relt, cache, respsize)  \
- { (svc_procfunc) nfsacld_proc_##name,         \
-   (kxdrproc_t) nfsaclsvc_decode_##argt##args, \
-   (kxdrproc_t) nfsaclsvc_encode_##rest##res,  \
-   (kxdrproc_t) nfsaclsvc_release_##relt,              \
-   sizeof(struct nfsd3_##argt##args),          \
-   sizeof(struct nfsd3_##rest##res),           \
-   0,                                          \
-   cache,                                      \
-   respsize,                                   \
- }
+#define PROC(name, argt, rest, relt, cache, respsize)                  \
+{                                                                      \
+       .pc_func        = nfsacld_proc_##name,                          \
+       .pc_decode      = nfsaclsvc_decode_##argt##args,                \
+       .pc_encode      = nfsaclsvc_encode_##rest##res,                 \
+       .pc_release     = nfsaclsvc_release_##relt,     \
+       .pc_argsize     = sizeof(struct nfsd3_##argt##args),            \
+       .pc_ressize     = sizeof(struct nfsd3_##rest##res),             \
+       .pc_cachetype   = cache,                                        \
+       .pc_xdrressize  = respsize,                                     \
+}
 
 #define ST 1           /* status*/
 #define AT 21          /* attributes */
 #define pAT (1+AT)     /* post attributes - conditional */
 #define ACL (1+NFS_ACL_MAX_ENTRIES*3)  /* Access Control List */
 
-static struct svc_procedure            nfsd_acl_procedures2[] = {
+static const struct svc_procedure nfsd_acl_procedures2[] = {
   PROC(null,   void,           void,           void,     RC_NOCACHE, ST),
   PROC(getacl, getacl,         getacl,         getacl,   RC_NOCACHE, ST+1+2*(1+ACL)),
   PROC(setacl, setacl,         attrstat,       attrstat, RC_NOCACHE, ST+AT),
@@ -370,10 +378,12 @@ static struct svc_procedure               nfsd_acl_procedures2[] = {
   PROC(access, access,         access,         access,   RC_NOCACHE, ST+AT+1),
 };
 
-struct svc_version     nfsd_acl_version2 = {
-               .vs_vers        = 2,
-               .vs_nproc       = 5,
-               .vs_proc        = nfsd_acl_procedures2,
-               .vs_dispatch    = nfsd_dispatch,
-               .vs_xdrsize     = NFS3_SVC_XDRSIZE,
+static unsigned int nfsd_acl_count2[ARRAY_SIZE(nfsd_acl_procedures2)];
+const struct svc_version nfsd_acl_version2 = {
+       .vs_vers        = 2,
+       .vs_nproc       = 5,
+       .vs_proc        = nfsd_acl_procedures2,
+       .vs_count       = nfsd_acl_count2,
+       .vs_dispatch    = nfsd_dispatch,
+       .vs_xdrsize     = NFS3_SVC_XDRSIZE,
 };
index dcb5f79076c0cb3cb12400575cb7e3d3cfa9e26d..01976529f04240f45cf7dcf0246c193e5be8d77a 100644 (file)
@@ -18,7 +18,7 @@
  * NULL call.
  */
 static __be32
-nfsd3_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
+nfsd3_proc_null(struct svc_rqst *rqstp)
 {
        return nfs_ok;
 }
@@ -26,9 +26,10 @@ nfsd3_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
 /*
  * Get the Access and/or Default ACL of a file.
  */
-static __be32 nfsd3_proc_getacl(struct svc_rqst * rqstp,
-               struct nfsd3_getaclargs *argp, struct nfsd3_getaclres *resp)
+static __be32 nfsd3_proc_getacl(struct svc_rqst *rqstp)
 {
+       struct nfsd3_getaclargs *argp = rqstp->rq_argp;
+       struct nfsd3_getaclres *resp = rqstp->rq_resp;
        struct posix_acl *acl;
        struct inode *inode;
        svc_fh *fh;
@@ -80,10 +81,10 @@ fail:
 /*
  * Set the Access and/or Default ACL of a file.
  */
-static __be32 nfsd3_proc_setacl(struct svc_rqst * rqstp,
-               struct nfsd3_setaclargs *argp,
-               struct nfsd3_attrstat *resp)
+static __be32 nfsd3_proc_setacl(struct svc_rqst *rqstp)
 {
+       struct nfsd3_setaclargs *argp = rqstp->rq_argp;
+       struct nfsd3_attrstat *resp = rqstp->rq_resp;
        struct inode *inode;
        svc_fh *fh;
        __be32 nfserr = 0;
@@ -123,9 +124,10 @@ out:
 /*
  * XDR decode functions
  */
-static int nfs3svc_decode_getaclargs(struct svc_rqst *rqstp, __be32 *p,
-               struct nfsd3_getaclargs *args)
+static int nfs3svc_decode_getaclargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_getaclargs *args = rqstp->rq_argp;
+
        p = nfs3svc_decode_fh(p, &args->fh);
        if (!p)
                return 0;
@@ -135,9 +137,9 @@ static int nfs3svc_decode_getaclargs(struct svc_rqst *rqstp, __be32 *p,
 }
 
 
-static int nfs3svc_decode_setaclargs(struct svc_rqst *rqstp, __be32 *p,
-               struct nfsd3_setaclargs *args)
+static int nfs3svc_decode_setaclargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_setaclargs *args = rqstp->rq_argp;
        struct kvec *head = rqstp->rq_arg.head;
        unsigned int base;
        int n;
@@ -166,9 +168,9 @@ static int nfs3svc_decode_setaclargs(struct svc_rqst *rqstp, __be32 *p,
  */
 
 /* GETACL */
-static int nfs3svc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p,
-               struct nfsd3_getaclres *resp)
+static int nfs3svc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_getaclres *resp = rqstp->rq_resp;
        struct dentry *dentry = resp->fh.fh_dentry;
 
        p = nfs3svc_encode_post_op_attr(rqstp, p, &resp->fh);
@@ -211,9 +213,10 @@ static int nfs3svc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p,
 }
 
 /* SETACL */
-static int nfs3svc_encode_setaclres(struct svc_rqst *rqstp, __be32 *p,
-               struct nfsd3_attrstat *resp)
+static int nfs3svc_encode_setaclres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_attrstat *resp = rqstp->rq_resp;
+
        p = nfs3svc_encode_post_op_attr(rqstp, p, &resp->fh);
 
        return xdr_ressize_check(rqstp, p);
@@ -222,13 +225,13 @@ static int nfs3svc_encode_setaclres(struct svc_rqst *rqstp, __be32 *p,
 /*
  * XDR release functions
  */
-static int nfs3svc_release_getacl(struct svc_rqst *rqstp, __be32 *p,
-               struct nfsd3_getaclres *resp)
+static void nfs3svc_release_getacl(struct svc_rqst *rqstp)
 {
+       struct nfsd3_getaclres *resp = rqstp->rq_resp;
+
        fh_put(&resp->fh);
        posix_acl_release(resp->acl_access);
        posix_acl_release(resp->acl_default);
-       return 1;
 }
 
 #define nfs3svc_decode_voidargs                NULL
@@ -237,34 +240,36 @@ static int nfs3svc_release_getacl(struct svc_rqst *rqstp, __be32 *p,
 #define nfsd3_voidres                  nfsd3_voidargs
 struct nfsd3_voidargs { int dummy; };
 
-#define PROC(name, argt, rest, relt, cache, respsize)  \
- { (svc_procfunc) nfsd3_proc_##name,           \
-   (kxdrproc_t) nfs3svc_decode_##argt##args,   \
-   (kxdrproc_t) nfs3svc_encode_##rest##res,    \
-   (kxdrproc_t) nfs3svc_release_##relt,                \
-   sizeof(struct nfsd3_##argt##args),          \
-   sizeof(struct nfsd3_##rest##res),           \
-   0,                                          \
-   cache,                                      \
-   respsize,                                   \
- }
+#define PROC(name, argt, rest, relt, cache, respsize)                  \
+{                                                                      \
+       .pc_func        = nfsd3_proc_##name,                            \
+       .pc_decode      = nfs3svc_decode_##argt##args,                  \
+       .pc_encode      = nfs3svc_encode_##rest##res,                   \
+       .pc_release     = nfs3svc_release_##relt,                       \
+       .pc_argsize     = sizeof(struct nfsd3_##argt##args),            \
+       .pc_ressize     = sizeof(struct nfsd3_##rest##res),             \
+       .pc_cachetype   = cache,                                        \
+       .pc_xdrressize  = respsize,                                     \
+}
 
 #define ST 1           /* status*/
 #define AT 21          /* attributes */
 #define pAT (1+AT)     /* post attributes - conditional */
 #define ACL (1+NFS_ACL_MAX_ENTRIES*3)  /* Access Control List */
 
-static struct svc_procedure            nfsd_acl_procedures3[] = {
+static const struct svc_procedure nfsd_acl_procedures3[] = {
   PROC(null,   void,           void,           void,     RC_NOCACHE, ST),
   PROC(getacl, getacl,         getacl,         getacl,   RC_NOCACHE, ST+1+2*(1+ACL)),
   PROC(setacl, setacl,         setacl,         fhandle,  RC_NOCACHE, ST+pAT),
 };
 
-struct svc_version     nfsd_acl_version3 = {
-               .vs_vers        = 3,
-               .vs_nproc       = 3,
-               .vs_proc        = nfsd_acl_procedures3,
-               .vs_dispatch    = nfsd_dispatch,
-               .vs_xdrsize     = NFS3_SVC_XDRSIZE,
+static unsigned int nfsd_acl_count3[ARRAY_SIZE(nfsd_acl_procedures3)];
+const struct svc_version nfsd_acl_version3 = {
+       .vs_vers        = 3,
+       .vs_nproc       = 3,
+       .vs_proc        = nfsd_acl_procedures3,
+       .vs_count       = nfsd_acl_count3,
+       .vs_dispatch    = nfsd_dispatch,
+       .vs_xdrsize     = NFS3_SVC_XDRSIZE,
 };
 
index 045c9081eabeb0242a0f60d49ec9177dc9c0c6f4..2cb56a0d6625f07db79447768fac92c86940d9b7 100644 (file)
@@ -31,7 +31,7 @@ static int    nfs3_ftypes[] = {
  * NULL call.
  */
 static __be32
-nfsd3_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
+nfsd3_proc_null(struct svc_rqst *rqstp)
 {
        return nfs_ok;
 }
@@ -40,9 +40,10 @@ nfsd3_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
  * Get a file's attributes
  */
 static __be32
-nfsd3_proc_getattr(struct svc_rqst *rqstp, struct nfsd_fhandle  *argp,
-                                          struct nfsd3_attrstat *resp)
+nfsd3_proc_getattr(struct svc_rqst *rqstp)
 {
+       struct nfsd_fhandle *argp = rqstp->rq_argp;
+       struct nfsd3_attrstat *resp = rqstp->rq_resp;
        __be32  nfserr;
 
        dprintk("nfsd: GETATTR(3)  %s\n",
@@ -63,9 +64,10 @@ nfsd3_proc_getattr(struct svc_rqst *rqstp, struct nfsd_fhandle  *argp,
  * Set a file's attributes
  */
 static __be32
-nfsd3_proc_setattr(struct svc_rqst *rqstp, struct nfsd3_sattrargs *argp,
-                                          struct nfsd3_attrstat  *resp)
+nfsd3_proc_setattr(struct svc_rqst *rqstp)
 {
+       struct nfsd3_sattrargs *argp = rqstp->rq_argp;
+       struct nfsd3_attrstat *resp = rqstp->rq_resp;
        __be32  nfserr;
 
        dprintk("nfsd: SETATTR(3)  %s\n",
@@ -81,9 +83,10 @@ nfsd3_proc_setattr(struct svc_rqst *rqstp, struct nfsd3_sattrargs *argp,
  * Look up a path name component
  */
 static __be32
-nfsd3_proc_lookup(struct svc_rqst *rqstp, struct nfsd3_diropargs *argp,
-                                         struct nfsd3_diropres  *resp)
+nfsd3_proc_lookup(struct svc_rqst *rqstp)
 {
+       struct nfsd3_diropargs *argp = rqstp->rq_argp;
+       struct nfsd3_diropres  *resp = rqstp->rq_resp;
        __be32  nfserr;
 
        dprintk("nfsd: LOOKUP(3)   %s %.*s\n",
@@ -105,9 +108,10 @@ nfsd3_proc_lookup(struct svc_rqst *rqstp, struct nfsd3_diropargs *argp,
  * Check file access
  */
 static __be32
-nfsd3_proc_access(struct svc_rqst *rqstp, struct nfsd3_accessargs *argp,
-                                         struct nfsd3_accessres *resp)
+nfsd3_proc_access(struct svc_rqst *rqstp)
 {
+       struct nfsd3_accessargs *argp = rqstp->rq_argp;
+       struct nfsd3_accessres *resp = rqstp->rq_resp;
        __be32  nfserr;
 
        dprintk("nfsd: ACCESS(3)   %s 0x%x\n",
@@ -124,9 +128,10 @@ nfsd3_proc_access(struct svc_rqst *rqstp, struct nfsd3_accessargs *argp,
  * Read a symlink.
  */
 static __be32
-nfsd3_proc_readlink(struct svc_rqst *rqstp, struct nfsd3_readlinkargs *argp,
-                                          struct nfsd3_readlinkres *resp)
+nfsd3_proc_readlink(struct svc_rqst *rqstp)
 {
+       struct nfsd3_readlinkargs *argp = rqstp->rq_argp;
+       struct nfsd3_readlinkres *resp = rqstp->rq_resp;
        __be32 nfserr;
 
        dprintk("nfsd: READLINK(3) %s\n", SVCFH_fmt(&argp->fh));
@@ -142,9 +147,10 @@ nfsd3_proc_readlink(struct svc_rqst *rqstp, struct nfsd3_readlinkargs *argp,
  * Read a portion of a file.
  */
 static __be32
-nfsd3_proc_read(struct svc_rqst *rqstp, struct nfsd3_readargs *argp,
-                                       struct nfsd3_readres  *resp)
+nfsd3_proc_read(struct svc_rqst *rqstp)
 {
+       struct nfsd3_readargs *argp = rqstp->rq_argp;
+       struct nfsd3_readres *resp = rqstp->rq_resp;
        __be32  nfserr;
        u32     max_blocksize = svc_max_payload(rqstp);
        unsigned long cnt = min(argp->count, max_blocksize);
@@ -179,9 +185,10 @@ nfsd3_proc_read(struct svc_rqst *rqstp, struct nfsd3_readargs *argp,
  * Write data to a file
  */
 static __be32
-nfsd3_proc_write(struct svc_rqst *rqstp, struct nfsd3_writeargs *argp,
-                                        struct nfsd3_writeres  *resp)
+nfsd3_proc_write(struct svc_rqst *rqstp)
 {
+       struct nfsd3_writeargs *argp = rqstp->rq_argp;
+       struct nfsd3_writeres *resp = rqstp->rq_resp;
        __be32  nfserr;
        unsigned long cnt = argp->len;
 
@@ -206,9 +213,10 @@ nfsd3_proc_write(struct svc_rqst *rqstp, struct nfsd3_writeargs *argp,
  * first reports about SunOS compatibility problems start to pour in...
  */
 static __be32
-nfsd3_proc_create(struct svc_rqst *rqstp, struct nfsd3_createargs *argp,
-                                         struct nfsd3_diropres   *resp)
+nfsd3_proc_create(struct svc_rqst *rqstp)
 {
+       struct nfsd3_createargs *argp = rqstp->rq_argp;
+       struct nfsd3_diropres *resp = rqstp->rq_resp;
        svc_fh          *dirfhp, *newfhp = NULL;
        struct iattr    *attr;
        __be32          nfserr;
@@ -243,9 +251,10 @@ nfsd3_proc_create(struct svc_rqst *rqstp, struct nfsd3_createargs *argp,
  * Make directory. This operation is not idempotent.
  */
 static __be32
-nfsd3_proc_mkdir(struct svc_rqst *rqstp, struct nfsd3_createargs *argp,
-                                        struct nfsd3_diropres   *resp)
+nfsd3_proc_mkdir(struct svc_rqst *rqstp)
 {
+       struct nfsd3_createargs *argp = rqstp->rq_argp;
+       struct nfsd3_diropres *resp = rqstp->rq_resp;
        __be32  nfserr;
 
        dprintk("nfsd: MKDIR(3)    %s %.*s\n",
@@ -263,9 +272,10 @@ nfsd3_proc_mkdir(struct svc_rqst *rqstp, struct nfsd3_createargs *argp,
 }
 
 static __be32
-nfsd3_proc_symlink(struct svc_rqst *rqstp, struct nfsd3_symlinkargs *argp,
-                                          struct nfsd3_diropres    *resp)
+nfsd3_proc_symlink(struct svc_rqst *rqstp)
 {
+       struct nfsd3_symlinkargs *argp = rqstp->rq_argp;
+       struct nfsd3_diropres *resp = rqstp->rq_resp;
        __be32  nfserr;
 
        dprintk("nfsd: SYMLINK(3)  %s %.*s -> %.*s\n",
@@ -284,9 +294,10 @@ nfsd3_proc_symlink(struct svc_rqst *rqstp, struct nfsd3_symlinkargs *argp,
  * Make socket/fifo/device.
  */
 static __be32
-nfsd3_proc_mknod(struct svc_rqst *rqstp, struct nfsd3_mknodargs *argp,
-                                        struct nfsd3_diropres  *resp)
+nfsd3_proc_mknod(struct svc_rqst *rqstp)
 {
+       struct nfsd3_mknodargs *argp = rqstp->rq_argp;
+       struct nfsd3_diropres  *resp = rqstp->rq_resp;
        __be32  nfserr;
        int type;
        dev_t   rdev = 0;
@@ -321,9 +332,10 @@ nfsd3_proc_mknod(struct svc_rqst *rqstp, struct nfsd3_mknodargs *argp,
  * Remove file/fifo/socket etc.
  */
 static __be32
-nfsd3_proc_remove(struct svc_rqst *rqstp, struct nfsd3_diropargs *argp,
-                                         struct nfsd3_attrstat  *resp)
+nfsd3_proc_remove(struct svc_rqst *rqstp)
 {
+       struct nfsd3_diropargs *argp = rqstp->rq_argp;
+       struct nfsd3_attrstat *resp = rqstp->rq_resp;
        __be32  nfserr;
 
        dprintk("nfsd: REMOVE(3)   %s %.*s\n",
@@ -342,9 +354,10 @@ nfsd3_proc_remove(struct svc_rqst *rqstp, struct nfsd3_diropargs *argp,
  * Remove a directory
  */
 static __be32
-nfsd3_proc_rmdir(struct svc_rqst *rqstp, struct nfsd3_diropargs *argp,
-                                        struct nfsd3_attrstat  *resp)
+nfsd3_proc_rmdir(struct svc_rqst *rqstp)
 {
+       struct nfsd3_diropargs *argp = rqstp->rq_argp;
+       struct nfsd3_attrstat *resp = rqstp->rq_resp;
        __be32  nfserr;
 
        dprintk("nfsd: RMDIR(3)    %s %.*s\n",
@@ -359,9 +372,10 @@ nfsd3_proc_rmdir(struct svc_rqst *rqstp, struct nfsd3_diropargs *argp,
 }
 
 static __be32
-nfsd3_proc_rename(struct svc_rqst *rqstp, struct nfsd3_renameargs *argp,
-                                         struct nfsd3_renameres  *resp)
+nfsd3_proc_rename(struct svc_rqst *rqstp)
 {
+       struct nfsd3_renameargs *argp = rqstp->rq_argp;
+       struct nfsd3_renameres *resp = rqstp->rq_resp;
        __be32  nfserr;
 
        dprintk("nfsd: RENAME(3)   %s %.*s ->\n",
@@ -381,9 +395,10 @@ nfsd3_proc_rename(struct svc_rqst *rqstp, struct nfsd3_renameargs *argp,
 }
 
 static __be32
-nfsd3_proc_link(struct svc_rqst *rqstp, struct nfsd3_linkargs *argp,
-                                       struct nfsd3_linkres  *resp)
+nfsd3_proc_link(struct svc_rqst *rqstp)
 {
+       struct nfsd3_linkargs *argp = rqstp->rq_argp;
+       struct nfsd3_linkres  *resp = rqstp->rq_resp;
        __be32  nfserr;
 
        dprintk("nfsd: LINK(3)     %s ->\n",
@@ -404,9 +419,10 @@ nfsd3_proc_link(struct svc_rqst *rqstp, struct nfsd3_linkargs *argp,
  * Read a portion of a directory.
  */
 static __be32
-nfsd3_proc_readdir(struct svc_rqst *rqstp, struct nfsd3_readdirargs *argp,
-                                          struct nfsd3_readdirres  *resp)
+nfsd3_proc_readdir(struct svc_rqst *rqstp)
 {
+       struct nfsd3_readdirargs *argp = rqstp->rq_argp;
+       struct nfsd3_readdirres  *resp = rqstp->rq_resp;
        __be32          nfserr;
        int             count;
 
@@ -440,9 +456,10 @@ nfsd3_proc_readdir(struct svc_rqst *rqstp, struct nfsd3_readdirargs *argp,
  * For now, we choose to ignore the dircount parameter.
  */
 static __be32
-nfsd3_proc_readdirplus(struct svc_rqst *rqstp, struct nfsd3_readdirargs *argp,
-                                              struct nfsd3_readdirres  *resp)
+nfsd3_proc_readdirplus(struct svc_rqst *rqstp)
 {
+       struct nfsd3_readdirargs *argp = rqstp->rq_argp;
+       struct nfsd3_readdirres  *resp = rqstp->rq_resp;
        __be32  nfserr;
        int     count = 0;
        loff_t  offset;
@@ -507,9 +524,10 @@ nfsd3_proc_readdirplus(struct svc_rqst *rqstp, struct nfsd3_readdirargs *argp,
  * Get file system stats
  */
 static __be32
-nfsd3_proc_fsstat(struct svc_rqst * rqstp, struct nfsd_fhandle    *argp,
-                                          struct nfsd3_fsstatres *resp)
+nfsd3_proc_fsstat(struct svc_rqst *rqstp)
 {
+       struct nfsd_fhandle *argp = rqstp->rq_argp;
+       struct nfsd3_fsstatres *resp = rqstp->rq_resp;
        __be32  nfserr;
 
        dprintk("nfsd: FSSTAT(3)   %s\n",
@@ -524,9 +542,10 @@ nfsd3_proc_fsstat(struct svc_rqst * rqstp, struct nfsd_fhandle    *argp,
  * Get file system info
  */
 static __be32
-nfsd3_proc_fsinfo(struct svc_rqst * rqstp, struct nfsd_fhandle    *argp,
-                                          struct nfsd3_fsinfores *resp)
+nfsd3_proc_fsinfo(struct svc_rqst *rqstp)
 {
+       struct nfsd_fhandle *argp = rqstp->rq_argp;
+       struct nfsd3_fsinfores *resp = rqstp->rq_resp;
        __be32  nfserr;
        u32     max_blocksize = svc_max_payload(rqstp);
 
@@ -567,9 +586,10 @@ nfsd3_proc_fsinfo(struct svc_rqst * rqstp, struct nfsd_fhandle    *argp,
  * Get pathconf info for the specified file
  */
 static __be32
-nfsd3_proc_pathconf(struct svc_rqst * rqstp, struct nfsd_fhandle      *argp,
-                                            struct nfsd3_pathconfres *resp)
+nfsd3_proc_pathconf(struct svc_rqst *rqstp)
 {
+       struct nfsd_fhandle *argp = rqstp->rq_argp;
+       struct nfsd3_pathconfres *resp = rqstp->rq_resp;
        __be32  nfserr;
 
        dprintk("nfsd: PATHCONF(3) %s\n",
@@ -610,9 +630,10 @@ nfsd3_proc_pathconf(struct svc_rqst * rqstp, struct nfsd_fhandle      *argp,
  * Commit a file (range) to stable storage.
  */
 static __be32
-nfsd3_proc_commit(struct svc_rqst * rqstp, struct nfsd3_commitargs *argp,
-                                          struct nfsd3_commitres  *resp)
+nfsd3_proc_commit(struct svc_rqst *rqstp)
 {
+       struct nfsd3_commitargs *argp = rqstp->rq_argp;
+       struct nfsd3_commitres *resp = rqstp->rq_resp;
        __be32  nfserr;
 
        dprintk("nfsd: COMMIT(3)   %s %u@%Lu\n",
@@ -647,233 +668,221 @@ nfsd3_proc_commit(struct svc_rqst * rqstp, struct nfsd3_commitargs *argp,
 #define nfsd3_voidres                  nfsd3_voidargs
 struct nfsd3_voidargs { int dummy; };
 
-#define PROC(name, argt, rest, relt, cache, respsize)  \
- { (svc_procfunc) nfsd3_proc_##name,           \
-   (kxdrproc_t) nfs3svc_decode_##argt##args,   \
-   (kxdrproc_t) nfs3svc_encode_##rest##res,    \
-   (kxdrproc_t) nfs3svc_release_##relt,                \
-   sizeof(struct nfsd3_##argt##args),          \
-   sizeof(struct nfsd3_##rest##res),           \
-   0,                                          \
-   cache,                                      \
-   respsize,                                   \
- }
-
 #define ST 1           /* status*/
 #define FH 17          /* filehandle with length */
 #define AT 21          /* attributes */
 #define pAT (1+AT)     /* post attributes - conditional */
 #define WC (7+pAT)     /* WCC attributes */
 
-static struct svc_procedure            nfsd_procedures3[22] = {
+static const struct svc_procedure nfsd_procedures3[22] = {
        [NFS3PROC_NULL] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_null,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_voidres,
+               .pc_func = nfsd3_proc_null,
+               .pc_encode = nfs3svc_encode_voidres,
                .pc_argsize = sizeof(struct nfsd3_voidargs),
                .pc_ressize = sizeof(struct nfsd3_voidres),
                .pc_cachetype = RC_NOCACHE,
                .pc_xdrressize = ST,
        },
        [NFS3PROC_GETATTR] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_getattr,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_fhandleargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_attrstatres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
+               .pc_func = nfsd3_proc_getattr,
+               .pc_decode = nfs3svc_decode_fhandleargs,
+               .pc_encode = nfs3svc_encode_attrstatres,
+               .pc_release = nfs3svc_release_fhandle,
                .pc_argsize = sizeof(struct nfsd3_fhandleargs),
                .pc_ressize = sizeof(struct nfsd3_attrstatres),
                .pc_cachetype = RC_NOCACHE,
                .pc_xdrressize = ST+AT,
        },
        [NFS3PROC_SETATTR] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_setattr,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_sattrargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_wccstatres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
+               .pc_func = nfsd3_proc_setattr,
+               .pc_decode = nfs3svc_decode_sattrargs,
+               .pc_encode = nfs3svc_encode_wccstatres,
+               .pc_release = nfs3svc_release_fhandle,
                .pc_argsize = sizeof(struct nfsd3_sattrargs),
                .pc_ressize = sizeof(struct nfsd3_wccstatres),
                .pc_cachetype = RC_REPLBUFF,
                .pc_xdrressize = ST+WC,
        },
        [NFS3PROC_LOOKUP] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_lookup,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_diropargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_diropres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
+               .pc_func = nfsd3_proc_lookup,
+               .pc_decode = nfs3svc_decode_diropargs,
+               .pc_encode = nfs3svc_encode_diropres,
+               .pc_release = nfs3svc_release_fhandle2,
                .pc_argsize = sizeof(struct nfsd3_diropargs),
                .pc_ressize = sizeof(struct nfsd3_diropres),
                .pc_cachetype = RC_NOCACHE,
                .pc_xdrressize = ST+FH+pAT+pAT,
        },
        [NFS3PROC_ACCESS] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_access,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_accessargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_accessres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
+               .pc_func = nfsd3_proc_access,
+               .pc_decode = nfs3svc_decode_accessargs,
+               .pc_encode = nfs3svc_encode_accessres,
+               .pc_release = nfs3svc_release_fhandle,
                .pc_argsize = sizeof(struct nfsd3_accessargs),
                .pc_ressize = sizeof(struct nfsd3_accessres),
                .pc_cachetype = RC_NOCACHE,
                .pc_xdrressize = ST+pAT+1,
        },
        [NFS3PROC_READLINK] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_readlink,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_readlinkargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_readlinkres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
+               .pc_func = nfsd3_proc_readlink,
+               .pc_decode = nfs3svc_decode_readlinkargs,
+               .pc_encode = nfs3svc_encode_readlinkres,
+               .pc_release = nfs3svc_release_fhandle,
                .pc_argsize = sizeof(struct nfsd3_readlinkargs),
                .pc_ressize = sizeof(struct nfsd3_readlinkres),
                .pc_cachetype = RC_NOCACHE,
                .pc_xdrressize = ST+pAT+1+NFS3_MAXPATHLEN/4,
        },
        [NFS3PROC_READ] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_read,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_readargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_readres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
+               .pc_func = nfsd3_proc_read,
+               .pc_decode = nfs3svc_decode_readargs,
+               .pc_encode = nfs3svc_encode_readres,
+               .pc_release = nfs3svc_release_fhandle,
                .pc_argsize = sizeof(struct nfsd3_readargs),
                .pc_ressize = sizeof(struct nfsd3_readres),
                .pc_cachetype = RC_NOCACHE,
                .pc_xdrressize = ST+pAT+4+NFSSVC_MAXBLKSIZE/4,
        },
        [NFS3PROC_WRITE] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_write,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_writeargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_writeres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
+               .pc_func = nfsd3_proc_write,
+               .pc_decode = nfs3svc_decode_writeargs,
+               .pc_encode = nfs3svc_encode_writeres,
+               .pc_release = nfs3svc_release_fhandle,
                .pc_argsize = sizeof(struct nfsd3_writeargs),
                .pc_ressize = sizeof(struct nfsd3_writeres),
                .pc_cachetype = RC_REPLBUFF,
                .pc_xdrressize = ST+WC+4,
        },
        [NFS3PROC_CREATE] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_create,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_createargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_createres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
+               .pc_func = nfsd3_proc_create,
+               .pc_decode = nfs3svc_decode_createargs,
+               .pc_encode = nfs3svc_encode_createres,
+               .pc_release = nfs3svc_release_fhandle2,
                .pc_argsize = sizeof(struct nfsd3_createargs),
                .pc_ressize = sizeof(struct nfsd3_createres),
                .pc_cachetype = RC_REPLBUFF,
                .pc_xdrressize = ST+(1+FH+pAT)+WC,
        },
        [NFS3PROC_MKDIR] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_mkdir,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_mkdirargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_createres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
+               .pc_func = nfsd3_proc_mkdir,
+               .pc_decode = nfs3svc_decode_mkdirargs,
+               .pc_encode = nfs3svc_encode_createres,
+               .pc_release = nfs3svc_release_fhandle2,
                .pc_argsize = sizeof(struct nfsd3_mkdirargs),
                .pc_ressize = sizeof(struct nfsd3_createres),
                .pc_cachetype = RC_REPLBUFF,
                .pc_xdrressize = ST+(1+FH+pAT)+WC,
        },
        [NFS3PROC_SYMLINK] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_symlink,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_symlinkargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_createres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
+               .pc_func = nfsd3_proc_symlink,
+               .pc_decode = nfs3svc_decode_symlinkargs,
+               .pc_encode = nfs3svc_encode_createres,
+               .pc_release = nfs3svc_release_fhandle2,
                .pc_argsize = sizeof(struct nfsd3_symlinkargs),
                .pc_ressize = sizeof(struct nfsd3_createres),
                .pc_cachetype = RC_REPLBUFF,
                .pc_xdrressize = ST+(1+FH+pAT)+WC,
        },
        [NFS3PROC_MKNOD] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_mknod,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_mknodargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_createres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
+               .pc_func = nfsd3_proc_mknod,
+               .pc_decode = nfs3svc_decode_mknodargs,
+               .pc_encode = nfs3svc_encode_createres,
+               .pc_release = nfs3svc_release_fhandle2,
                .pc_argsize = sizeof(struct nfsd3_mknodargs),
                .pc_ressize = sizeof(struct nfsd3_createres),
                .pc_cachetype = RC_REPLBUFF,
                .pc_xdrressize = ST+(1+FH+pAT)+WC,
        },
        [NFS3PROC_REMOVE] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_remove,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_diropargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_wccstatres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
+               .pc_func = nfsd3_proc_remove,
+               .pc_decode = nfs3svc_decode_diropargs,
+               .pc_encode = nfs3svc_encode_wccstatres,
+               .pc_release = nfs3svc_release_fhandle,
                .pc_argsize = sizeof(struct nfsd3_diropargs),
                .pc_ressize = sizeof(struct nfsd3_wccstatres),
                .pc_cachetype = RC_REPLBUFF,
                .pc_xdrressize = ST+WC,
        },
        [NFS3PROC_RMDIR] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_rmdir,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_diropargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_wccstatres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
+               .pc_func = nfsd3_proc_rmdir,
+               .pc_decode = nfs3svc_decode_diropargs,
+               .pc_encode = nfs3svc_encode_wccstatres,
+               .pc_release = nfs3svc_release_fhandle,
                .pc_argsize = sizeof(struct nfsd3_diropargs),
                .pc_ressize = sizeof(struct nfsd3_wccstatres),
                .pc_cachetype = RC_REPLBUFF,
                .pc_xdrressize = ST+WC,
        },
        [NFS3PROC_RENAME] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_rename,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_renameargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_renameres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
+               .pc_func = nfsd3_proc_rename,
+               .pc_decode = nfs3svc_decode_renameargs,
+               .pc_encode = nfs3svc_encode_renameres,
+               .pc_release = nfs3svc_release_fhandle2,
                .pc_argsize = sizeof(struct nfsd3_renameargs),
                .pc_ressize = sizeof(struct nfsd3_renameres),
                .pc_cachetype = RC_REPLBUFF,
                .pc_xdrressize = ST+WC+WC,
        },
        [NFS3PROC_LINK] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_link,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_linkargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_linkres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle2,
+               .pc_func = nfsd3_proc_link,
+               .pc_decode = nfs3svc_decode_linkargs,
+               .pc_encode = nfs3svc_encode_linkres,
+               .pc_release = nfs3svc_release_fhandle2,
                .pc_argsize = sizeof(struct nfsd3_linkargs),
                .pc_ressize = sizeof(struct nfsd3_linkres),
                .pc_cachetype = RC_REPLBUFF,
                .pc_xdrressize = ST+pAT+WC,
        },
        [NFS3PROC_READDIR] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_readdir,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_readdirargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_readdirres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
+               .pc_func = nfsd3_proc_readdir,
+               .pc_decode = nfs3svc_decode_readdirargs,
+               .pc_encode = nfs3svc_encode_readdirres,
+               .pc_release = nfs3svc_release_fhandle,
                .pc_argsize = sizeof(struct nfsd3_readdirargs),
                .pc_ressize = sizeof(struct nfsd3_readdirres),
                .pc_cachetype = RC_NOCACHE,
        },
        [NFS3PROC_READDIRPLUS] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_readdirplus,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_readdirplusargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_readdirres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
+               .pc_func = nfsd3_proc_readdirplus,
+               .pc_decode = nfs3svc_decode_readdirplusargs,
+               .pc_encode = nfs3svc_encode_readdirres,
+               .pc_release = nfs3svc_release_fhandle,
                .pc_argsize = sizeof(struct nfsd3_readdirplusargs),
                .pc_ressize = sizeof(struct nfsd3_readdirres),
                .pc_cachetype = RC_NOCACHE,
        },
        [NFS3PROC_FSSTAT] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_fsstat,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_fhandleargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_fsstatres,
+               .pc_func = nfsd3_proc_fsstat,
+               .pc_decode = nfs3svc_decode_fhandleargs,
+               .pc_encode = nfs3svc_encode_fsstatres,
                .pc_argsize = sizeof(struct nfsd3_fhandleargs),
                .pc_ressize = sizeof(struct nfsd3_fsstatres),
                .pc_cachetype = RC_NOCACHE,
                .pc_xdrressize = ST+pAT+2*6+1,
        },
        [NFS3PROC_FSINFO] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_fsinfo,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_fhandleargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_fsinfores,
+               .pc_func = nfsd3_proc_fsinfo,
+               .pc_decode = nfs3svc_decode_fhandleargs,
+               .pc_encode = nfs3svc_encode_fsinfores,
                .pc_argsize = sizeof(struct nfsd3_fhandleargs),
                .pc_ressize = sizeof(struct nfsd3_fsinfores),
                .pc_cachetype = RC_NOCACHE,
                .pc_xdrressize = ST+pAT+12,
        },
        [NFS3PROC_PATHCONF] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_pathconf,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_fhandleargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_pathconfres,
+               .pc_func = nfsd3_proc_pathconf,
+               .pc_decode = nfs3svc_decode_fhandleargs,
+               .pc_encode = nfs3svc_encode_pathconfres,
                .pc_argsize = sizeof(struct nfsd3_fhandleargs),
                .pc_ressize = sizeof(struct nfsd3_pathconfres),
                .pc_cachetype = RC_NOCACHE,
                .pc_xdrressize = ST+pAT+6,
        },
        [NFS3PROC_COMMIT] = {
-               .pc_func = (svc_procfunc) nfsd3_proc_commit,
-               .pc_decode = (kxdrproc_t) nfs3svc_decode_commitargs,
-               .pc_encode = (kxdrproc_t) nfs3svc_encode_commitres,
-               .pc_release = (kxdrproc_t) nfs3svc_release_fhandle,
+               .pc_func = nfsd3_proc_commit,
+               .pc_decode = nfs3svc_decode_commitargs,
+               .pc_encode = nfs3svc_encode_commitres,
+               .pc_release = nfs3svc_release_fhandle,
                .pc_argsize = sizeof(struct nfsd3_commitargs),
                .pc_ressize = sizeof(struct nfsd3_commitres),
                .pc_cachetype = RC_NOCACHE,
@@ -881,10 +890,12 @@ static struct svc_procedure               nfsd_procedures3[22] = {
        },
 };
 
-struct svc_version     nfsd_version3 = {
-               .vs_vers        = 3,
-               .vs_nproc       = 22,
-               .vs_proc        = nfsd_procedures3,
-               .vs_dispatch    = nfsd_dispatch,
-               .vs_xdrsize     = NFS3_SVC_XDRSIZE,
+static unsigned int nfsd_count3[ARRAY_SIZE(nfsd_procedures3)];
+const struct svc_version nfsd_version3 = {
+       .vs_vers        = 3,
+       .vs_nproc       = 22,
+       .vs_proc        = nfsd_procedures3,
+       .vs_dispatch    = nfsd_dispatch,
+       .vs_count       = nfsd_count3,
+       .vs_xdrsize     = NFS3_SVC_XDRSIZE,
 };
index 452334694a5d1f37cc480e5d1cf2873c4246019d..bf444b664011a891992b04435b739e30fbc17b0e 100644 (file)
@@ -260,7 +260,7 @@ void fill_post_wcc(struct svc_fh *fhp)
                printk("nfsd: inode locked twice during operation.\n");
 
        err = fh_getattr(fhp, &fhp->fh_post_attr);
-       fhp->fh_post_change = d_inode(fhp->fh_dentry)->i_version;
+       fhp->fh_post_change = nfsd4_change_attribute(d_inode(fhp->fh_dentry));
        if (err) {
                fhp->fh_post_saved = false;
                /* Grab the ctime anyway - set_change_info might use it */
@@ -273,8 +273,10 @@ void fill_post_wcc(struct svc_fh *fhp)
  * XDR decode functions
  */
 int
-nfs3svc_decode_fhandle(struct svc_rqst *rqstp, __be32 *p, struct nfsd_fhandle *args)
+nfs3svc_decode_fhandle(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd_fhandle *args = rqstp->rq_argp;
+
        p = decode_fh(p, &args->fh);
        if (!p)
                return 0;
@@ -282,9 +284,10 @@ nfs3svc_decode_fhandle(struct svc_rqst *rqstp, __be32 *p, struct nfsd_fhandle *a
 }
 
 int
-nfs3svc_decode_sattrargs(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_sattrargs *args)
+nfs3svc_decode_sattrargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_sattrargs *args = rqstp->rq_argp;
+
        p = decode_fh(p, &args->fh);
        if (!p)
                return 0;
@@ -300,9 +303,10 @@ nfs3svc_decode_sattrargs(struct svc_rqst *rqstp, __be32 *p,
 }
 
 int
-nfs3svc_decode_diropargs(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_diropargs *args)
+nfs3svc_decode_diropargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_diropargs *args = rqstp->rq_argp;
+
        if (!(p = decode_fh(p, &args->fh))
         || !(p = decode_filename(p, &args->name, &args->len)))
                return 0;
@@ -311,9 +315,10 @@ nfs3svc_decode_diropargs(struct svc_rqst *rqstp, __be32 *p,
 }
 
 int
-nfs3svc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_accessargs *args)
+nfs3svc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_accessargs *args = rqstp->rq_argp;
+
        p = decode_fh(p, &args->fh);
        if (!p)
                return 0;
@@ -323,9 +328,9 @@ nfs3svc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p,
 }
 
 int
-nfs3svc_decode_readargs(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_readargs *args)
+nfs3svc_decode_readargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_readargs *args = rqstp->rq_argp;
        unsigned int len;
        int v;
        u32 max_blocksize = svc_max_payload(rqstp);
@@ -353,9 +358,9 @@ nfs3svc_decode_readargs(struct svc_rqst *rqstp, __be32 *p,
 }
 
 int
-nfs3svc_decode_writeargs(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_writeargs *args)
+nfs3svc_decode_writeargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_writeargs *args = rqstp->rq_argp;
        unsigned int len, v, hdr, dlen;
        u32 max_blocksize = svc_max_payload(rqstp);
        struct kvec *head = rqstp->rq_arg.head;
@@ -413,9 +418,10 @@ nfs3svc_decode_writeargs(struct svc_rqst *rqstp, __be32 *p,
 }
 
 int
-nfs3svc_decode_createargs(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_createargs *args)
+nfs3svc_decode_createargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_createargs *args = rqstp->rq_argp;
+
        if (!(p = decode_fh(p, &args->fh))
         || !(p = decode_filename(p, &args->name, &args->len)))
                return 0;
@@ -435,10 +441,12 @@ nfs3svc_decode_createargs(struct svc_rqst *rqstp, __be32 *p,
 
        return xdr_argsize_check(rqstp, p);
 }
+
 int
-nfs3svc_decode_mkdirargs(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_createargs *args)
+nfs3svc_decode_mkdirargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_createargs *args = rqstp->rq_argp;
+
        if (!(p = decode_fh(p, &args->fh)) ||
            !(p = decode_filename(p, &args->name, &args->len)))
                return 0;
@@ -448,9 +456,9 @@ nfs3svc_decode_mkdirargs(struct svc_rqst *rqstp, __be32 *p,
 }
 
 int
-nfs3svc_decode_symlinkargs(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_symlinkargs *args)
+nfs3svc_decode_symlinkargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_symlinkargs *args = rqstp->rq_argp;
        unsigned int len, avail;
        char *old, *new;
        struct kvec *vec;
@@ -500,9 +508,10 @@ nfs3svc_decode_symlinkargs(struct svc_rqst *rqstp, __be32 *p,
 }
 
 int
-nfs3svc_decode_mknodargs(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_mknodargs *args)
+nfs3svc_decode_mknodargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_mknodargs *args = rqstp->rq_argp;
+
        if (!(p = decode_fh(p, &args->fh))
         || !(p = decode_filename(p, &args->name, &args->len)))
                return 0;
@@ -522,9 +531,10 @@ nfs3svc_decode_mknodargs(struct svc_rqst *rqstp, __be32 *p,
 }
 
 int
-nfs3svc_decode_renameargs(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_renameargs *args)
+nfs3svc_decode_renameargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_renameargs *args = rqstp->rq_argp;
+
        if (!(p = decode_fh(p, &args->ffh))
         || !(p = decode_filename(p, &args->fname, &args->flen))
         || !(p = decode_fh(p, &args->tfh))
@@ -535,9 +545,10 @@ nfs3svc_decode_renameargs(struct svc_rqst *rqstp, __be32 *p,
 }
 
 int
-nfs3svc_decode_readlinkargs(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_readlinkargs *args)
+nfs3svc_decode_readlinkargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_readlinkargs *args = rqstp->rq_argp;
+
        p = decode_fh(p, &args->fh);
        if (!p)
                return 0;
@@ -547,9 +558,10 @@ nfs3svc_decode_readlinkargs(struct svc_rqst *rqstp, __be32 *p,
 }
 
 int
-nfs3svc_decode_linkargs(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_linkargs *args)
+nfs3svc_decode_linkargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_linkargs *args = rqstp->rq_argp;
+
        if (!(p = decode_fh(p, &args->ffh))
         || !(p = decode_fh(p, &args->tfh))
         || !(p = decode_filename(p, &args->tname, &args->tlen)))
@@ -559,9 +571,9 @@ nfs3svc_decode_linkargs(struct svc_rqst *rqstp, __be32 *p,
 }
 
 int
-nfs3svc_decode_readdirargs(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_readdirargs *args)
+nfs3svc_decode_readdirargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_readdirargs *args = rqstp->rq_argp;
        p = decode_fh(p, &args->fh);
        if (!p)
                return 0;
@@ -576,9 +588,9 @@ nfs3svc_decode_readdirargs(struct svc_rqst *rqstp, __be32 *p,
 }
 
 int
-nfs3svc_decode_readdirplusargs(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_readdirargs *args)
+nfs3svc_decode_readdirplusargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_readdirargs *args = rqstp->rq_argp;
        int len;
        u32 max_blocksize = svc_max_payload(rqstp);
 
@@ -602,9 +614,9 @@ nfs3svc_decode_readdirplusargs(struct svc_rqst *rqstp, __be32 *p,
 }
 
 int
-nfs3svc_decode_commitargs(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_commitargs *args)
+nfs3svc_decode_commitargs(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_commitargs *args = rqstp->rq_argp;
        p = decode_fh(p, &args->fh);
        if (!p)
                return 0;
@@ -622,16 +634,17 @@ nfs3svc_decode_commitargs(struct svc_rqst *rqstp, __be32 *p,
  * will work properly.
  */
 int
-nfs3svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p, void *dummy)
+nfs3svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p)
 {
        return xdr_ressize_check(rqstp, p);
 }
 
 /* GETATTR */
 int
-nfs3svc_encode_attrstat(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_attrstat *resp)
+nfs3svc_encode_attrstat(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_attrstat *resp = rqstp->rq_resp;
+
        if (resp->status == 0) {
                lease_get_mtime(d_inode(resp->fh.fh_dentry),
                                &resp->stat.mtime);
@@ -642,18 +655,20 @@ nfs3svc_encode_attrstat(struct svc_rqst *rqstp, __be32 *p,
 
 /* SETATTR, REMOVE, RMDIR */
 int
-nfs3svc_encode_wccstat(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_attrstat *resp)
+nfs3svc_encode_wccstat(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_attrstat *resp = rqstp->rq_resp;
+
        p = encode_wcc_data(rqstp, p, &resp->fh);
        return xdr_ressize_check(rqstp, p);
 }
 
 /* LOOKUP */
 int
-nfs3svc_encode_diropres(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_diropres *resp)
+nfs3svc_encode_diropres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_diropres *resp = rqstp->rq_resp;
+
        if (resp->status == 0) {
                p = encode_fh(p, &resp->fh);
                p = encode_post_op_attr(rqstp, p, &resp->fh);
@@ -664,9 +679,10 @@ nfs3svc_encode_diropres(struct svc_rqst *rqstp, __be32 *p,
 
 /* ACCESS */
 int
-nfs3svc_encode_accessres(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_accessres *resp)
+nfs3svc_encode_accessres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_accessres *resp = rqstp->rq_resp;
+
        p = encode_post_op_attr(rqstp, p, &resp->fh);
        if (resp->status == 0)
                *p++ = htonl(resp->access);
@@ -675,9 +691,10 @@ nfs3svc_encode_accessres(struct svc_rqst *rqstp, __be32 *p,
 
 /* READLINK */
 int
-nfs3svc_encode_readlinkres(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_readlinkres *resp)
+nfs3svc_encode_readlinkres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_readlinkres *resp = rqstp->rq_resp;
+
        p = encode_post_op_attr(rqstp, p, &resp->fh);
        if (resp->status == 0) {
                *p++ = htonl(resp->len);
@@ -696,9 +713,10 @@ nfs3svc_encode_readlinkres(struct svc_rqst *rqstp, __be32 *p,
 
 /* READ */
 int
-nfs3svc_encode_readres(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_readres *resp)
+nfs3svc_encode_readres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_readres *resp = rqstp->rq_resp;
+
        p = encode_post_op_attr(rqstp, p, &resp->fh);
        if (resp->status == 0) {
                *p++ = htonl(resp->count);
@@ -720,9 +738,9 @@ nfs3svc_encode_readres(struct svc_rqst *rqstp, __be32 *p,
 
 /* WRITE */
 int
-nfs3svc_encode_writeres(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_writeres *resp)
+nfs3svc_encode_writeres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_writeres *resp = rqstp->rq_resp;
        struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
 
        p = encode_wcc_data(rqstp, p, &resp->fh);
@@ -737,9 +755,10 @@ nfs3svc_encode_writeres(struct svc_rqst *rqstp, __be32 *p,
 
 /* CREATE, MKDIR, SYMLINK, MKNOD */
 int
-nfs3svc_encode_createres(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_diropres *resp)
+nfs3svc_encode_createres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_diropres *resp = rqstp->rq_resp;
+
        if (resp->status == 0) {
                *p++ = xdr_one;
                p = encode_fh(p, &resp->fh);
@@ -751,9 +770,10 @@ nfs3svc_encode_createres(struct svc_rqst *rqstp, __be32 *p,
 
 /* RENAME */
 int
-nfs3svc_encode_renameres(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_renameres *resp)
+nfs3svc_encode_renameres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_renameres *resp = rqstp->rq_resp;
+
        p = encode_wcc_data(rqstp, p, &resp->ffh);
        p = encode_wcc_data(rqstp, p, &resp->tfh);
        return xdr_ressize_check(rqstp, p);
@@ -761,9 +781,10 @@ nfs3svc_encode_renameres(struct svc_rqst *rqstp, __be32 *p,
 
 /* LINK */
 int
-nfs3svc_encode_linkres(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_linkres *resp)
+nfs3svc_encode_linkres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_linkres *resp = rqstp->rq_resp;
+
        p = encode_post_op_attr(rqstp, p, &resp->fh);
        p = encode_wcc_data(rqstp, p, &resp->tfh);
        return xdr_ressize_check(rqstp, p);
@@ -771,9 +792,10 @@ nfs3svc_encode_linkres(struct svc_rqst *rqstp, __be32 *p,
 
 /* READDIR */
 int
-nfs3svc_encode_readdirres(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_readdirres *resp)
+nfs3svc_encode_readdirres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_readdirres *resp = rqstp->rq_resp;
+
        p = encode_post_op_attr(rqstp, p, &resp->fh);
 
        if (resp->status == 0) {
@@ -1021,9 +1043,9 @@ nfs3svc_encode_entry_plus(void *cd, const char *name,
 
 /* FSSTAT */
 int
-nfs3svc_encode_fsstatres(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_fsstatres *resp)
+nfs3svc_encode_fsstatres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_fsstatres *resp = rqstp->rq_resp;
        struct kstatfs  *s = &resp->stats;
        u64             bs = s->f_bsize;
 
@@ -1043,9 +1065,10 @@ nfs3svc_encode_fsstatres(struct svc_rqst *rqstp, __be32 *p,
 
 /* FSINFO */
 int
-nfs3svc_encode_fsinfores(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_fsinfores *resp)
+nfs3svc_encode_fsinfores(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_fsinfores *resp = rqstp->rq_resp;
+
        *p++ = xdr_zero;        /* no post_op_attr */
 
        if (resp->status == 0) {
@@ -1067,9 +1090,10 @@ nfs3svc_encode_fsinfores(struct svc_rqst *rqstp, __be32 *p,
 
 /* PATHCONF */
 int
-nfs3svc_encode_pathconfres(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_pathconfres *resp)
+nfs3svc_encode_pathconfres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_pathconfres *resp = rqstp->rq_resp;
+
        *p++ = xdr_zero;        /* no post_op_attr */
 
        if (resp->status == 0) {
@@ -1086,9 +1110,9 @@ nfs3svc_encode_pathconfres(struct svc_rqst *rqstp, __be32 *p,
 
 /* COMMIT */
 int
-nfs3svc_encode_commitres(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_commitres *resp)
+nfs3svc_encode_commitres(struct svc_rqst *rqstp, __be32 *p)
 {
+       struct nfsd3_commitres *resp = rqstp->rq_resp;
        struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
 
        p = encode_wcc_data(rqstp, p, &resp->fh);
@@ -1103,19 +1127,19 @@ nfs3svc_encode_commitres(struct svc_rqst *rqstp, __be32 *p,
 /*
  * XDR release functions
  */
-int
-nfs3svc_release_fhandle(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_attrstat *resp)
+void
+nfs3svc_release_fhandle(struct svc_rqst *rqstp)
 {
+       struct nfsd3_attrstat *resp = rqstp->rq_resp;
+
        fh_put(&resp->fh);
-       return 1;
 }
 
-int
-nfs3svc_release_fhandle2(struct svc_rqst *rqstp, __be32 *p,
-                                       struct nfsd3_fhandle_pair *resp)
+void
+nfs3svc_release_fhandle2(struct svc_rqst *rqstp)
 {
+       struct nfsd3_fhandle_pair *resp = rqstp->rq_resp;
+
        fh_put(&resp->fh1);
        fh_put(&resp->fh2);
-       return 1;
 }
index 0274db6e65d0d6775d0b6c9c9e72e2f0c6a5fa57..b45083c0f9ae8a78838d84145f71efaf1eab4d89 100644 (file)
@@ -468,7 +468,7 @@ static int decode_cb_sequence4res(struct xdr_stream *xdr,
  * NB: Without this zero space reservation, callbacks over krb5p fail
  */
 static void nfs4_xdr_enc_cb_null(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                void *__unused)
+                                const void *__unused)
 {
        xdr_reserve_space(xdr, 0);
 }
@@ -477,8 +477,9 @@ static void nfs4_xdr_enc_cb_null(struct rpc_rqst *req, struct xdr_stream *xdr,
  * 20.2. Operation 4: CB_RECALL - Recall a Delegation
  */
 static void nfs4_xdr_enc_cb_recall(struct rpc_rqst *req, struct xdr_stream *xdr,
-                                  const struct nfsd4_callback *cb)
+                                  const void *data)
 {
+       const struct nfsd4_callback *cb = data;
        const struct nfs4_delegation *dp = cb_to_delegation(cb);
        struct nfs4_cb_compound_hdr hdr = {
                .ident = cb->cb_clp->cl_cb_ident,
@@ -512,8 +513,9 @@ static int nfs4_xdr_dec_cb_null(struct rpc_rqst *req, struct xdr_stream *xdr,
  */
 static int nfs4_xdr_dec_cb_recall(struct rpc_rqst *rqstp,
                                  struct xdr_stream *xdr,
-                                 struct nfsd4_callback *cb)
+                                 void *data)
 {
+       struct nfsd4_callback *cb = data;
        struct nfs4_cb_compound_hdr hdr;
        int status;
 
@@ -585,8 +587,9 @@ static void encode_cb_layout4args(struct xdr_stream *xdr,
 
 static void nfs4_xdr_enc_cb_layout(struct rpc_rqst *req,
                                   struct xdr_stream *xdr,
-                                  const struct nfsd4_callback *cb)
+                                  const void *data)
 {
+       const struct nfsd4_callback *cb = data;
        const struct nfs4_layout_stateid *ls =
                container_of(cb, struct nfs4_layout_stateid, ls_recall);
        struct nfs4_cb_compound_hdr hdr = {
@@ -602,8 +605,9 @@ static void nfs4_xdr_enc_cb_layout(struct rpc_rqst *req,
 
 static int nfs4_xdr_dec_cb_layout(struct rpc_rqst *rqstp,
                                  struct xdr_stream *xdr,
-                                 struct nfsd4_callback *cb)
+                                 void *data)
 {
+       struct nfsd4_callback *cb = data;
        struct nfs4_cb_compound_hdr hdr;
        int status;
 
@@ -631,8 +635,9 @@ static void encode_stateowner(struct xdr_stream *xdr, struct nfs4_stateowner *so
 
 static void nfs4_xdr_enc_cb_notify_lock(struct rpc_rqst *req,
                                        struct xdr_stream *xdr,
-                                       const struct nfsd4_callback *cb)
+                                       const void *data)
 {
+       const struct nfsd4_callback *cb = data;
        const struct nfsd4_blocked_lock *nbl =
                container_of(cb, struct nfsd4_blocked_lock, nbl_cb);
        struct nfs4_lockowner *lo = (struct nfs4_lockowner *)nbl->nbl_lock.fl_owner;
@@ -659,8 +664,9 @@ static void nfs4_xdr_enc_cb_notify_lock(struct rpc_rqst *req,
 
 static int nfs4_xdr_dec_cb_notify_lock(struct rpc_rqst *rqstp,
                                        struct xdr_stream *xdr,
-                                       struct nfsd4_callback *cb)
+                                       void *data)
 {
+       struct nfsd4_callback *cb = data;
        struct nfs4_cb_compound_hdr hdr;
        int status;
 
@@ -682,15 +688,15 @@ static int nfs4_xdr_dec_cb_notify_lock(struct rpc_rqst *rqstp,
 #define PROC(proc, call, argtype, restype)                             \
 [NFSPROC4_CLNT_##proc] = {                                             \
        .p_proc    = NFSPROC4_CB_##call,                                \
-       .p_encode  = (kxdreproc_t)nfs4_xdr_enc_##argtype,               \
-       .p_decode  = (kxdrdproc_t)nfs4_xdr_dec_##restype,               \
+       .p_encode  = nfs4_xdr_enc_##argtype,            \
+       .p_decode  = nfs4_xdr_dec_##restype,                            \
        .p_arglen  = NFS4_enc_##argtype##_sz,                           \
        .p_replen  = NFS4_dec_##restype##_sz,                           \
        .p_statidx = NFSPROC4_CB_##call,                                \
        .p_name    = #proc,                                             \
 }
 
-static struct rpc_procinfo nfs4_cb_procedures[] = {
+static const struct rpc_procinfo nfs4_cb_procedures[] = {
        PROC(CB_NULL,   NULL,           cb_null,        cb_null),
        PROC(CB_RECALL, COMPOUND,       cb_recall,      cb_recall),
 #ifdef CONFIG_NFSD_PNFS
@@ -699,7 +705,8 @@ static struct rpc_procinfo nfs4_cb_procedures[] = {
        PROC(CB_NOTIFY_LOCK,    COMPOUND,       cb_notify_lock, cb_notify_lock),
 };
 
-static struct rpc_version nfs_cb_version4 = {
+static unsigned int nfs4_cb_counts[ARRAY_SIZE(nfs4_cb_procedures)];
+static const struct rpc_version nfs_cb_version4 = {
 /*
  * Note on the callback rpc program version number: despite language in rfc
  * 5661 section 18.36.3 requiring servers to use 4 in this field, the
@@ -709,7 +716,8 @@ static struct rpc_version nfs_cb_version4 = {
  */
        .number                 = 1,
        .nrprocs                = ARRAY_SIZE(nfs4_cb_procedures),
-       .procs                  = nfs4_cb_procedures
+       .procs                  = nfs4_cb_procedures,
+       .counts                 = nfs4_cb_counts,
 };
 
 static const struct rpc_version *nfs_cb_version[] = {
index dadb3bf305b22f352a3f91a2df06b30284b4891c..d27e75ad25e349fb07628f0d7af414e786005709 100644 (file)
@@ -344,8 +344,9 @@ copy_clientid(clientid_t *clid, struct nfsd4_session *session)
 
 static __be32
 nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-          struct nfsd4_open *open)
+          union nfsd4_op_u *u)
 {
+       struct nfsd4_open *open = &u->open;
        __be32 status;
        struct svc_fh *resfh = NULL;
        struct net *net = SVC_NET(rqstp);
@@ -467,14 +468,14 @@ out:
  */
 static __be32 nfsd4_open_omfg(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_op *op)
 {
-       struct nfsd4_open *open = (struct nfsd4_open *)&op->u;
+       struct nfsd4_open *open = &op->u.open;
 
        if (!seqid_mutating_err(ntohl(op->status)))
                return op->status;
        if (nfsd4_has_session(cstate))
                return op->status;
        open->op_xdr_error = op->status;
-       return nfsd4_open(rqstp, cstate, open);
+       return nfsd4_open(rqstp, cstate, &op->u);
 }
 
 /*
@@ -482,19 +483,21 @@ static __be32 nfsd4_open_omfg(struct svc_rqst *rqstp, struct nfsd4_compound_stat
  */
 static __be32
 nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-           struct svc_fh **getfh)
+           union nfsd4_op_u *u)
 {
        if (!cstate->current_fh.fh_dentry)
                return nfserr_nofilehandle;
 
-       *getfh = &cstate->current_fh;
+       u->getfh = &cstate->current_fh;
        return nfs_ok;
 }
 
 static __be32
 nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-           struct nfsd4_putfh *putfh)
+           union nfsd4_op_u *u)
 {
+       struct nfsd4_putfh *putfh = &u->putfh;
+
        fh_put(&cstate->current_fh);
        cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen;
        memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval,
@@ -504,7 +507,7 @@ nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 
 static __be32
 nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-               void *arg)
+               union nfsd4_op_u *u)
 {
        __be32 status;
 
@@ -515,7 +518,7 @@ nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 
 static __be32
 nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-               void *arg)
+               union nfsd4_op_u *u)
 {
        if (!cstate->save_fh.fh_dentry)
                return nfserr_restorefh;
@@ -530,7 +533,7 @@ nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 
 static __be32
 nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-            void *arg)
+            union nfsd4_op_u *u)
 {
        if (!cstate->current_fh.fh_dentry)
                return nfserr_nofilehandle;
@@ -548,8 +551,10 @@ nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  */
 static __be32
 nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-            struct nfsd4_access *access)
+            union nfsd4_op_u *u)
 {
+       struct nfsd4_access *access = &u->access;
+
        if (access->ac_req_access & ~NFS3_ACCESS_FULL)
                return nfserr_inval;
 
@@ -574,8 +579,10 @@ static void gen_boot_verifier(nfs4_verifier *verifier, struct net *net)
 
 static __be32
 nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-            struct nfsd4_commit *commit)
+            union nfsd4_op_u *u)
 {
+       struct nfsd4_commit *commit = &u->commit;
+
        gen_boot_verifier(&commit->co_verf, SVC_NET(rqstp));
        return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset,
                             commit->co_count);
@@ -583,8 +590,9 @@ nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 
 static __be32
 nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-            struct nfsd4_create *create)
+            union nfsd4_op_u *u)
 {
+       struct nfsd4_create *create = &u->create;
        struct svc_fh resfh;
        __be32 status;
        dev_t rdev;
@@ -670,8 +678,9 @@ out:
 
 static __be32
 nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-             struct nfsd4_getattr *getattr)
+             union nfsd4_op_u *u)
 {
+       struct nfsd4_getattr *getattr = &u->getattr;
        __be32 status;
 
        status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
@@ -691,8 +700,9 @@ nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 
 static __be32
 nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-          struct nfsd4_link *link)
+          union nfsd4_op_u *u)
 {
+       struct nfsd4_link *link = &u->link;
        __be32 status = nfserr_nofilehandle;
 
        if (!cstate->save_fh.fh_dentry)
@@ -723,24 +733,25 @@ static __be32 nfsd4_do_lookupp(struct svc_rqst *rqstp, struct svc_fh *fh)
 
 static __be32
 nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-             void *arg)
+             union nfsd4_op_u *u)
 {
        return nfsd4_do_lookupp(rqstp, &cstate->current_fh);
 }
 
 static __be32
 nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-            struct nfsd4_lookup *lookup)
+            union nfsd4_op_u *u)
 {
        return nfsd_lookup(rqstp, &cstate->current_fh,
-                          lookup->lo_name, lookup->lo_len,
+                          u->lookup.lo_name, u->lookup.lo_len,
                           &cstate->current_fh);
 }
 
 static __be32
 nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-          struct nfsd4_read *read)
+          union nfsd4_op_u *u)
 {
+       struct nfsd4_read *read = &u->read;
        __be32 status;
 
        read->rd_filp = NULL;
@@ -775,8 +786,9 @@ out:
 
 static __be32
 nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-             struct nfsd4_readdir *readdir)
+             union nfsd4_op_u *u)
 {
+       struct nfsd4_readdir *readdir = &u->readdir;
        u64 cookie = readdir->rd_cookie;
        static const nfs4_verifier zeroverf;
 
@@ -800,17 +812,18 @@ nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 
 static __be32
 nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-              struct nfsd4_readlink *readlink)
+              union nfsd4_op_u *u)
 {
-       readlink->rl_rqstp = rqstp;
-       readlink->rl_fhp = &cstate->current_fh;
+       u->readlink.rl_rqstp = rqstp;
+       u->readlink.rl_fhp = &cstate->current_fh;
        return nfs_ok;
 }
 
 static __be32
 nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-            struct nfsd4_remove *remove)
+            union nfsd4_op_u *u)
 {
+       struct nfsd4_remove *remove = &u->remove;
        __be32 status;
 
        if (opens_in_grace(SVC_NET(rqstp)))
@@ -826,8 +839,9 @@ nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 
 static __be32
 nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-            struct nfsd4_rename *rename)
+            union nfsd4_op_u *u)
 {
+       struct nfsd4_rename *rename = &u->rename;
        __be32 status = nfserr_nofilehandle;
 
        if (!cstate->save_fh.fh_dentry)
@@ -847,8 +861,9 @@ nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 
 static __be32
 nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-             struct nfsd4_secinfo *secinfo)
+             union nfsd4_op_u *u)
 {
+       struct nfsd4_secinfo *secinfo = &u->secinfo;
        struct svc_export *exp;
        struct dentry *dentry;
        __be32 err;
@@ -876,11 +891,11 @@ nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 
 static __be32
 nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-             struct nfsd4_secinfo_no_name *sin)
+               union nfsd4_op_u *u)
 {
        __be32 err;
 
-       switch (sin->sin_style) {
+       switch (u->secinfo_no_name.sin_style) {
        case NFS4_SECINFO_STYLE4_CURRENT_FH:
                break;
        case NFS4_SECINFO_STYLE4_PARENT:
@@ -892,15 +907,16 @@ nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstat
                return nfserr_inval;
        }
 
-       sin->sin_exp = exp_get(cstate->current_fh.fh_export);
+       u->secinfo_no_name.sin_exp = exp_get(cstate->current_fh.fh_export);
        fh_put(&cstate->current_fh);
        return nfs_ok;
 }
 
 static __be32
 nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-             struct nfsd4_setattr *setattr)
+             union nfsd4_op_u *u)
 {
+       struct nfsd4_setattr *setattr = &u->setattr;
        __be32 status = nfs_ok;
        int err;
 
@@ -960,8 +976,9 @@ static int fill_in_write_vector(struct kvec *vec, struct nfsd4_write *write)
 
 static __be32
 nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-           struct nfsd4_write *write)
+           union nfsd4_op_u *u)
 {
+       struct nfsd4_write *write = &u->write;
        stateid_t *stateid = &write->wr_stateid;
        struct file *filp = NULL;
        __be32 status = nfs_ok;
@@ -1034,8 +1051,9 @@ out_put_src:
 
 static __be32
 nfsd4_clone(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-               struct nfsd4_clone *clone)
+               union nfsd4_op_u *u)
 {
+       struct nfsd4_clone *clone = &u->clone;
        struct file *src, *dst;
        __be32 status;
 
@@ -1055,8 +1073,9 @@ out:
 
 static __be32
 nfsd4_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-               struct nfsd4_copy *copy)
+               union nfsd4_op_u *u)
 {
+       struct nfsd4_copy *copy = &u->copy;
        struct file *src, *dst;
        __be32 status;
        ssize_t bytes;
@@ -1111,23 +1130,24 @@ nfsd4_fallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 
 static __be32
 nfsd4_allocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-              struct nfsd4_fallocate *fallocate)
+              union nfsd4_op_u *u)
 {
-       return nfsd4_fallocate(rqstp, cstate, fallocate, 0);
+       return nfsd4_fallocate(rqstp, cstate, &u->allocate, 0);
 }
 
 static __be32
 nfsd4_deallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-                struct nfsd4_fallocate *fallocate)
+                union nfsd4_op_u *u)
 {
-       return nfsd4_fallocate(rqstp, cstate, fallocate,
+       return nfsd4_fallocate(rqstp, cstate, &u->deallocate,
                               FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE);
 }
 
 static __be32
 nfsd4_seek(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-               struct nfsd4_seek *seek)
+          union nfsd4_op_u *u)
 {
+       struct nfsd4_seek *seek = &u->seek;
        int whence;
        __be32 status;
        struct file *file;
@@ -1232,21 +1252,21 @@ out_kfree:
 
 static __be32
 nfsd4_nverify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-             struct nfsd4_verify *verify)
+             union nfsd4_op_u *u)
 {
        __be32 status;
 
-       status = _nfsd4_verify(rqstp, cstate, verify);
+       status = _nfsd4_verify(rqstp, cstate, &u->verify);
        return status == nfserr_not_same ? nfs_ok : status;
 }
 
 static __be32
 nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
-            struct nfsd4_verify *verify)
+            union nfsd4_op_u *u)
 {
        __be32 status;
 
-       status = _nfsd4_verify(rqstp, cstate, verify);
+       status = _nfsd4_verify(rqstp, cstate, &u->nverify);
        return status == nfserr_same ? nfs_ok : status;
 }
 
@@ -1271,9 +1291,9 @@ nfsd4_layout_verify(struct svc_export *exp, unsigned int layout_type)
 
 static __be32
 nfsd4_getdeviceinfo(struct svc_rqst *rqstp,
-               struct nfsd4_compound_state *cstate,
-               struct nfsd4_getdeviceinfo *gdp)
+               struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
 {
+       struct nfsd4_getdeviceinfo *gdp = &u->getdeviceinfo;
        const struct nfsd4_layout_ops *ops;
        struct nfsd4_deviceid_map *map;
        struct svc_export *exp;
@@ -1317,9 +1337,9 @@ out:
 
 static __be32
 nfsd4_layoutget(struct svc_rqst *rqstp,
-               struct nfsd4_compound_state *cstate,
-               struct nfsd4_layoutget *lgp)
+               struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
 {
+       struct nfsd4_layoutget *lgp = &u->layoutget;
        struct svc_fh *current_fh = &cstate->current_fh;
        const struct nfsd4_layout_ops *ops;
        struct nfs4_layout_stateid *ls;
@@ -1397,9 +1417,9 @@ out:
 
 static __be32
 nfsd4_layoutcommit(struct svc_rqst *rqstp,
-               struct nfsd4_compound_state *cstate,
-               struct nfsd4_layoutcommit *lcp)
+               struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
 {
+       struct nfsd4_layoutcommit *lcp = &u->layoutcommit;
        const struct nfsd4_layout_seg *seg = &lcp->lc_seg;
        struct svc_fh *current_fh = &cstate->current_fh;
        const struct nfsd4_layout_ops *ops;
@@ -1461,9 +1481,9 @@ out:
 
 static __be32
 nfsd4_layoutreturn(struct svc_rqst *rqstp,
-               struct nfsd4_compound_state *cstate,
-               struct nfsd4_layoutreturn *lrp)
+               struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
 {
+       struct nfsd4_layoutreturn *lrp = &u->layoutreturn;
        struct svc_fh *current_fh = &cstate->current_fh;
        __be32 nfserr;
 
@@ -1510,7 +1530,7 @@ out:
  * NULL call.
  */
 static __be32
-nfsd4_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
+nfsd4_proc_null(struct svc_rqst *rqstp)
 {
        return nfs_ok;
 }
@@ -1521,12 +1541,6 @@ static inline void nfsd4_increment_op_stats(u32 opnum)
                nfsdstats.nfs4_opcount[opnum]++;
 }
 
-typedef __be32(*nfsd4op_func)(struct svc_rqst *, struct nfsd4_compound_state *,
-                             void *);
-typedef u32(*nfsd4op_rsize)(struct svc_rqst *, struct nfsd4_op *op);
-typedef void(*stateid_setter)(struct nfsd4_compound_state *, void *);
-typedef void(*stateid_getter)(struct nfsd4_compound_state *, void *);
-
 enum nfsd4_op_flags {
        ALLOWED_WITHOUT_FH = 1 << 0,    /* No current filehandle required */
        ALLOWED_ON_ABSENT_FS = 1 << 1,  /* ops processed on absent fs */
@@ -1558,16 +1572,19 @@ enum nfsd4_op_flags {
 };
 
 struct nfsd4_operation {
-       nfsd4op_func op_func;
+       __be32 (*op_func)(struct svc_rqst *, struct nfsd4_compound_state *,
+                       union nfsd4_op_u *);
        u32 op_flags;
        char *op_name;
        /* Try to get response size before operation */
-       nfsd4op_rsize op_rsize_bop;
-       stateid_getter op_get_currentstateid;
-       stateid_setter op_set_currentstateid;
+       u32 (*op_rsize_bop)(struct svc_rqst *, struct nfsd4_op *);
+       void (*op_get_currentstateid)(struct nfsd4_compound_state *,
+                       union nfsd4_op_u *);
+       void (*op_set_currentstateid)(struct nfsd4_compound_state *,
+                       union nfsd4_op_u *);
 };
 
-static struct nfsd4_operation nfsd4_ops[];
+static const struct nfsd4_operation nfsd4_ops[];
 
 static const char *nfsd4_op_name(unsigned opnum);
 
@@ -1604,7 +1621,7 @@ static __be32 nfs41_check_op_ordering(struct nfsd4_compoundargs *args)
        return nfs_ok;
 }
 
-static inline struct nfsd4_operation *OPDESC(struct nfsd4_op *op)
+static inline const struct nfsd4_operation *OPDESC(struct nfsd4_op *op)
 {
        return &nfsd4_ops[op->opnum];
 }
@@ -1622,10 +1639,9 @@ static bool need_wrongsec_check(struct svc_rqst *rqstp)
        struct nfsd4_compoundargs *argp = rqstp->rq_argp;
        struct nfsd4_op *this = &argp->ops[resp->opcnt - 1];
        struct nfsd4_op *next = &argp->ops[resp->opcnt];
-       struct nfsd4_operation *thisd;
-       struct nfsd4_operation *nextd;
+       const struct nfsd4_operation *thisd = OPDESC(this);
+       const struct nfsd4_operation *nextd;
 
-       thisd = OPDESC(this);
        /*
         * Most ops check wronsec on our own; only the putfh-like ops
         * have special rules.
@@ -1673,12 +1689,12 @@ static void svcxdr_init_encode(struct svc_rqst *rqstp,
  * COMPOUND call.
  */
 static __be32
-nfsd4_proc_compound(struct svc_rqst *rqstp,
-                   struct nfsd4_compoundargs *args,
-                   struct nfsd4_compoundres *resp)
+nfsd4_proc_compound(struct svc_rqst *rqstp)
 {
+       struct nfsd4_compoundargs *args = rqstp->rq_argp;
+       struct nfsd4_compoundres *resp = rqstp->rq_resp;
        struct nfsd4_op *op;
-       struct nfsd4_operation *opdesc;
+       const struct nfsd4_operation *opdesc;
        struct nfsd4_compound_state *cstate = &resp->cstate;
        struct svc_fh *current_fh = &cstate->current_fh;
        struct svc_fh *save_fh = &cstate->save_fh;
@@ -2091,360 +2107,360 @@ static inline u32 nfsd4_seek_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
        return (op_encode_hdr_size + 3) * sizeof(__be32);
 }
 
-static struct nfsd4_operation nfsd4_ops[] = {
+static const struct nfsd4_operation nfsd4_ops[] = {
        [OP_ACCESS] = {
-               .op_func = (nfsd4op_func)nfsd4_access,
+               .op_func = nfsd4_access,
                .op_name = "OP_ACCESS",
-               .op_rsize_bop = (nfsd4op_rsize)nfsd4_access_rsize,
+               .op_rsize_bop = nfsd4_access_rsize,
        },
        [OP_CLOSE] = {
-               .op_func = (nfsd4op_func)nfsd4_close,
+               .op_func = nfsd4_close,
                .op_flags = OP_MODIFIES_SOMETHING,
                .op_name = "OP_CLOSE",
-               .op_rsize_bop = (nfsd4op_rsize)nfsd4_status_stateid_rsize,
-        &nbs