*/
 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);
  */
 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);
  */
 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);
  */
 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);
  */
 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);
 }
  */
 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)
 #define PROC(proc, argtype, restype)                                   \
 [NLMPROC_##proc] = {                                                   \
        .p_proc      = NLMPROC_##proc,                                  \
-       .p_encode    = (kxdreproc_t)nlm4_xdr_enc_##argtype,             \
+       .p_encode    = nlm4_xdr_enc_##argtype,                          \
        .p_decode    = (kxdrdproc_t)nlm4_xdr_dec_##restype,             \
        .p_arglen    = NLM4_##argtype##_sz,                             \
        .p_replen    = NLM4_##restype##_sz,                             \
 
  */
 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);
  */
 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);
  */
 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);
  */
 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);
  */
 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);
 }
 
 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);
 #define PROC(proc, argtype, restype)   \
 [NLMPROC_##proc] = {                                                   \
        .p_proc      = NLMPROC_##proc,                                  \
-       .p_encode    = (kxdreproc_t)nlm_xdr_enc_##argtype,              \
+       .p_encode    = nlm_xdr_enc_##argtype,           \
        .p_decode    = (kxdrdproc_t)nlm_xdr_dec_##restype,              \
        .p_arglen    = NLM_##argtype##_sz,                              \
        .p_replen    = NLM_##restype##_sz,                              \
 
 }
 
 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 struct rpc_procinfo     nsm_procedures[] = {
 [NSMPROC_MON] = {
                .p_proc         = NSMPROC_MON,
-               .p_encode       = (kxdreproc_t)nsm_xdr_enc_mon,
+               .p_encode       = nsm_xdr_enc_mon,
                .p_decode       = (kxdrdproc_t)nsm_xdr_dec_stat_res,
                .p_arglen       = SM_mon_sz,
                .p_replen       = SM_monres_sz,
        },
 [NSMPROC_UNMON] = {
                .p_proc         = NSMPROC_UNMON,
-               .p_encode       = (kxdreproc_t)nsm_xdr_enc_unmon,
+               .p_encode       = nsm_xdr_enc_unmon,
                .p_decode       = (kxdrdproc_t)nsm_xdr_dec_stat,
                .p_arglen       = SM_mon_id_sz,
                .p_replen       = SM_unmonres_sz,