1 files changed, 99 insertions, 1 deletions

diff --git a/net/sunrpc/svc_xprt.c b/net/sunrpc/svc_xprt.c
index 0551b6b6cf8c..1e66f2491460 100644
--- a/net/sunrpc/svc_xprt.c
+++ b/net/sunrpc/svc_xprt.c
@@ -318,6 +318,8 @@ void svc_xprt_enqueue(struct svc_xprt *xprt)
                 goto out_unlock;
         }
 
+        pool->sp_stats.packets++;
+
         /* Mark transport as busy. It will remain in this state until
          * the provider calls svc_xprt_received. We update XPT_BUSY
          * atomically because it also guards against trying to enqueue
@@ -355,6 +357,7 @@ void svc_xprt_enqueue(struct svc_xprt *xprt)
         if (pool->sp_nwaking >= SVC_MAX_WAKING) {
                 /* too many threads are runnable and trying to wake up */
                 thread_avail = 0;
+                pool->sp_stats.overloads_avoided++;
         }
 
         if (thread_avail) {
@@ -374,11 +377,13 @@ void svc_xprt_enqueue(struct svc_xprt *xprt)
                 atomic_add(rqstp->rq_reserved, &xprt->xpt_reserved);
                 rqstp->rq_waking = 1;
                 pool->sp_nwaking++;
+                pool->sp_stats.threads_woken++;
                 BUG_ON(xprt->xpt_pool != pool);
                 wake_up(&rqstp->rq_wait);
         } else {
                 dprintk("svc: transport %p put into queue\n", xprt);
                 list_add_tail(&xprt->xpt_ready, &pool->sp_sockets);
+                pool->sp_stats.sockets_queued++;
                 BUG_ON(xprt->xpt_pool != pool);
         }
 
@@ -591,6 +596,7 @@ int svc_recv(struct svc_rqst *rqstp, long timeout)
         int                     pages;
         struct xdr_buf          *arg;
         DECLARE_WAITQUEUE(wait, current);
+        long                    time_left;
 
         dprintk("svc: server %p waiting for data (to = %ld)\n",
                 rqstp, timeout);
@@ -676,12 +682,14 @@ int svc_recv(struct svc_rqst *rqstp, long timeout)
                 add_wait_queue(&rqstp->rq_wait, &wait);
                 spin_unlock_bh(&pool->sp_lock);
 
-                schedule_timeout(timeout);
+                time_left = schedule_timeout(timeout);
 
                 try_to_freeze();
 
                 spin_lock_bh(&pool->sp_lock);
                 remove_wait_queue(&rqstp->rq_wait, &wait);
+                if (!time_left)
+                        pool->sp_stats.threads_timedout++;
 
                 xprt = rqstp->rq_xprt;
                 if (!xprt) {
@@ -1114,3 +1122,93 @@ int svc_xprt_names(struct svc_serv *serv, char *buf, int buflen)
         return totlen;
 }
 EXPORT_SYMBOL_GPL(svc_xprt_names);
+
+
+/*----------------------------------------------------------------------------*/
+
+static void *svc_pool_stats_start(struct seq_file *m, loff_t *pos)
+{
+        unsigned int pidx = (unsigned int)*pos;
+        struct svc_serv *serv = m->private;
+
+        dprintk("svc_pool_stats_start, *pidx=%u\n", pidx);
+
+        lock_kernel();
+        /* bump up the pseudo refcount while traversing */
+        svc_get(serv);
+        unlock_kernel();
+
+        if (!pidx)
+                return SEQ_START_TOKEN;
+        return (pidx > serv->sv_nrpools ? NULL : &serv->sv_pools[pidx-1]);
+}
+
+static void *svc_pool_stats_next(struct seq_file *m, void *p, loff_t *pos)
+{
+        struct svc_pool *pool = p;
+        struct svc_serv *serv = m->private;
+
+        dprintk("svc_pool_stats_next, *pos=%llu\n", *pos);
+
+        if (p == SEQ_START_TOKEN) {
+                pool = &serv->sv_pools[0];
+        } else {
+                unsigned int pidx = (pool - &serv->sv_pools[0]);
+                if (pidx < serv->sv_nrpools-1)
+                        pool = &serv->sv_pools[pidx+1];
+                else
+                        pool = NULL;
+        }
+        ++*pos;
+        return pool;
+}
+
+static void svc_pool_stats_stop(struct seq_file *m, void *p)
+{
+        struct svc_serv *serv = m->private;
+
+        lock_kernel();
+        /* this function really, really should have been called svc_put() */
+        svc_destroy(serv);
+        unlock_kernel();
+}
+
+static int svc_pool_stats_show(struct seq_file *m, void *p)
+{
+        struct svc_pool *pool = p;
+
+        if (p == SEQ_START_TOKEN) {
+                seq_puts(m, "# pool packets-arrived sockets-enqueued threads-woken overloads-avoided threads-timedout\n");
+                return 0;
+        }
+
+        seq_printf(m, "%u %lu %lu %lu %lu %lu\n",
+                pool->sp_id,
+                pool->sp_stats.packets,
+                pool->sp_stats.sockets_queued,
+                pool->sp_stats.threads_woken,
+                pool->sp_stats.overloads_avoided,
+                pool->sp_stats.threads_timedout);
+
+        return 0;
+}
+
+static const struct seq_operations svc_pool_stats_seq_ops = {
+        .start  = svc_pool_stats_start,
+        .next   = svc_pool_stats_next,
+        .stop   = svc_pool_stats_stop,
+        .show   = svc_pool_stats_show,
+};
+
+int svc_pool_stats_open(struct svc_serv *serv, struct file *file)
+{
+        int err;
+
+        err = seq_open(file, &svc_pool_stats_seq_ops);
+        if (!err)
+                ((struct seq_file *) file->private_data)->private = serv;
+        return err;
+}
+EXPORT_SYMBOL(svc_pool_stats_open);
+
+/*----------------------------------------------------------------------------*/