1 files changed, 107 insertions, 115 deletions

diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index 3d739e5d15d8..fe9306bf10cc 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -138,20 +138,6 @@ static ctl_table sunrpc_table[] = {
 #endif
 
 /*
- * Time out for an RPC UDP socket connect.  UDP socket connects are
- * synchronous, but we set a timeout anyway in case of resource
- * exhaustion on the local host.
- */
-#define XS_UDP_CONN_TO          (5U * HZ)
-
-/*
- * Wait duration for an RPC TCP connection to be established.  Solaris
- * NFS over TCP uses 60 seconds, for example, which is in line with how
- * long a server takes to reboot.
- */
-#define XS_TCP_CONN_TO          (60U * HZ)
-
-/*
  * Wait duration for a reply from the RPC portmapper.
  */
 #define XS_BIND_TO              (60U * HZ)
@@ -224,7 +210,8 @@ struct sock_xprt {
          * State of TCP reply receive
          */
         __be32                  tcp_fraghdr,
-                                tcp_xid;
+                                tcp_xid,
+                                tcp_calldir;
 
         u32                     tcp_offset,
                                 tcp_reclen;
@@ -297,12 +284,11 @@ static void xs_format_common_peer_addresses(struct rpc_xprt *xprt)
         switch (sap->sa_family) {
         case AF_INET:
                 sin = xs_addr_in(xprt);
-                (void)snprintf(buf, sizeof(buf), "%02x%02x%02x%02x",
-                                        NIPQUAD(sin->sin_addr.s_addr));
+                snprintf(buf, sizeof(buf), "%08x", ntohl(sin->sin_addr.s_addr));
                 break;
         case AF_INET6:
                 sin6 = xs_addr_in6(xprt);
-                (void)snprintf(buf, sizeof(buf), "%pi6", &sin6->sin6_addr);
+                snprintf(buf, sizeof(buf), "%pi6", &sin6->sin6_addr);
                 break;
         default:
                 BUG();
@@ -315,10 +301,10 @@ static void xs_format_common_peer_ports(struct rpc_xprt *xprt)
         struct sockaddr *sap = xs_addr(xprt);
         char buf[128];
 
-        (void)snprintf(buf, sizeof(buf), "%u", rpc_get_port(sap));
+        snprintf(buf, sizeof(buf), "%u", rpc_get_port(sap));
         xprt->address_strings[RPC_DISPLAY_PORT] = kstrdup(buf, GFP_KERNEL);
 
-        (void)snprintf(buf, sizeof(buf), "%4hx", rpc_get_port(sap));
+        snprintf(buf, sizeof(buf), "%4hx", rpc_get_port(sap));
         xprt->address_strings[RPC_DISPLAY_HEX_PORT] = kstrdup(buf, GFP_KERNEL);
 }
 
@@ -543,14 +529,12 @@ static int xs_udp_send_request(struct rpc_task *task)
                         xdr->len - req->rq_bytes_sent, status);
 
         if (status >= 0) {
-                task->tk_bytes_sent += status;
+                req->rq_xmit_bytes_sent += status;
                 if (status >= req->rq_slen)
                         return 0;
                 /* Still some bytes left; set up for a retry later. */
                 status = -EAGAIN;
         }
-        if (!transport->sock)
-                goto out;
 
         switch (status) {
         case -ENOTSOCK:
@@ -570,7 +554,7 @@ static int xs_udp_send_request(struct rpc_task *task)
                  * prompts ECONNREFUSED. */
                 clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
         }
-out:
+
         return status;
 }
 
@@ -641,7 +625,7 @@ static int xs_tcp_send_request(struct rpc_task *task)
                 /* If we've sent the entire packet, immediately
                  * reset the count of bytes sent. */
                 req->rq_bytes_sent += status;
-                task->tk_bytes_sent += status;
+                req->rq_xmit_bytes_sent += status;
                 if (likely(req->rq_bytes_sent >= req->rq_slen)) {
                         req->rq_bytes_sent = 0;
                         return 0;
@@ -652,8 +636,6 @@ static int xs_tcp_send_request(struct rpc_task *task)
                 status = -EAGAIN;
                 break;
         }
