diff -urN 2.4.19pre8/include/linux/sunrpc/clnt.h nfs/include/linux/sunrpc/clnt.h
--- 2.4.19pre8/include/linux/sunrpc/clnt.h Fri Mar 29 20:22:37 2002
+++ nfs/include/linux/sunrpc/clnt.h Fri May 3 16:13:47 2002
@@ -111,6 +111,8 @@
void rpc_release_client(struct rpc_clnt *);
void rpc_getport(struct rpc_task *, struct rpc_clnt *);
int rpc_register(u32, u32, int, unsigned short, int *);
+u32 * rpc_call_header(struct rpc_task *task);
+u32 * rpc_call_verify(struct rpc_task *task);
void rpc_call_setup(struct rpc_task *, struct rpc_message *, int);
@@ -142,6 +144,11 @@
* Helper function for NFSroot support
*/
int rpc_getport_external(struct sockaddr_in *, __u32, __u32, int);
+
+/*
+ * Ping function
+ */
+void rpc_ping(struct rpc_task *task);
#endif /* __KERNEL__ */
#endif /* _LINUX_SUNRPC_CLNT_H */
diff -urN 2.4.19pre8/include/linux/sunrpc/xprt.h nfs/include/linux/sunrpc/xprt.h
--- 2.4.19pre8/include/linux/sunrpc/xprt.h Fri May 3 02:12:28 2002
+++ nfs/include/linux/sunrpc/xprt.h Fri May 3 16:14:29 2002
@@ -39,12 +39,14 @@
* Come Linux 2.3, we'll handle fragments directly.
*/
#define RPC_MAXCONG 16
-#define RPC_MAXREQS (RPC_MAXCONG + 1)
+#define RPC_MAXREQS (RPC_MAXCONG + 2)
#define RPC_CWNDSCALE 256
#define RPC_MAXCWND (RPC_MAXCONG * RPC_CWNDSCALE)
#define RPC_INITCWND RPC_CWNDSCALE
#define RPCXPRT_CONGESTED(xprt) \
((xprt)->cong >= (xprt)->cwnd)
+#define RPCXPRT_SUPERCONGESTED(xprt) \
+ ((xprt)->cwnd < 2*RPC_CWNDSCALE)
/* Default timeout values */
#define RPC_MAX_UDP_TIMEOUT (60*HZ)
@@ -140,6 +142,7 @@
struct rpc_wait_queue sending; /* requests waiting to send */
struct rpc_wait_queue pending; /* requests in flight */
struct rpc_wait_queue backlog; /* waiting for slot */
+ struct rpc_wait_queue pingwait; /* waiting on ping() */
struct rpc_rqst * free; /* free slots */
struct rpc_rqst slot[RPC_MAXREQS];
unsigned long sockstate; /* Socket state */
@@ -183,15 +186,19 @@
unsigned long);
int xprt_reserve(struct rpc_task *);
+int xprt_ping_reserve(struct rpc_task *);
void xprt_transmit(struct rpc_task *);
void xprt_receive(struct rpc_task *);
int xprt_adjust_timeout(struct rpc_timeout *);
void xprt_release(struct rpc_task *);
+void xprt_ping_release(struct rpc_task *);
void xprt_reconnect(struct rpc_task *);
int xprt_clear_backlog(struct rpc_xprt *);
#define XPRT_WSPACE 0
#define XPRT_CONNECT 1
+#define XPRT_PING 2
+#define XPRT_NORESPOND 3
#define xprt_wspace(xp) (test_bit(XPRT_WSPACE, &(xp)->sockstate))
#define xprt_test_and_set_wspace(xp) (test_and_set_bit(XPRT_WSPACE, &(xp)->sockstate))
@@ -201,6 +208,32 @@
#define xprt_set_connected(xp) (set_bit(XPRT_CONNECT, &(xp)->sockstate))
#define xprt_test_and_set_connected(xp) (test_and_set_bit(XPRT_CONNECT, &(xp)->sockstate))
#define xprt_clear_connected(xp) (clear_bit(XPRT_CONNECT, &(xp)->sockstate))
+
+static inline int xprt_pinging(struct rpc_xprt *xprt)
+{
+ return test_bit(XPRT_PING, &xprt->sockstate);
+}
+static inline int xprt_test_and_set_pinging(struct rpc_xprt *xprt)
+{
+ return test_and_set_bit(XPRT_PING, &xprt->sockstate);
+}
+static inline void xprt_clear_pinging(struct rpc_xprt *xprt)
+{
+ clear_bit(XPRT_PING, &xprt->sockstate);
+}
+
+static inline int xprt_norespond(struct rpc_xprt *xprt)
+{
+ return test_bit(XPRT_NORESPOND, &xprt->sockstate);
+}
+static inline int xprt_test_and_set_norespond(struct rpc_xprt *xprt)
+{
+ return test_and_set_bit(XPRT_NORESPOND, &xprt->sockstate);
+}
+static inline void xprt_clear_norespond(struct rpc_xprt *xprt)
+{
+ clear_bit(XPRT_NORESPOND, &xprt->sockstate);
+}
#endif /* __KERNEL__*/
diff -urN 2.4.19pre8/net/sunrpc/Makefile nfs/net/sunrpc/Makefile
--- 2.4.19pre8/net/sunrpc/Makefile Tue Jan 2 17:41:24 2001
+++ nfs/net/sunrpc/Makefile Fri May 3 16:13:47 2002
@@ -14,7 +14,7 @@
obj-y := clnt.o xprt.o sched.o \
auth.o auth_null.o auth_unix.o \
svc.o svcsock.o svcauth.o \
- pmap_clnt.o xdr.o sunrpc_syms.o
+ ping.o pmap_clnt.o xdr.o sunrpc_syms.o
obj-$(CONFIG_PROC_FS) += stats.o
obj-$(CONFIG_SYSCTL) += sysctl.o
diff -urN 2.4.19pre8/net/sunrpc/clnt.c nfs/net/sunrpc/clnt.c
--- 2.4.19pre8/net/sunrpc/clnt.c Tue Jan 22 18:53:57 2002
+++ nfs/net/sunrpc/clnt.c Fri May 3 16:13:47 2002
@@ -57,8 +57,8 @@
static void call_reconnect(struct rpc_task *task);
static void child_reconnect(struct rpc_task *);
static void child_reconnect_status(struct rpc_task *);
-static u32 * call_header(struct rpc_task *task);
-static u32 * call_verify(struct rpc_task *task);
+static void call_ping(struct rpc_task *task);
+static void call_pingresult(struct rpc_task *task);
/*
@@ -491,7 +491,7 @@
/* Encode header and provided arguments */
encode = rpcproc_encode(clnt, task->tk_msg.rpc_proc);
- if (!(p = call_header(task))) {
+ if (!(p = rpc_call_header(task))) {
printk(KERN_INFO "RPC: call_header failed, exit EIO\n");
rpc_exit(task, -EIO);
} else
@@ -618,11 +618,10 @@
task->tk_action = call_reconnect;
break;
}
- /*
- * Sleep and dream of an open connection
- */
- task->tk_timeout = 5 * HZ;
- rpc_sleep_on(&xprt->sending, task, NULL, NULL);
+ if (RPCXPRT_SUPERCONGESTED(clnt->cl_xprt)) {
+ task->tk_action = call_ping;
+ break;
+ }
case -ENOMEM:
case -EAGAIN:
task->tk_action = call_transmit;
@@ -646,6 +645,7 @@
{
struct rpc_clnt *clnt = task->tk_client;
struct rpc_rqst *req = task->tk_rqstp;
+ int major = 0;
if (req) {
struct rpc_timeout *to = &req->rq_timeout;
@@ -666,17 +666,7 @@
rpc_exit(task, -EIO);
return;
}
- if (clnt->cl_chatty && !(task->tk_flags & RPC_CALL_MAJORSEEN)) {
- task->tk_flags |= RPC_CALL_MAJORSEEN;
- if (req)
- printk(KERN_NOTICE "%s: server %s not responding, still trying\n",
- clnt->cl_protname, clnt->cl_server);
-#ifdef RPC_DEBUG
- else
- printk(KERN_NOTICE "%s: task %d can't get a request slot\n",
- clnt->cl_protname, task->tk_pid);
-#endif
- }
+ major = 1;
if (clnt->cl_autobind)
clnt->cl_port = 0;
@@ -689,6 +679,8 @@
} else if (!xprt_connected(clnt->cl_xprt)) {
task->tk_action = call_reconnect;
clnt->cl_stats->rpcretrans++;
+ } else if (major && RPCXPRT_SUPERCONGESTED(clnt->cl_xprt)) {
+ task->tk_action = call_ping;
} else {
task->tk_action = call_transmit;
clnt->cl_stats->rpcretrans++;
@@ -710,12 +702,6 @@
dprintk("RPC: %4d call_decode (status %d)\n",
task->tk_pid, task->tk_status);
- if (clnt->cl_chatty && (task->tk_flags & RPC_CALL_MAJORSEEN)) {
- printk(KERN_NOTICE "%s: server %s OK\n",
- clnt->cl_protname, clnt->cl_server);
- task->tk_flags &= ~RPC_CALL_MAJORSEEN;
- }
-
if (task->tk_status < 12) {
if (!clnt->cl_softrtry) {
task->tk_action = call_transmit;
@@ -729,7 +715,7 @@
}
/* Verify the RPC header */
- if (!(p = call_verify(task)))
+ if (!(p = rpc_call_verify(task)))
return;
/*
@@ -788,8 +774,8 @@
/*
* Call header serialization
*/
-static u32 *
-call_header(struct rpc_task *task)
+u32 *
+rpc_call_header(struct rpc_task *task)
{
struct rpc_clnt *clnt = task->tk_client;
struct rpc_xprt *xprt = clnt->cl_xprt;
@@ -809,10 +795,63 @@
}
/*
+ * Ping a non-responding server
+ */
+static void
+call_ping(struct rpc_task *task)
+{
+ task->tk_action = call_pingresult;
+ rpc_ping(task);
+}
+
+/*
+ * Interpret the result from ping
+ */
+static void
+call_pingresult(struct rpc_task *task)
+{
+ struct rpc_clnt *clnt = task->tk_client;
+ struct rpc_xprt *xprt = clnt->cl_xprt;
+ int status = task->tk_status;
+
+ task->tk_status = 0;
+ if (status >= 0) {
+ task->tk_action = call_transmit;
+ return;
+ }
+
+ switch(status) {
+ case -ECONNREFUSED:
+ case -ENOTCONN:
+ if (clnt->cl_autobind || !clnt->cl_port) {
+ clnt->cl_port = 0;
+ task->tk_action = call_bind;
+ break;
+ }
+ if (xprt->stream) {
+ task->tk_action = call_reconnect;
+ break;
+ }
+ case -ENOMEM:
+ case -ENOBUFS:
+ rpc_delay(task, HZ >> 4);
+ case -ETIMEDOUT:
+ task->tk_action = call_ping;
+ break;
+ default:
+ if (clnt->cl_chatty)
+ printk("%s: RPC call returned error %d\n",
+ clnt->cl_protname, -status);
+ rpc_exit(task,status);
+ return;
+ }
+}
+
+/*
* Reply header verification
*/
-static u32 *
-call_verify(struct rpc_task *task)
+u32 *
+rpc_call_verify(struct rpc_task *task)
{
u32 *p = task->tk_rqstp->rq_rvec[0].iov_base, n;
diff -urN 2.4.19pre8/net/sunrpc/ping.c nfs/net/sunrpc/ping.c
--- 2.4.19pre8/net/sunrpc/ping.c Thu Jan 1 01:00:00 1970
+++ nfs/net/sunrpc/ping.c Fri May 3 16:13:47 2002
@@ -0,0 +1,218 @@
+/*
+ * linux/net/sunrpc/ping.c
+ *
+ * Ping routing.
+ *
+ * Copyright (C) 2000, Trond Myklebust <trond.myklebust@fys.uio.no>
+ */
+
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/socket.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/uio.h>
+#include <linux/in.h>
+#include <linux/sunrpc/clnt.h>
+#include <linux/sunrpc/xprt.h>
+#include <linux/sunrpc/sched.h>
+
+
+#define RPC_SLACK_SPACE 512 /* total overkill */
+#define RPC_PING_DELAY (15*HZ)
+
+#ifdef RPC_DEBUG
+# define RPCDBG_FACILITY RPCDBG_XPRT
+#endif
+
+static void ping_call_reserve(struct rpc_task *);
+static void ping_call_allocate(struct rpc_task *);
+static void ping_call_encode(struct rpc_task *);
+static void ping_call_transmit(struct rpc_task *);
+static void ping_call_receive(struct rpc_task *);
+static void ping_call_exit(struct rpc_task *);
+
+
+static void
+ping_call_reserve(struct rpc_task *task)
+{
+ dprintk("RPC: %4d, ping_call_reserve\n", task->tk_pid);
+ task->tk_status = 0;
+ task->tk_action = ping_call_allocate;
+ task->tk_timeout = task->tk_client->cl_timeout.to_resrvval;
+ xprt_ping_reserve(task);
+}
+
+static void
+ping_call_allocate(struct rpc_task *task)
+{
+ struct rpc_clnt *clnt = task->tk_client;
+ struct rpc_rqst *req = task->tk_rqstp;
+ unsigned int bufsiz;
+
+ dprintk("RPC: %4d, ping_call_allocate (status %d)\n",
+ task->tk_pid, task->tk_status);
+
+ task->tk_action = ping_call_exit;
+ if (task->tk_status < 0)
+ return;
+
+ bufsiz = rpcproc_bufsiz(clnt, task->tk_msg.rpc_proc) + RPC_SLACK_SPACE;
+ if (!(task->tk_buffer = rpc_malloc(task, bufsiz << 1))) {
+ task->tk_status = -ENOMEM;
+ return;
+ }
+ req->rq_svec[0].iov_base = (void *)task->tk_buffer;
+ req->rq_svec[0].iov_len = bufsiz;
+ req->rq_slen = 0;
+ req->rq_snr = 1;
+ req->rq_rvec[0].iov_base = (void *)((char *)task->tk_buffer + bufsiz);
+ req->rq_rvec[0].iov_len = bufsiz;
+ req->rq_rlen = bufsiz;
+ req->rq_rnr = 1;
+ task->tk_action = ping_call_encode;
+}
+
+static void
+ping_call_encode(struct rpc_task *task)
+{
+ struct rpc_rqst *req = task->tk_rqstp;
+ u32 *p;
+
+ dprintk("RPC: %4d, ping_call_encode (status %d)\n",
+ task->tk_pid, task->tk_status);
+
+ if (task->tk_status < 0) {
+ task->tk_action = ping_call_exit;
+ return;
+ }
+ p = rpc_call_header(task);
+ req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
+ task->tk_action = ping_call_transmit;
+}
+
+static void
+ping_call_transmit(struct rpc_task *task)
+{
+ dprintk("RPC: %4d, ping_call_transmit\n", task->tk_pid);
+ task->tk_action = ping_call_receive;
+ xprt_transmit(task);
+}
+
+static void
+ping_call_receive(struct rpc_task *task)
+{
+ struct rpc_clnt *clnt = task->tk_client;
+ struct rpc_xprt *xprt = clnt->cl_xprt;
+ struct rpc_rqst *req = task->tk_rqstp;
+ struct rpc_timeout *to = &req->rq_timeout;
+ u32 *p;
+
+ dprintk("RPC: %4d, ping_call_receive (status %d)\n",
+ task->tk_pid, task->tk_status);
+
+ if (task->tk_status >= 0)
+ p = rpc_call_verify(task);
+
+ task->tk_action = ping_call_exit;
+
+ if (task->tk_status >= 0 || task->tk_status == -EACCES) {
+ task->tk_status = 0;
+ if (xprt_norespond(xprt)) {
+ if (clnt->cl_chatty)
+ printk(KERN_NOTICE "%s: server %s OK\n",
+ clnt->cl_protname, clnt->cl_server);
+ xprt_clear_norespond(xprt);
+ }
+ return;
+ }
+
+ switch (task->tk_status) {
+ case -ENOTCONN:
+ break;
+ case -ENOMEM:
+ case -EAGAIN:
+ case -ECONNREFUSED:
+ case -ETIMEDOUT:
+ if (!xprt_adjust_timeout(to)) {
+ task->tk_status = 0;
+ task->tk_action = ping_call_transmit;
+ break;
+ }
+ default:
+ if (clnt->cl_softrtry) {
+ task->tk_status = -EIO;
+ break;
+ }
+ if (clnt->cl_chatty) {
+ if (!xprt_test_and_set_norespond(xprt)) {
+ printk(KERN_NOTICE
+ "%s: server %s is not responding\n",
+ clnt->cl_protname, clnt->cl_server);
+ } else {
+ printk(KERN_NOTICE
+ "%s: server %s still not responding\n",
+ clnt->cl_protname, clnt->cl_server);
+ }
+ }
+ rpc_delay(task, RPC_PING_DELAY);
+ }
+}
+
+static void
+ping_call_exit(struct rpc_task *task)
+{
+ struct rpc_xprt *xprt = task->tk_xprt;
+
+ dprintk("RPC: %4d, ping_call_exit (status %d)\n",
+ task->tk_pid, task->tk_status);
+
+ task->tk_action = NULL;
+ xprt_ping_release(task);
+
+ /* Sigh. rpc_delay() clears task->tk_status */
+ if (task->tk_status == 0 && xprt_norespond(xprt))
+ task->tk_status = -ETIMEDOUT;
+
+ xprt_clear_pinging(xprt);
+ rpc_wake_up_status(&xprt->pingwait, task->tk_status);
+}
+
+void
+rpc_ping(struct rpc_task *task)
+{
+ struct rpc_clnt *clnt = task->tk_client;
+ struct rpc_xprt *xprt = clnt->cl_xprt;
+ struct rpc_task *child;
+ struct rpc_message msg = {0, NULL, NULL, NULL};
+
+ dprintk("RPC: %4d, rpc_ping\n", task->tk_pid);
+
+ again:
+ if (xprt_test_and_set_pinging(xprt)) {
+ rpc_sleep_on(&xprt->pingwait, task, NULL, 0);
+ if (!xprt_pinging(xprt)) {
+ rpc_wake_up_task(task);
+ goto again;
+ }
+ dprintk("RPC: %4d, rpc_ping, waiting on completion\n",
+ task->tk_pid);
+ return;
+ }
+
+ child = rpc_new_child(clnt, task);
+ if (!child) {
+ dprintk("RPC: %4d, rpc_ping, failed to create child process\n",
+ task->tk_pid);
+ xprt_clear_pinging(xprt);
+ rpc_wake_up_status(&xprt->pingwait, -ENOMEM);
+ task->tk_status = -ENOMEM;
+ return;
+ }
+ rpc_call_setup(child, &msg, 0);
+ child->tk_action = ping_call_reserve;
+
+ dprintk("RPC: %4d, rpc_ping, running child process %4d\n",
+ task->tk_pid, child->tk_pid);
+ rpc_run_child(task, child, NULL);
+}
diff -urN 2.4.19pre8/net/sunrpc/xprt.c nfs/net/sunrpc/xprt.c
--- 2.4.19pre8/net/sunrpc/xprt.c Fri May 3 02:12:32 2002
+++ nfs/net/sunrpc/xprt.c Fri May 3 16:13:47 2002
@@ -83,7 +83,7 @@
*/
static void xprt_request_init(struct rpc_task *, struct rpc_xprt *);
static void do_xprt_transmit(struct rpc_task *);
-static void xprt_reserve_status(struct rpc_task *task);
+static void xprt_alloc_slot(struct rpc_xprt *, struct rpc_task *);
static void xprt_disconnect(struct rpc_xprt *);
static void xprt_reconn_status(struct rpc_task *task);
static struct socket *xprt_create_socket(int, struct rpc_timeout *);
@@ -1113,15 +1113,8 @@
rpc_sleep_on(&xprt->sending, task, NULL, NULL);
}
spin_unlock_bh(&xprt->sock_lock);
- return;
case -EAGAIN:
- /* Keep holding the socket if it is blocked */
- rpc_delay(task, HZ>>4);
return;
- case -ECONNREFUSED:
- case -ENOTCONN:
- if (!xprt->stream)
- return;
default:
if (xprt->stream)
xprt_disconnect(xprt);
@@ -1172,9 +1165,11 @@
dprintk("RPC: %4d xprt_reserve cong = %ld cwnd = %ld\n",
task->tk_pid, xprt->cong, xprt->cwnd);
spin_lock_bh(&xprt->xprt_lock);
- xprt_reserve_status(task);
+ if (!RPCXPRT_CONGESTED(xprt))
+ xprt_alloc_slot(xprt, task);
if (task->tk_rqstp) {
task->tk_timeout = 0;
+ xprt->cong += RPC_CWNDSCALE;
} else if (!task->tk_timeout) {
task->tk_status = -ENOBUFS;
} else {
@@ -1189,35 +1184,48 @@
}
/*
- * Reservation callback
+ * Reserve a ping RPC call slot.
*/
-static void
-xprt_reserve_status(struct rpc_task *task)
+int
+xprt_ping_reserve(struct rpc_task *task)
{
struct rpc_xprt *xprt = task->tk_xprt;
- struct rpc_rqst *req;
- if (xprt->shutdown) {
- task->tk_status = -EIO;
- } else if (task->tk_status < 0) {
- /* NOP */
- } else if (task->tk_rqstp) {
- /* We've already been given a request slot: NOP */
- } else {
- if (RPCXPRT_CONGESTED(xprt) || !(req = xprt->free))
- goto out_nofree;
- /* OK: There's room for us. Grab a free slot and bump
- * congestion value */
- xprt->free = req->rq_next;
- req->rq_next = NULL;
- xprt->cong += RPC_CWNDSCALE;
- task->tk_rqstp = req;
- xprt_request_init(task, xprt);
+ /* We already have an initialized request. */
+ if (task->tk_rqstp)
+ return 0;
- if (xprt->free)
- xprt_clear_backlog(xprt);
- }
+ dprintk("RPC: %4d xprt_ping_reserve cong = %ld cwnd = %ld\n",
+ task->tk_pid, xprt->cong, xprt->cwnd);
+ spin_lock_bh(&xprt->xprt_lock);
+ xprt_alloc_slot(xprt, task);
+ if (!task->tk_rqstp)
+ task->tk_status = -ENOBUFS;
+ spin_unlock_bh(&xprt->xprt_lock);
+ dprintk("RPC: %4d xprt_ping_reserve returns %d\n",
+ task->tk_pid, task->tk_status);
+ return task->tk_status;
+}
+/*
+ * Reserve a slot
+ */
+static void
+xprt_alloc_slot(struct rpc_xprt *xprt, struct rpc_task *task)
+{
+ struct rpc_rqst *req;
+
+ if (!(req = xprt->free))
+ goto out_nofree;
+ /* OK: There's room for us. Grab a free slot and bump
+ * congestion value */
+ xprt->free = req->rq_next;
+ req->rq_next = NULL;
+ task->tk_rqstp = req;
+ xprt_request_init(task, xprt);
+
+ if (xprt->free)
+ xprt_clear_backlog(xprt);
return;
out_nofree:
@@ -1249,8 +1257,8 @@
/*
* Release an RPC call slot
*/
-void
-xprt_release(struct rpc_task *task)
+static void
+__xprt_release(struct rpc_task *task, int congvalue)
{
struct rpc_xprt *xprt = task->tk_xprt;
struct rpc_rqst *req;
@@ -1271,13 +1279,26 @@
req->rq_next = xprt->free;
xprt->free = req;
- /* Decrease congestion value. */
- xprt->cong -= RPC_CWNDSCALE;
-
- xprt_clear_backlog(xprt);
+ if (congvalue) {
+ /* Decrease congestion value. */
+ xprt->cong -= congvalue;
+ xprt_clear_backlog(xprt);
+ }
spin_unlock_bh(&xprt->xprt_lock);
}
+void
+xprt_release(struct rpc_task *task)
+{
+ __xprt_release(task, RPC_CWNDSCALE);
+}
+
+void
+xprt_ping_release(struct rpc_task *task)
+{
+ __xprt_release(task, 0);
+}
+
/*
* Set default timeout parameters
*/
@@ -1347,6 +1368,7 @@
xprt->pending = RPC_INIT_WAITQ("xprt_pending");
xprt->sending = RPC_INIT_WAITQ("xprt_sending");
xprt->backlog = RPC_INIT_WAITQ("xprt_backlog");
+ xprt->pingwait= RPC_INIT_WAITQ("xprt_pingwait");
/* initialize free list */
for (i = 0, req = xprt->slot; i < RPC_MAXREQS-1; i++, req++)
@@ -1479,6 +1501,7 @@
rpc_wake_up(&xprt->sending);
rpc_wake_up(&xprt->pending);
rpc_wake_up(&xprt->backlog);
+ rpc_wake_up(&xprt->pingwait);
if (waitqueue_active(&xprt->cong_wait))
wake_up(&xprt->cong_wait);
}