[PATCH] RPC: client-side transport switch cleanup

 Clean-up: change some comments to reflect the realities of the new RPC
 transport switch mechanism.  Get rid of unused xprt_receive() prototype.

 Also, organize function prototypes in xprt.h by usage and scope.

 Test-plan:
 Compile kernel with CONFIG_NFS enabled.

 Version: Thu, 11 Aug 2005 16:07:21 -0400

 Signed-off-by: Chuck Lever <cel@netapp.com>
 Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>

4 files changed, 55 insertions, 46 deletions

diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index d5223993fca9..bfbc492ae36d 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -1,5 +1,5 @@
 /*
- *  linux/include/linux/sunrpc/clnt_xprt.h
+ *  linux/include/linux/sunrpc/xprt.h
  *
  *  Declarations for the RPC transport interface.
  *
@@ -150,8 +150,8 @@ struct rpc_xprt {
         unsigned long           cong;           /* current congestion */
         unsigned long           cwnd;           /* congestion window */
 
-        unsigned int            rcvsize,        /* socket receive buffer size */
-                                sndsize;        /* socket send buffer size */
+        unsigned int            rcvsize,        /* transport rcv buffer size */
+                                sndsize;        /* transport send buffer size */
 
         size_t                  max_payload;    /* largest RPC payload size,
                                                    in bytes */