-        if (!transport->sock)
-                goto out;
 
         switch (status) {
         case -ENOTSOCK:
@@ -673,7 +655,7 @@ static int xs_tcp_send_request(struct rpc_task *task)
         case -ENOTCONN:
                 clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);
         }
-out:
+
         return status;
 }
 
@@ -818,7 +800,7 @@ static void xs_udp_data_ready(struct sock *sk, int len)
         u32 _xid;
         __be32 *xp;
 
-        read_lock(&sk->sk_callback_lock);
+        read_lock_bh(&sk->sk_callback_lock);
         dprintk("RPC:       xs_udp_data_ready...\n");
         if (!(xprt = xprt_from_sock(sk)))
                 goto out;
@@ -863,7 +845,6 @@ static void xs_udp_data_ready(struct sock *sk, int len)
         dst_confirm(skb_dst(skb));
 
         xprt_adjust_cwnd(task, copied);
-        xprt_update_rtt(task);
         xprt_complete_rqst(task, copied);
 
  out_unlock:
@@ -871,7 +852,7 @@ static void xs_udp_data_ready(struct sock *sk, int len)
  dropit:
         skb_free_datagram(sk, skb);
  out:
-        read_unlock(&sk->sk_callback_lock);
+        read_unlock_bh(&sk->sk_callback_lock);
 }
 
 static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, struct xdr_skb_reader *desc)
@@ -947,7 +928,7 @@ static inline void xs_tcp_read_calldir(struct sock_xprt *transport,
 {
         size_t len, used;
         u32 offset;
-        __be32  calldir;
+        char *p;
 
         /*
          * We want transport->tcp_offset to be 8 at the end of this routine
@@ -956,26 +937,33 @@ static inline void xs_tcp_read_calldir(struct sock_xprt *transport,
          * transport->tcp_offset is 4 (after having already read the xid).
          */
         offset = transport->tcp_offset - sizeof(transport->tcp_xid);
-        len = sizeof(calldir) - offset;
+        len = sizeof(transport->tcp_calldir) - offset;
         dprintk("RPC:       reading CALL/REPLY flag (%Zu bytes)\n", len);
-        used = xdr_skb_read_bits(desc, &calldir, len);
+        p = ((char *) &transport->tcp_calldir) + offset;
+        used = xdr_skb_read_bits(desc, p, len);
         transport->tcp_offset += used;
         if (used != len)
                 return;
         transport->tcp_flags &= ~TCP_RCV_READ_CALLDIR;
-        transport->tcp_flags |= TCP_RCV_COPY_CALLDIR;
-        transport->tcp_flags |= TCP_RCV_COPY_DATA;
         /*
          * We don't yet have the XDR buffer, so we will write the calldir
          * out after we get the buffer from the 'struct rpc_rqst'
          */
-        if (ntohl(calldir) == RPC_REPLY)
+        switch (ntohl(transport->tcp_calldir)) {
+        case RPC_REPLY:
+                transport->tcp_flags |= TCP_RCV_COPY_CALLDIR;
+                transport->tcp_flags |= TCP_RCV_COPY_DATA;
                 transport->tcp_flags |= TCP_RPC_REPLY;
-        else
+                break;
+        case RPC_CALL:
+                transport->tcp_flags |= TCP_RCV_COPY_CALLDIR;
+                transport->tcp_flags |= TCP_RCV_COPY_DATA;
                 transport->tcp_flags &= ~TCP_RPC_REPLY;
-        dprintk("RPC:       reading %s CALL/REPLY flag %08x\n",
-                        (transport->tcp_flags & TCP_RPC_REPLY) ?
-                                "reply for" : "request with", calldir);
+                break;
+        default:
+                dprintk("RPC:       invalid request message type\n");
+                xprt_force_disconnect(&transport->xprt);
+        }
         xs_tcp_check_fraghdr(transport);
 }
 
@@ -995,12 +983,10 @@ static inline void xs_tcp_read_common(struct rpc_xprt *xprt,
                 /*
                  * Save the RPC direction in the XDR buffer
                  */
-                __be32  calldir = transport->tcp_flags & TCP_RPC_REPLY ?
-                                        htonl(RPC_REPLY) : 0;
-
                 memcpy(rcvbuf->head[0].iov_base + transport->tcp_copied,
-                        &calldir, sizeof(calldir));
-                transport->tcp_copied += sizeof(calldir);
+                        &transport->tcp_calldir,
+                        sizeof(transport->tcp_calldir));
+                transport->tcp_copied += sizeof(transport->tcp_calldir);
                 transport->tcp_flags &= ~TCP_RCV_COPY_CALLDIR;
         }
 
