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);
 }
 
  */
 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);
 
 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);
 
 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;
 }
  */
 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);
 }
 
  */
 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;
 
  */
 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);
 }
  */
 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);
 
 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);
 #define PROC(proc, argtype, restype, timer)                            \
 [NFSPROC_##proc] = {                                                   \
        .p_proc     =  NFSPROC_##proc,                                  \
-       .p_encode   =  (kxdreproc_t)nfs2_xdr_enc_##argtype,             \
+       .p_encode   =  nfs2_xdr_enc_##argtype,                          \
        .p_decode   =  (kxdrdproc_t)nfs2_xdr_dec_##restype,             \
        .p_arglen   =  NFS_##argtype##_sz,                              \
        .p_replen   =  NFS_##restype##_sz,                              \
 
  */
 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);
 }
 
 
 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);
  */
 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);
 }
 
 
 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);
 }
 
  */
 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);
 
 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);
 
 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;
 }
 
 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);
 }
  */
 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);
 }
  *     };
  */
 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;
 
 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);
 }
  */
 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);
 }
 
  */
 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;
 
  */
 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);
 }
 
 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);
 
 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);
 
 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);
 }
 
 
 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))
 
 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;
 
 #define PROC(proc, argtype, restype, timer)                            \
 [NFS3PROC_##proc] = {                                                  \
        .p_proc      = NFS3PROC_##proc,                                 \
-       .p_encode    = (kxdreproc_t)nfs3_xdr_enc_##argtype##3args,      \
+       .p_encode    = nfs3_xdr_enc_##argtype##3args,                   \
        .p_decode    = (kxdrdproc_t)nfs3_xdr_dec_##restype##3res,       \
        .p_arglen    = NFS3_##argtype##args_sz,                         \
        .p_replen    = NFS3_##restype##res_sz,                          \
 static struct rpc_procinfo     nfs3_acl_procedures[] = {
        [ACLPROC3_GETACL] = {
                .p_proc = ACLPROC3_GETACL,
-               .p_encode = (kxdreproc_t)nfs3_xdr_enc_getacl3args,
+               .p_encode = nfs3_xdr_enc_getacl3args,
                .p_decode = (kxdrdproc_t)nfs3_xdr_dec_getacl3res,
                .p_arglen = ACL3_getaclargs_sz,
                .p_replen = ACL3_getaclres_sz,
        },
        [ACLPROC3_SETACL] = {
                .p_proc = ACLPROC3_SETACL,
-               .p_encode = (kxdreproc_t)nfs3_xdr_enc_setacl3args,
+               .p_encode = nfs3_xdr_enc_setacl3args,
                .p_decode = (kxdrdproc_t)nfs3_xdr_dec_setacl3res,
                .p_arglen = ACL3_setaclargs_sz,
                .p_replen = ACL3_setaclres_sz,
 
                                         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);
 }
 
 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);
 }
 
 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);
 }
 
 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);
 }
 
 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);
 }
 
 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)
 {
 }
 
 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;
  */
 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),
        };
 }
 
 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;
  */
 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),
        };
  */
 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),
        };
  */
 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),
        };
  */
 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 = {
  */
 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),
        };
 
 }
 
 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;
 
 #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;
        *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);
 }
 
 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;
 }
 
 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;
 }
 
 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);
 }
 
 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);
 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;
 }
 
 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);
 }
 
 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);
  * 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),
        };
  * 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),
        };
  */
 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),
        };
  * 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),
        };
  * 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),
        };
  * 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),
        };
  * 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),
        };
  * 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);
 }
 
  * 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),
        };
  * 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),
        };
  * 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),
        };
  */
 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,
        };
  */
 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),
        };
  */
 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),
        };
  * 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),
        };
  * 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),
        };
  * 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),
        };
 
 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,
        };
  * 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),
        };
  * 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),
        };
  * 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),
        };
  * 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),
        };
  * 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),
        };
  * 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),
        };
  *  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),
        };
  * 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),
        };
  * 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),
        };
  * 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),
        };
  */
 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),
  * 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,
        };
  */
 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,
        };
  */
 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,
        };
  */
 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),
        };
  */
 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),
        };
        }
 
        /* 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);
 }
 
  */
 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),
        };
  */
 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),
        };
  */
 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,
        };
  */
 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,
        };
  */
 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,
        };
  */
 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,
        };
  */
 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,
        };
  * 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),
        };
  */
 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),
        };
  */
 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)
        };
  */
 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),
        };
  */
 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),
        };
  */
 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 = {
  */
 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),
        };
 /*
  * 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),
        };
        encode_putrootfh(xdr, &hdr);
        encode_secinfo_no_name(xdr, args, &hdr);
        encode_nops(&hdr);
-       return 0;
 }
 
 /*
  */
 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),
        };
  */
 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),
        };
  * 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),
        };
 #define PROC(proc, argtype, restype)                           \
 [NFSPROC4_CLNT_##proc] = {                                     \
        .p_proc   = NFSPROC4_COMPOUND,                          \
-       .p_encode = (kxdreproc_t)nfs4_xdr_##argtype,            \
+       .p_encode = nfs4_xdr_##argtype,                         \
        .p_decode = (kxdrdproc_t)nfs4_xdr_##restype,            \
        .p_arglen = NFS4_##argtype##_sz,                        \
        .p_replen = NFS4_##restype##_sz,                        \