@@ -184,12 +184,12 @@ struct rpc_xprt {
         unsigned long           tcp_copied,     /* copied to request */
                                 tcp_flags;
         /*
-         * Connection of sockets
+         * Connection of transports
          */
-        struct work_struct      sock_connect;
+        struct work_struct      connect_worker;
         unsigned short          port;
         /*
-         * Disconnection of idle sockets
+         * Disconnection of idle transports
          */
         struct work_struct      task_cleanup;
         struct timer_list       timer;
@@ -219,27 +219,36 @@ struct rpc_xprt {
 
 #ifdef __KERNEL__
 
-struct rpc_xprt *       xprt_create_proto(int proto, struct sockaddr_in *addr,
-                                        struct rpc_timeout *toparms);
-void                    xprt_disconnect(struct rpc_xprt *);
-int                     xprt_destroy(struct rpc_xprt *);
-void                    xprt_set_timeout(struct rpc_timeout *, unsigned int,
-                                        unsigned long);
-struct rpc_rqst *       xprt_lookup_rqst(struct rpc_xprt *, u32);
-void                    xprt_complete_rqst(struct rpc_xprt *,
-                                        struct rpc_rqst *, int);
-void                    xprt_reserve(struct rpc_task *);
-int                     xprt_prepare_transmit(struct rpc_task *);
-void                    xprt_transmit(struct rpc_task *);
-void                    xprt_receive(struct rpc_task *);
-void                    xprt_wake_pending_tasks(struct rpc_xprt *, int);
+/*
+ * Transport operations used by ULPs
+ */
+struct rpc_xprt *       xprt_create_proto(int proto, struct sockaddr_in *addr, struct rpc_timeout *to);
+void                    xprt_set_timeout(struct rpc_timeout *to, unsigned int retr, unsigned long incr);
+
+/*
+ * Generic internal transport functions
+ */
+void                    xprt_connect(struct rpc_task *task);
+void                    xprt_reserve(struct rpc_task *task);
+int                     xprt_prepare_transmit(struct rpc_task *task);
+void                    xprt_transmit(struct rpc_task *task);
 int                     xprt_adjust_timeout(struct rpc_rqst *req);
-void                    xprt_release(struct rpc_task *);
-void                    xprt_connect(struct rpc_task *);
-int                     xs_setup_udp(struct rpc_xprt *,
-                                        struct rpc_timeout *);
-int                     xs_setup_tcp(struct rpc_xprt *,
-                                        struct rpc_timeout *);
+void                    xprt_release(struct rpc_task *task);
+int                     xprt_destroy(struct rpc_xprt *xprt);
+
+/*
+ * Transport switch helper functions
+ */
+void                    xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status);
+struct rpc_rqst *       xprt_lookup_rqst(struct rpc_xprt *xprt, u32 xid);
+void                    xprt_complete_rqst(struct rpc_xprt *xprt, struct rpc_rqst *req, int copied);
+void                    xprt_disconnect(struct rpc_xprt *xprt);
+
+/*
+ * Socket transport setup operations
+ */
+int                     xs_setup_udp(struct rpc_xprt *xprt, struct rpc_timeout *to);
+int                     xs_setup_tcp(struct rpc_xprt *xprt, struct rpc_timeout *to);
 
 /*
  * Reserved bit positions in xprt->state
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index 0d1b010a4a01..4677959d2834 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -1,5 +1,5 @@
 /*
- *  linux/net/sunrpc/rpcclnt.c
+ *  linux/net/sunrpc/clnt.c
  *
  *  This file contains the high-level RPC interface.
  *  It is modeled as a finite state machine to support both synchronous
diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index 2f9cd468b953..247fa1ec870c 100644
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -10,12 +10,12 @@
  *      one is available. Otherwise, it sleeps on the backlog queue
  *      (xprt_reserve).
  *  -   Next, the caller puts together the RPC message, stuffs it into
- *      the request struct, and calls xprt_call().
- *  -   xprt_call transmits the message and installs the caller on the
- *      socket's wait list. At the same time, it installs a timer that
+ *      the request struct, and calls xprt_transmit().
+ *  -   xprt_transmit sends the message and installs the caller on the
+ *      transport's wait list. At the same time, it installs a timer that
  *      is run after the packet's timeout has expired.
  *  -   When a packet arrives, the data_ready handler walks the list of
- *      pending requests for that socket. If a matching XID is found, the
+ *      pending requests for that transport. If a matching XID is found, the
  *      caller is woken up, and the timer removed.
  *  -   When no reply arrives within the timeout interval, the timer is
  *      fired by the kernel and runs xprt_timer(). It either adjusts the
@@ -32,6 +32,8 @@
  *  tasks that rely on callbacks.
  *
  *  Copyright (C) 1995-1997, Olaf Kirch <okir@monad.swb.de>
+ *
+ *  Transport switch API copyright (C) 2005, Chuck Lever <cel@netapp.com>
  */
 
 #include <linux/module.h>
@@ -52,8 +54,6 @@
 # define RPCDBG_FACILITY        RPCDBG_XPRT
 #endif
 
-#define XPRT_MAX_BACKOFF        (8)
-
 /*
  * Local functions
  */
@@ -65,9 +65,9 @@ static int      __xprt_get_cong(struct rpc_xprt *, struct rpc_task *);
 static int      xprt_clear_backlog(struct rpc_xprt *xprt);
 
 /*
- * Serialize write access to sockets, in order to prevent different
+ * Serialize write access to transports, in order to prevent different
  * requests from interfering with each other.
- * Also prevents TCP socket connects from colliding with writes.
+ * Also prevents transport connects from colliding with writes.
  */
 static int
 __xprt_lock_write(struct rpc_xprt *xprt, struct rpc_task *task)
@@ -91,7 +91,7 @@ __xprt_lock_write(struct rpc_xprt *xprt, struct rpc_task *task)
         clear_bit(XPRT_LOCKED, &xprt->state);
         smp_mb__after_clear_bit();
 out_sleep:
-        dprintk("RPC: %4d failed to lock socket %p\n", task->tk_pid, xprt);
+        dprintk("RPC: %4d failed to lock transport %p\n", task->tk_pid, xprt);
         task->tk_timeout = 0;
         task->tk_status = -EAGAIN;
         if (req && req->rq_ntrans)
@@ -144,7 +144,7 @@ out_unlock:
 }
 
 /*
- * Releases the socket for use by other requests.
+ * Releases the transport for use by other requests.
  */
 static void
 __xprt_release_write(struct rpc_xprt *xprt, struct rpc_task *task)