@@ -1055,8 +1041,6 @@ static inline void xs_tcp_read_common(struct rpc_xprt *xprt,
                 if (transport->tcp_flags & TCP_RCV_LAST_FRAG)
                         transport->tcp_flags &= ~TCP_RCV_COPY_DATA;
         }
-
-        return;
 }
 
 /*
@@ -1245,7 +1229,7 @@ static void xs_tcp_data_ready(struct sock *sk, int bytes)
 
         dprintk("RPC:       xs_tcp_data_ready...\n");
 
-        read_lock(&sk->sk_callback_lock);
+        read_lock_bh(&sk->sk_callback_lock);
         if (!(xprt = xprt_from_sock(sk)))
                 goto out;
         if (xprt->shutdown)
@@ -1264,7 +1248,7 @@ static void xs_tcp_data_ready(struct sock *sk, int bytes)
                 read = tcp_read_sock(sk, &rd_desc, xs_tcp_data_recv);
         } while (read > 0);
 out:
-        read_unlock(&sk->sk_callback_lock);
+        read_unlock_bh(&sk->sk_callback_lock);
 }
 
 /*
@@ -1317,18 +1301,19 @@ static void xs_tcp_state_change(struct sock *sk)
 {
         struct rpc_xprt *xprt;
 
-        read_lock(&sk->sk_callback_lock);
+        read_lock_bh(&sk->sk_callback_lock);
         if (!(xprt = xprt_from_sock(sk)))
                 goto out;
         dprintk("RPC:       xs_tcp_state_change client %p...\n", xprt);
-        dprintk("RPC:       state %x conn %d dead %d zapped %d\n",
+        dprintk("RPC:       state %x conn %d dead %d zapped %d sk_shutdown %d\n",
                         sk->sk_state, xprt_connected(xprt),
                         sock_flag(sk, SOCK_DEAD),
-                        sock_flag(sk, SOCK_ZAPPED));
+                        sock_flag(sk, SOCK_ZAPPED),
+                        sk->sk_shutdown);
 
         switch (sk->sk_state) {
         case TCP_ESTABLISHED:
-                spin_lock_bh(&xprt->transport_lock);
+                spin_lock(&xprt->transport_lock);
                 if (!xprt_test_and_set_connected(xprt)) {
                         struct sock_xprt *transport = container_of(xprt,
                                         struct sock_xprt, xprt);
@@ -1342,7 +1327,7 @@ static void xs_tcp_state_change(struct sock *sk)
 
                         xprt_wake_pending_tasks(xprt, -EAGAIN);
                 }
-                spin_unlock_bh(&xprt->transport_lock);
+                spin_unlock(&xprt->transport_lock);
                 break;
         case TCP_FIN_WAIT1:
                 /* The client initiated a shutdown of the socket */
@@ -1380,7 +1365,7 @@ static void xs_tcp_state_change(struct sock *sk)
                 xs_sock_mark_closed(xprt);
         }
  out:
-        read_unlock(&sk->sk_callback_lock);
+        read_unlock_bh(&sk->sk_callback_lock);
 }
 
 /**
@@ -1391,7 +1376,7 @@ static void xs_error_report(struct sock *sk)
 {
         struct rpc_xprt *xprt;
 
-        read_lock(&sk->sk_callback_lock);
+        read_lock_bh(&sk->sk_callback_lock);
         if (!(xprt = xprt_from_sock(sk)))
                 goto out;
         dprintk("RPC:       %s client %p...\n"
@@ -1399,7 +1384,7 @@ static void xs_error_report(struct sock *sk)
                         __func__, xprt, sk->sk_err);
         xprt_wake_pending_tasks(xprt, -EAGAIN);
 out:
-        read_unlock(&sk->sk_callback_lock);
+        read_unlock_bh(&sk->sk_callback_lock);
 }
 
 static void xs_write_space(struct sock *sk)
@@ -1431,13 +1416,13 @@ static void xs_write_space(struct sock *sk)
  */
 static void xs_udp_write_space(struct sock *sk)
 {
-        read_lock(&sk->sk_callback_lock);
+        read_lock_bh(&sk->sk_callback_lock);
 
         /* from net/core/sock.c:sock_def_write_space */
         if (sock_writeable(sk))
                 xs_write_space(sk);
 
-        read_unlock(&sk->sk_callback_lock);
+        read_unlock_bh(&sk->sk_callback_lock);
 }
 
 /**
@@ -1452,13 +1437,13 @@ static void xs_udp_write_space(struct sock *sk)
  */
 static void xs_tcp_write_space(struct sock *sk)
 {
-        read_lock(&sk->sk_callback_lock);
+        read_lock_bh(&sk->sk_callback_lock);
 
         /* from net/core/stream.c:sk_stream_write_space */
         if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
                 xs_write_space(sk);
 
-        read_unlock(&sk->sk_callback_lock);
+        read_unlock_bh(&sk->sk_callback_lock);
 }
 
 static void xs_udp_do_set_buffer_size(struct rpc_xprt *xprt)
