6 files changed, 107 insertions, 16 deletions

diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
index f147e6b84332..8fe9f35eba31 100644
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -45,7 +45,8 @@ struct rpc_clnt {
         char *                  cl_server;      /* server machine name */
         char *                  cl_protname;    /* protocol name */
         struct rpc_auth *       cl_auth;        /* authenticator */
-        struct rpc_stat *       cl_stats;       /* statistics */
+        struct rpc_stat *       cl_stats;       /* per-program statistics */
+        struct rpc_iostats *    cl_metrics;     /* per-client statistics */
 
         unsigned int            cl_softrtry : 1,/* soft timeouts */
                                 cl_intr     : 1,/* interruptible */
@@ -59,6 +60,7 @@ struct rpc_clnt {
         int                     cl_nodelen;     /* nodename length */
         char                    cl_nodename[UNX_MAXNODENAME];
         char                    cl_pathname[30];/* Path in rpc_pipe_fs */
+        struct vfsmount *       cl_vfsmnt;
         struct dentry *         cl_dentry;      /* inode */
         struct rpc_clnt *       cl_parent;      /* Points to parent of clones */
         struct rpc_rtt          cl_rtt_default;
@@ -100,6 +102,8 @@ struct rpc_procinfo {
         unsigned int            p_bufsiz;       /* req. buffer size */
         unsigned int            p_count;        /* call count */
         unsigned int            p_timer;        /* Which RTT timer to use */
+        u32                     p_statidx;      /* Which procedure to account */
+        char *                  p_name;         /* name of procedure */
 };
 
 #define RPC_CONGESTED(clnt)     (RPCXPRT_CONGESTED((clnt)->cl_xprt))
@@ -137,20 +141,6 @@ size_t		rpc_max_payload(struct rpc_clnt *);
 void            rpc_force_rebind(struct rpc_clnt *);
 int             rpc_ping(struct rpc_clnt *clnt, int flags);
 
-static __inline__
-int rpc_call(struct rpc_clnt *clnt, u32 proc, void *argp, void *resp, int flags)
-{
-        struct rpc_message msg = {
-                .rpc_proc       = &clnt->cl_procinfo[proc],
-                .rpc_argp       = argp,
-                .rpc_resp       = resp,
-                .rpc_cred       = NULL
-        };
-        return rpc_call_sync(clnt, &msg, flags);
-}
-                
-extern void rpciod_wake_up(void);
-
 /*
  * Helper function for NFSroot support
  */
diff --git a/include/linux/sunrpc/gss_krb5.h b/include/linux/sunrpc/gss_krb5.h
index 2c3601d31045..1279280d7196 100644
--- a/include/linux/sunrpc/gss_krb5.h
+++ b/include/linux/sunrpc/gss_krb5.h
@@ -53,6 +53,8 @@ struct krb5_ctx {
         struct xdr_netobj       mech_used;
 };
 
+extern spinlock_t krb5_seq_lock;
+
 #define KG_TOK_MIC_MSG    0x0101
 #define KG_TOK_WRAP_MSG   0x0201
 
diff --git a/include/linux/sunrpc/metrics.h b/include/linux/sunrpc/metrics.h
new file mode 100644
index 000000000000..8f96e9dc369a
--- /dev/null
+++ b/include/linux/sunrpc/metrics.h
@@ -0,0 +1,77 @@
+/*
+ *  linux/include/linux/sunrpc/metrics.h
+ *
+ *  Declarations for RPC client per-operation metrics
+ *
+ *  Copyright (C) 2005  Chuck Lever <cel@netapp.com>
+ *
+ *  RPC client per-operation statistics provide latency and retry
+ *  information about each type of RPC procedure in a given RPC program.
+ *  These statistics are not for detailed problem diagnosis, but simply
+ *  to indicate whether the problem is local or remote.
+ *
+ *  These counters are not meant to be human-readable, but are meant to be
+ *  integrated into system monitoring tools such as "sar" and "iostat".  As
+ *  such, the counters are sampled by the tools over time, and are never
+ *  zeroed after a file system is mounted.  Moving averages can be computed
+ *  by the tools by taking the difference between two instantaneous samples
+ *  and dividing that by the time between the samples.
+ *
+ *  The counters are maintained in a single array per RPC client, indexed
+ *  by procedure number.  There is no need to maintain separate counter
+ *  arrays per-CPU because these counters are always modified behind locks.
+ */
+
+#ifndef _LINUX_SUNRPC_METRICS_H
+#define _LINUX_SUNRPC_METRICS_H
+
+#include <linux/seq_file.h>
+
+#define RPC_IOSTATS_VERS        "1.0"
+
+struct rpc_iostats {
+        /*
+         * These counters give an idea about how many request
+         * transmissions are required, on average, to complete that
+         * particular procedure.  Some procedures may require more
+         * than one transmission because the server is unresponsive,
+         * the client is retransmitting too aggressively, or the
+         * requests are large and the network is congested.
+         */
+        unsigned long           om_ops,         /* count of operations */
+                                om_ntrans,      /* count of RPC transmissions */
+                                om_timeouts;    /* count of major timeouts */
+
+        /*
+         * These count how many bytes are sent and received for a
+         * given RPC procedure type.  This indicates how much load a
+         * particular procedure is putting on the network.  These
+         * counts include the RPC and ULP headers, and the request
+         * payload.
+         */
+        unsigned long long      om_bytes_sent,  /* count of bytes out */
+                                om_bytes_recv;  /* count of bytes in */
+
+        /*
+         * The length of time an RPC request waits in queue before
+         * transmission, the network + server latency of the request,
+         * and the total time the request spent from init to release
+         * are measured.
+         */
+        unsigned long long      om_queue,       /* jiffies queued for xmit */
+                                om_rtt,         /* jiffies for RPC RTT */
+                                om_execute;     /* jiffies for RPC execution */
+} ____cacheline_aligned;
+
+struct rpc_task;
+struct rpc_clnt;
+
+/*
+ * EXPORTed functions for managing rpc_iostats structures
+ */
+struct rpc_iostats *    rpc_alloc_iostats(struct rpc_clnt *);
+void                    rpc_count_iostats(struct rpc_task *);
+void                    rpc_print_iostats(struct seq_file *, struct rpc_clnt *);
+void                    rpc_free_iostats(struct rpc_iostats *);
+
+#endif /* _LINUX_SUNRPC_METRICS_H */
diff --git a/include/linux/sunrpc/rpc_pipe_fs.h b/include/linux/sunrpc/rpc_pipe_fs.h
index 63929349571f..2c2189cb30aa 100644
--- a/include/linux/sunrpc/rpc_pipe_fs.h
+++ b/include/linux/sunrpc/rpc_pipe_fs.h
@@ -45,6 +45,8 @@ extern struct dentry *rpc_mkdir(char *, struct rpc_clnt *);
 extern int rpc_rmdir(char *);
 extern struct dentry *rpc_mkpipe(char *, void *, struct rpc_pipe_ops *, int flags);
 extern int rpc_unlink(char *);
+extern struct vfsmount *rpc_get_mount(void);
+extern void rpc_put_mount(void);
 
 #endif
 #endif
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index 8b25629accd8..82a91bb22362 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -86,6 +86,12 @@ struct rpc_task {
                 struct work_struct      tk_work;        /* Async task work queue */
                 struct rpc_wait         tk_wait;        /* RPC wait */
         } u;
+
+        unsigned short          tk_timeouts;    /* maj timeouts */
+        size_t                  tk_bytes_sent;  /* total bytes sent */
+        unsigned long           tk_start;       /* RPC task init timestamp */
+        long                    tk_rtt;         /* round-trip time (jiffies) */
+
 #ifdef RPC_DEBUG
         unsigned short          tk_pid;         /* debugging aid */
 #endif
@@ -203,6 +209,7 @@ struct rpc_wait_queue {
         unsigned char           priority;               /* current priority */
         unsigned char           count;                  /* # task groups remaining serviced so far */
         unsigned char           nr;                     /* # tasks remaining for cookie */
+        unsigned short          qlen;                   /* total # tasks waiting in queue */
 #ifdef RPC_DEBUG
         const char *            name;
 #endif
@@ -269,13 +276,13 @@ void *		rpc_malloc(struct rpc_task *, size_t);
 void            rpc_free(struct rpc_task *);
 int             rpciod_up(void);
 void            rpciod_down(void);
-void            rpciod_wake_up(void);
 int             __rpc_wait_for_completion_task(struct rpc_task *task, int (*)(void *));
 #ifdef RPC_DEBUG
 void            rpc_show_tasks(void);
 #endif
 int             rpc_init_mempool(void);
 void            rpc_destroy_mempool(void);
+extern struct workqueue_struct *rpciod_workqueue;
 
 static inline void rpc_exit(struct rpc_task *task, int status)
 {
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 6ef99b14ff09..7eebbab7160b 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -114,6 +114,7 @@ struct rpc_xprt_ops {
         void            (*release_request)(struct rpc_task *task);
         void            (*close)(struct rpc_xprt *xprt);
         void            (*destroy)(struct rpc_xprt *xprt);
+        void            (*print_stats)(struct rpc_xprt *xprt, struct seq_file *seq);
 };
 
 struct rpc_xprt {
@@ -187,6 +188,18 @@ struct rpc_xprt {
 
         struct list_head        recv;
 
+        struct {
+                unsigned long           bind_count,     /* total number of binds */
+                                        connect_count,  /* total number of connects */
+                                        connect_start,  /* connect start timestamp */
+                                        connect_time,   /* jiffies waiting for connect */
+                                        sends,          /* how many complete requests */
+                                        recvs,          /* how many complete requests */
+                                        bad_xids;       /* lookup_rqst didn't find XID */
+
+                unsigned long long      req_u,          /* average requests on the wire */
+                                        bklog_u;        /* backlog queue utilization */
+        } stat;
 
         void                    (*old_data_ready)(struct sock *, int);
         void                    (*old_state_change)(struct sock *);