@@ -294,8 +294,7 @@ int xprt_adjust_timeout(struct rpc_rqst *req)
         return status;
 }
 
-static void
-xprt_socket_autoclose(void *args)
+static void xprt_autoclose(void *args)
 {
         struct rpc_xprt *xprt = (struct rpc_xprt *)args;
 
@@ -329,7 +328,6 @@ xprt_init_autodisconnect(unsigned long data)
         if (test_and_set_bit(XPRT_LOCKED, &xprt->state))
                 goto out_abort;
         spin_unlock(&xprt->transport_lock);
-        /* Let keventd close the socket */
         if (xprt_connecting(xprt))
                 xprt_release_write(xprt, NULL);
         else
@@ -770,7 +768,7 @@ static struct rpc_xprt *xprt_setup(int proto, struct sockaddr_in *ap, struct rpc
 
         INIT_LIST_HEAD(&xprt->free);
         INIT_LIST_HEAD(&xprt->recv);
-        INIT_WORK(&xprt->task_cleanup, xprt_socket_autoclose, xprt);
+        INIT_WORK(&xprt->task_cleanup, xprt_autoclose, xprt);
         init_timer(&xprt->timer);
         xprt->timer.function = xprt_init_autodisconnect;
         xprt->timer.data = (unsigned long) xprt;
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index 182da2edf61c..7f0b9f7f167b 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -11,6 +11,8 @@
  * Rewrite of larges part of the code in order to stabilize TCP stuff.
  * Fix behaviour when socket buffer is full.
  *  (C) 1999 Trond Myklebust <trond.myklebust@fys.uio.no>
+ *
+ * IP socket transport implementation, (C) 2005 Chuck Lever <cel@netapp.com>
  */
 
 #include <linux/types.h>
@@ -363,7 +365,7 @@ static void xs_destroy(struct rpc_xprt *xprt)
 {
         dprintk("RPC:      xs_destroy xprt %p\n", xprt);
 
-        cancel_delayed_work(&xprt->sock_connect);
+        cancel_delayed_work(&xprt->connect_worker);
         flush_scheduled_work();
 
         xprt_disconnect(xprt);
@@ -938,11 +940,11 @@ static void xs_connect(struct rpc_task *task)
         if (!xprt_test_and_set_connecting(xprt)) {
                 if (xprt->sock != NULL) {
                         dprintk("RPC:      xs_connect delayed xprt %p\n", xprt);
-                        schedule_delayed_work(&xprt->sock_connect,
+                        schedule_delayed_work(&xprt->connect_worker,
                                         RPC_REESTABLISH_TIMEOUT);
                 } else {
                         dprintk("RPC:      xs_connect scheduled xprt %p\n", xprt);
-                        schedule_work(&xprt->sock_connect);
+                        schedule_work(&xprt->connect_worker);
                         /* flush_scheduled_work can sleep... */
                         if (!RPC_IS_ASYNC(task))
                                 flush_scheduled_work();
@@ -989,7 +991,7 @@ int xs_setup_udp(struct rpc_xprt *xprt, struct rpc_timeout *to)
         /* XXX: header size can vary due to auth type, IPv6, etc. */
         xprt->max_payload = (1U << 16) - (MAX_HEADER << 3);
 
-        INIT_WORK(&xprt->sock_connect, xs_connect_worker, xprt);
+        INIT_WORK(&xprt->connect_worker, xs_connect_worker, xprt);
 
         xprt->ops = &xs_ops;
 
@@ -1028,7 +1030,7 @@ int xs_setup_tcp(struct rpc_xprt *xprt, struct rpc_timeout *to)
         xprt->resvport = capable(CAP_NET_BIND_SERVICE) ? 1 : 0;
         xprt->max_payload = (1U << 31) - 1;
 
-        INIT_WORK(&xprt->sock_connect, xs_connect_worker, xprt);
+        INIT_WORK(&xprt->connect_worker, xs_connect_worker, xprt);
 
         xprt->ops = &xs_ops;