@@ -1795,10 +1780,25 @@ static void xs_tcp_reuse_connection(struct rpc_xprt *xprt, struct sock_xprt *tra
 {
         unsigned int state = transport->inet->sk_state;
 
-        if (state == TCP_CLOSE && transport->sock->state == SS_UNCONNECTED)
-                return;
-        if ((1 << state) & (TCPF_ESTABLISHED|TCPF_SYN_SENT))
-                return;
+        if (state == TCP_CLOSE && transport->sock->state == SS_UNCONNECTED) {
+                /* we don't need to abort the connection if the socket
+                 * hasn't undergone a shutdown
+                 */
+                if (transport->inet->sk_shutdown == 0)
+                        return;
+                dprintk("RPC:       %s: TCP_CLOSEd and sk_shutdown set to %d\n",
+                                __func__, transport->inet->sk_shutdown);
+        }
+        if ((1 << state) & (TCPF_ESTABLISHED|TCPF_SYN_SENT)) {
+                /* we don't need to abort the connection if the socket
+                 * hasn't undergone a shutdown
+                 */
+                if (transport->inet->sk_shutdown == 0)
+                        return;
+                dprintk("RPC:       %s: ESTABLISHED/SYN_SENT "
+                                "sk_shutdown set to %d\n",
+                                __func__, transport->inet->sk_shutdown);
+        }
         xs_abort_connection(xprt, transport);
 }
 
@@ -1912,6 +1912,11 @@ static void xs_tcp_setup_socket(struct rpc_xprt *xprt,
         case -EALREADY:
                 xprt_clear_connecting(xprt);
                 return;
+        case -EINVAL:
+                /* Happens, for instance, if the user specified a link
+                 * local IPv6 address without a scope-id.
+                 */
+                goto out;
         }
 out_eagain:
         status = -EAGAIN;
@@ -2016,9 +2021,6 @@ static void xs_connect(struct rpc_task *task)
         struct rpc_xprt *xprt = task->tk_xprt;
         struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
 
-        if (xprt_test_and_set_connecting(xprt))
-                return;
-
         if (transport->sock != NULL && !RPC_IS_SOFTCONN(task)) {
                 dprintk("RPC:       xs_connect delayed xprt %p for %lu "
                                 "seconds\n",
@@ -2038,16 +2040,6 @@ static void xs_connect(struct rpc_task *task)
         }
 }
 
-static void xs_tcp_connect(struct rpc_task *task)
-{
-        struct rpc_xprt *xprt = task->tk_xprt;
-
-        /* Exit if we need to wait for socket shutdown to complete */
-        if (test_bit(XPRT_CLOSING, &xprt->state))
-                return;
-        xs_connect(task);
-}
-
 /**
  * xs_udp_print_stats - display UDP socket-specifc stats
  * @xprt: rpc_xprt struct containing statistics
@@ -2100,7 +2092,7 @@ static void xs_tcp_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
  * we allocate pages instead doing a kmalloc like rpc_malloc is because we want
  * to use the server side send routines.
  */
-void *bc_malloc(struct rpc_task *task, size_t size)
+static void *bc_malloc(struct rpc_task *task, size_t size)
 {
         struct page *page;
         struct rpc_buffer *buf;
@@ -2120,7 +2112,7 @@ void *bc_malloc(struct rpc_task *task, size_t size)
 /*
  * Free the space allocated in the bc_alloc routine
  */
-void bc_free(void *buffer)
+static void bc_free(void *buffer)
 {
         struct rpc_buffer *buf;
 
@@ -2210,7 +2202,6 @@ static int bc_send_request(struct rpc_task *task)
 
 static void bc_close(struct rpc_xprt *xprt)
 {
-        return;
 }
 
 /*
@@ -2220,7 +2211,6 @@ static void bc_close(struct rpc_xprt *xprt)
 
 static void bc_destroy(struct rpc_xprt *xprt)
 {
-        return;
 }
 
 static struct rpc_xprt_ops xs_udp_ops = {
@@ -2246,14 +2236,11 @@ static struct rpc_xprt_ops xs_tcp_ops = {
         .release_xprt           = xs_tcp_release_xprt,
         .rpcbind                = rpcb_getport_async,
         .set_port               = xs_set_port,
-        .connect                = xs_tcp_connect,
+        .connect                = xs_connect,
         .buf_alloc              = rpc_malloc,
         .buf_free               = rpc_free,
         .send_request           = xs_tcp_send_request,
         .set_retrans_timeout    = xprt_set_retrans_timeout_def,
-#if defined(CONFIG_NFS_V4_1)
-        .release_request        = bc_release_request,
-#endif /* CONFIG_NFS_V4_1 */
         .close                  = xs_tcp_close,
         .destroy                = xs_destroy,
         .print_stats            = xs_tcp_print_stats,
@@ -2328,6 +2315,7 @@ static struct rpc_xprt *xs_setup_udp(struct xprt_create *args)
         struct sockaddr *addr = args->dstaddr;
         struct rpc_xprt *xprt;
         struct sock_xprt *transport;
+        struct rpc_xprt *ret;
 
         xprt = xs_setup_xprt(args, xprt_udp_slot_table_entries);
         if (IS_ERR(xprt))
@@ -2340,7 +2328,6 @@ static struct rpc_xprt *xs_setup_udp(struct xprt_create *args)
         xprt->max_payload = (1U << 16) - (MAX_HEADER << 3);
 
         xprt->bind_timeout = XS_BIND_TO;
-        xprt->connect_timeout = XS_UDP_CONN_TO;
         xprt->reestablish_timeout = XS_UDP_REEST_TO;
         xprt->idle_timeout = XS_IDLE_DISC_TO;
 
@@ -2366,8 +2353,8 @@ static struct rpc_xprt *xs_setup_udp(struct xprt_create *args)
                 xs_format_peer_addresses(xprt, "udp", RPCBIND_NETID_UDP6);
                 break;
         default:
-                kfree(xprt);
-                return ERR_PTR(-EAFNOSUPPORT);
+                ret = ERR_PTR(-EAFNOSUPPORT);
+                goto out_err;
         }
 
         if (xprt_bound(xprt))
@@ -2382,10 +2369,11 @@ static struct rpc_xprt *xs_setup_udp(struct xprt_create *args)
 
         if (try_module_get(THIS_MODULE))
                 return xprt;
-
+        ret = ERR_PTR(-EINVAL);
+out_err:
         kfree(xprt->slot);
         kfree(xprt);
-        return ERR_PTR(-EINVAL);
+        return ret;
 }
 
 static const struct rpc_timeout xs_tcp_default_timeout = {
@@ -2404,6 +2392,7 @@ static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args)
         struct sockaddr *addr = args->dstaddr;
         struct rpc_xprt *xprt;
         struct sock_xprt *transport;
+        struct rpc_xprt *ret;
 
         xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries);
         if (IS_ERR(xprt))
@@ -2415,7 +2404,6 @@ static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args)
         xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
 
         xprt->bind_timeout = XS_BIND_TO;
-        xprt->connect_timeout = XS_TCP_CONN_TO;
         xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
         xprt->idle_timeout = XS_IDLE_DISC_TO;
 
@@ -2440,8 +2428,8 @@ static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args)
                 xs_format_peer_addresses(xprt, "tcp", RPCBIND_NETID_TCP6);
                 break;
         default:
-                kfree(xprt);
-                return ERR_PTR(-EAFNOSUPPORT);
+                ret = ERR_PTR(-EAFNOSUPPORT);
+                goto out_err;
         }
 
         if (xprt_bound(xprt))
@@ -2457,10 +2445,11 @@ static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args)
 
         if (try_module_get(THIS_MODULE))
                 return xprt;
-
+        ret = ERR_PTR(-EINVAL);
+out_err:
         kfree(xprt->slot);
         kfree(xprt);
-        return ERR_PTR(-EINVAL);
+        return ret;
 }
 
 /**
@@ -2474,9 +2463,7 @@ static struct rpc_xprt *xs_setup_bc_tcp(struct xprt_create *args)
         struct rpc_xprt *xprt;
         struct sock_xprt *transport;
         struct svc_sock *bc_sock;
-
-        if (!args->bc_xprt)
-                ERR_PTR(-EINVAL);
+        struct rpc_xprt *ret;
 
         xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries);
         if (IS_ERR(xprt))
@@ -2491,7 +2478,6 @@ static struct rpc_xprt *xs_setup_bc_tcp(struct xprt_create *args)
         /* backchannel */
         xprt_set_bound(xprt);
         xprt->bind_timeout = 0;
-        xprt->connect_timeout = 0;
         xprt->reestablish_timeout = 0;
         xprt->idle_timeout = 0;
 
@@ -2517,8 +2503,8 @@ static struct rpc_xprt *xs_setup_bc_tcp(struct xprt_create *args)
                                    RPCBIND_NETID_TCP6);
                 break;
         default:
-                kfree(xprt);
-                return ERR_PTR(-EAFNOSUPPORT);
+                ret = ERR_PTR(-EAFNOSUPPORT);
+                goto out_err;
         }
 
         if (xprt_bound(xprt))
@@ -2540,9 +2526,11 @@ static struct rpc_xprt *xs_setup_bc_tcp(struct xprt_create *args)
 
         if (try_module_get(THIS_MODULE))
                 return xprt;
+        ret = ERR_PTR(-EINVAL);
+out_err:
         kfree(xprt->slot);
         kfree(xprt);
-        return ERR_PTR(-EINVAL);
+        return ret;
 }
 
 static struct xprt_class        xs_udp_transport = {
@@ -2605,7 +2593,8 @@ void cleanup_socket_xprt(void)
         xprt_unregister_transport(&xs_bc_tcp_transport);
 }
 
-static int param_set_uint_minmax(const char *val, struct kernel_param *kp,
+static int param_set_uint_minmax(const char *val,
+                const struct kernel_param *kp,
                 unsigned int min, unsigned int max)
 {
         unsigned long num;
@@ -2620,34 +2609,37 @@ static int param_set_uint_minmax(const char *val, struct kernel_param *kp,
         return 0;
 }
 
-static int param_set_portnr(const char *val, struct kernel_param *kp)
+static int param_set_portnr(const char *val, const struct kernel_param *kp)
 {
         return param_set_uint_minmax(val, kp,
                         RPC_MIN_RESVPORT,
                         RPC_MAX_RESVPORT);
 }
 
-static int param_get_portnr(char *buffer, struct kernel_param *kp)
-{
-        return param_get_uint(buffer, kp);
-}
+static struct kernel_param_ops param_ops_portnr = {
+        .set = param_set_portnr,
+        .get = param_get_uint,
+};
+
 #define param_check_portnr(name, p) \
         __param_check(name, p, unsigned int);
 
 module_param_named(min_resvport, xprt_min_resvport, portnr, 0644);
 module_param_named(max_resvport, xprt_max_resvport, portnr, 0644);
 
-static int param_set_slot_table_size(const char *val, struct kernel_param *kp)
+static int param_set_slot_table_size(const char *val,
+                                     const struct kernel_param *kp)
 {
         return param_set_uint_minmax(val, kp,
                         RPC_MIN_SLOT_TABLE,
                         RPC_MAX_SLOT_TABLE);
 }
 
-static int param_get_slot_table_size(char *buffer, struct kernel_param *kp)
-{
-        return param_get_uint(buffer, kp);
-}
+static struct kernel_param_ops param_ops_slot_table_size = {
+        .set = param_set_slot_table_size,
+        .get = param_get_uint,
+};
+
 #define param_check_slot_table_size(name, p) \
         __param_check(name, p, unsigned int);