Merge git://git.linux-nfs.org/pub/linux/nfs-2.6

* git://git.linux-nfs.org/pub/linux/nfs-2.6: (103 commits)
  SUNRPC,RPCSEC_GSS: spkm3--fix config dependencies
  SUNRPC,RPCSEC_GSS: spkm3: import contexts using NID_cast5_cbc
  LOCKD: Make nlmsvc_traverse_shares return void
  LOCKD: nlmsvc_traverse_blocks return is unused
  SUNRPC,RPCSEC_GSS: fix krb5 sequence numbers.
  NFSv4: Dont list system.nfs4_acl for filesystems that don't support it.
  SUNRPC,RPCSEC_GSS: remove unnecessary kmalloc of a checksum
  SUNRPC: Ensure rpc_call_async() always calls tk_ops->rpc_release()
  SUNRPC: Fix memory barriers for req->rq_received
  NFS: Fix a race in nfs_sync_inode()
  NFS: Clean up nfs_flush_list()
  NFS: Fix a race with PG_private and nfs_release_page()
  NFSv4: Ensure the callback daemon flushes signals
  SUNRPC: Fix a 'Busy inodes' error in rpc_pipefs
  NFS, NLM: Allow blocking locks to respect signals
  NFS: Make nfs_fhget() return appropriate error values
  NFSv4: Fix an oops in nfs4_fill_super
  lockd: blocks should hold a reference to the nlm_file
  NFSv4: SETCLIENTID_CONFIRM should handle NFS4ERR_DELAY/NFS4ERR_RESOURCE
  NFSv4: Send the delegation stateid for SETATTR calls
  ...

14 files changed, 153 insertions, 128 deletions

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 21e8cf795c38..5adf32b90f36 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -678,7 +678,6 @@ extern spinlock_t files_lock;
 #define FL_POSIX        1
 #define FL_FLOCK        2
 #define FL_ACCESS       8       /* not trying to lock, just looking */
-#define FL_LOCKD        16      /* lock held by rpc.lockd */
 #define FL_LEASE        32      /* lease held on this file */
 #define FL_SLEEP        128     /* A blocking lock */
 
@@ -742,8 +741,6 @@ struct file_lock {
 #define OFFT_OFFSET_MAX INT_LIMIT(off_t)
 #endif
 
-extern struct list_head file_lock_list;
-
 #include <linux/fcntl.h>
 
 extern int fcntl_getlk(struct file *, struct flock __user *);
@@ -765,10 +762,9 @@ extern void locks_init_lock(struct file_lock *);
 extern void locks_copy_lock(struct file_lock *, struct file_lock *);
 extern void locks_remove_posix(struct file *, fl_owner_t);
 extern void locks_remove_flock(struct file *);
-extern struct file_lock *posix_test_lock(struct file *, struct file_lock *);
+extern int posix_test_lock(struct file *, struct file_lock *, struct file_lock *);
 extern int posix_lock_file(struct file *, struct file_lock *);
 extern int posix_lock_file_wait(struct file *, struct file_lock *);
-extern void posix_block_lock(struct file_lock *, struct file_lock *);
 extern int posix_unblock_lock(struct file *, struct file_lock *);
 extern int posix_locks_deadlock(struct file_lock *, struct file_lock *);
 extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
@@ -1097,6 +1093,7 @@ struct super_operations {
         void (*umount_begin) (struct super_block *);
 
         int (*show_options)(struct seq_file *, struct vfsmount *);
+        int (*show_stats)(struct seq_file *, struct vfsmount *);
 
         ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
         ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h
index ef21ed296039..995f89dc8c04 100644
--- a/include/linux/lockd/lockd.h
+++ b/include/linux/lockd/lockd.h
@@ -14,6 +14,7 @@
 #include <linux/config.h>
 #include <linux/in.h>
 #include <linux/fs.h>
+#include <linux/kref.h>
 #include <linux/utsname.h>
 #include <linux/nfsd/nfsfh.h>
 #include <linux/lockd/bind.h>
@@ -58,6 +59,8 @@ struct nlm_host {
         unsigned long           h_expires;      /* eligible for GC */
         struct list_head        h_lockowners;   /* Lockowners for the client */
         spinlock_t              h_lock;
+        struct list_head        h_granted;      /* Locks in GRANTED state */
+        struct list_head        h_reclaim;      /* Locks in RECLAIM state */
 };
 
 /*
@@ -83,9 +86,9 @@ struct nlm_rqst {
         struct nlm_host *       a_host;         /* host handle */
         struct nlm_args         a_args;         /* arguments */
         struct nlm_res          a_res;          /* result */
-        struct nlm_wait *       a_block;
+        struct nlm_block *      a_block;
         unsigned int            a_retries;      /* Retry count */
-        char                    a_owner[NLMCLNT_OHSIZE];
+        u8                      a_owner[NLMCLNT_OHSIZE];
 };
 
 /*
@@ -110,16 +113,16 @@ struct nlm_file {
  */
 #define NLM_NEVER               (~(unsigned long) 0)
 struct nlm_block {
+        struct kref             b_count;        /* Reference count */
         struct nlm_block *      b_next;         /* linked list (all blocks) */
         struct nlm_block *      b_fnext;        /* linked list (per file) */
-        struct nlm_rqst         b_call;         /* RPC args & callback info */
+        struct nlm_rqst *       b_call;         /* RPC args & callback info */
         struct svc_serv *       b_daemon;       /* NLM service */
         struct nlm_host *       b_host;         /* host handle for RPC clnt */
         unsigned long           b_when;         /* next re-xmit */
         unsigned int            b_id;           /* block id */
         unsigned char           b_queued;       /* re-queued */
         unsigned char           b_granted;      /* VFS granted lock */
-        unsigned char           b_incall;       /* doing callback */
         unsigned char           b_done;         /* callback complete */
         struct nlm_file *       b_file;         /* file in question */
 };
@@ -145,15 +148,16 @@ extern unsigned long		nlmsvc_timeout;
 /*
  * Lockd client functions
  */
-struct nlm_rqst * nlmclnt_alloc_call(void);
-int               nlmclnt_prepare_block(struct nlm_rqst *req, struct nlm_host *host, struct file_lock *fl);
-void              nlmclnt_finish_block(struct nlm_rqst *req);
-long              nlmclnt_block(struct nlm_rqst *req, long timeout);
+struct nlm_rqst * nlm_alloc_call(struct nlm_host *host);
+void              nlm_release_call(struct nlm_rqst *);
+int               nlm_async_call(struct nlm_rqst *, u32, const struct rpc_call_ops *);
+int               nlm_async_reply(struct nlm_rqst *, u32, const struct rpc_call_ops *);
+struct nlm_wait * nlmclnt_prepare_block(struct nlm_host *host, struct file_lock *fl);
+void              nlmclnt_finish_block(struct nlm_wait *block);
+int               nlmclnt_block(struct nlm_wait *block, struct nlm_rqst *req, long timeout);
 u32               nlmclnt_grant(const struct sockaddr_in *addr, const struct nlm_lock *);
 void              nlmclnt_recovery(struct nlm_host *, u32);
 int               nlmclnt_reclaim(struct nlm_host *, struct file_lock *);
-int               nlmclnt_setgrantargs(struct nlm_rqst *, struct nlm_lock *);
-void              nlmclnt_freegrantargs(struct nlm_rqst *);
 
 /*
  * Host cache
@@ -172,7 +176,6 @@ extern struct nlm_host *nlm_find_client(void);
 /*
  * Server-side lock handling
  */
-int               nlmsvc_async_call(struct nlm_rqst *, u32, const struct rpc_call_ops *);
 u32               nlmsvc_lock(struct svc_rqst *, struct nlm_file *,
                                         struct nlm_lock *, int, struct nlm_cookie *);
 u32               nlmsvc_unlock(struct nlm_file *, struct nlm_lock *);
@@ -180,7 +183,7 @@ u32		  nlmsvc_testlock(struct nlm_file *, struct nlm_lock *,
                                         struct nlm_lock *);
 u32               nlmsvc_cancel_blocked(struct nlm_file *, struct nlm_lock *);
 unsigned long     nlmsvc_retry_blocked(void);
-int               nlmsvc_traverse_blocks(struct nlm_host *, struct nlm_file *,
+void              nlmsvc_traverse_blocks(struct nlm_host *, struct nlm_file *,
                                         int action);
 void      nlmsvc_grant_reply(struct svc_rqst *, struct nlm_cookie *, u32);
 
diff --git a/include/linux/lockd/share.h b/include/linux/lockd/share.h
index 5d8aa325f140..c75a424ebe4c 100644
--- a/include/linux/lockd/share.h
+++ b/include/linux/lockd/share.h
@@ -25,6 +25,6 @@ u32	nlmsvc_share_file(struct nlm_host *, struct nlm_file *,
                                                struct nlm_args *);
 u32     nlmsvc_unshare_file(struct nlm_host *, struct nlm_file *,
                                                struct nlm_args *);
-int     nlmsvc_traverse_shares(struct nlm_host *, struct nlm_file *, int);
+void    nlmsvc_traverse_shares(struct nlm_host *, struct nlm_file *, int);
 
 #endif /* LINUX_LOCKD_SHARE_H */
diff --git a/include/linux/lockd/xdr.h b/include/linux/lockd/xdr.h
index d7a5cc4cfa97..bb0a0f1caa91 100644
--- a/include/linux/lockd/xdr.h
+++ b/include/linux/lockd/xdr.h
@@ -28,6 +28,7 @@ struct nlm_lock {
         int                     len;    /* length of "caller" */
         struct nfs_fh           fh;
         struct xdr_netobj       oh;
+        u32                     svid;
         struct file_lock        fl;
 };
 
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index b4dc6e2e10c9..cbebd7d1b9e8 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -56,9 +56,7 @@
  * When flushing a cluster of dirty pages, there can be different
  * strategies:
  */
-#define FLUSH_AGING             0       /* only flush old buffers */
 #define FLUSH_SYNC              1       /* file being synced, or contention */
-#define FLUSH_WAIT              2       /* wait for completion */
 #define FLUSH_STABLE            4       /* commit to stable storage */
 #define FLUSH_LOWPRI            8       /* low priority background flush */
 #define FLUSH_HIGHPRI           16      /* high priority memory reclaim flush */
@@ -78,6 +76,7 @@ struct nfs_access_entry {
 struct nfs4_state;
 struct nfs_open_context {
         atomic_t count;
+        struct vfsmount *vfsmnt;
         struct dentry *dentry;
         struct rpc_cred *cred;
         struct nfs4_state *state;
@@ -118,8 +117,7 @@ struct nfs_inode {
         unsigned long           cache_validity;         /* bit mask */
 
         /*
-         * read_cache_jiffies is when we started read-caching this inode,
-         * and read_cache_mtime is the mtime of the inode at that time.
+         * read_cache_jiffies is when we started read-caching this inode.
          * attrtimeo is for how long the cached information is assumed
          * to be valid. A successful attribute revalidation doubles
          * attrtimeo (up to acregmax/acdirmax), a failure resets it to
@@ -128,11 +126,6 @@ struct nfs_inode {
          * We need to revalidate the cached attrs for this inode if
          *
          *      jiffies - read_cache_jiffies > attrtimeo
-         *
-         * and invalidate any cached data/flush out any dirty pages if
-         * we find that
-         *
-         *      mtime != read_cache_mtime
          */
         unsigned long           read_cache_jiffies;
         unsigned long           attrtimeo;
@@ -311,12 +304,9 @@ extern void nfs_begin_attr_update(struct inode *);
 extern void nfs_end_attr_update(struct inode *);
 extern void nfs_begin_data_update(struct inode *);
 extern void nfs_end_data_update(struct inode *);
-extern struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, struct rpc_cred *cred);
 extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx);
 extern void put_nfs_open_context(struct nfs_open_context *ctx);
-extern void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx);
 extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, int mode);
-extern void nfs_file_clear_open_context(struct file *filp);
 
 /* linux/net/ipv4/ipconfig.c: trims ip addr off front of name, too. */
 extern u32 root_nfs_parse_addr(char *name); /*__init*/
@@ -415,21 +405,22 @@ extern int  nfs_writepage(struct page *page, struct writeback_control *wbc);
 extern int  nfs_writepages(struct address_space *, struct writeback_control *);
 extern int  nfs_flush_incompatible(struct file *file, struct page *page);
 extern int  nfs_updatepage(struct file *, struct page *, unsigned int, unsigned int);
-extern void nfs_writeback_done(struct rpc_task *task, void *data);
-extern void nfs_writedata_release(void *data);
+extern int nfs_writeback_done(struct rpc_task *, struct nfs_write_data *);
+extern void nfs_writedata_release(void *);
 
 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
-extern void nfs_commit_done(struct rpc_task *, void *data);
-extern void nfs_commit_release(void *data);
+struct nfs_write_data *nfs_commit_alloc(unsigned int pagecount);
+void nfs_commit_free(struct nfs_write_data *p);
 #endif
 
 /*
  * Try to write back everything synchronously (but check the
  * return value!)
  */
-extern int  nfs_sync_inode(struct inode *, unsigned long, unsigned int, int);
+extern int  nfs_sync_inode_wait(struct inode *, unsigned long, unsigned int, int);
 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
 extern int  nfs_commit_inode(struct inode *, int);
+extern void nfs_commit_release(void *wdata);
 #else
 static inline int
 nfs_commit_inode(struct inode *inode, int how)
@@ -447,7 +438,7 @@ nfs_have_writebacks(struct inode *inode)
 static inline int
 nfs_wb_all(struct inode *inode)
 {
-        int error = nfs_sync_inode(inode, 0, 0, FLUSH_WAIT);
+        int error = nfs_sync_inode_wait(inode, 0, 0, 0);
         return (error < 0) ? error : 0;
 }
 
@@ -456,8 +447,8 @@ nfs_wb_all(struct inode *inode)
  */
 static inline int nfs_wb_page_priority(struct inode *inode, struct page* page, int how)
 {
-        int error = nfs_sync_inode(inode, page->index, 1,
-                        how | FLUSH_WAIT | FLUSH_STABLE);
+        int error = nfs_sync_inode_wait(inode, page->index, 1,
+                        how | FLUSH_STABLE);
         return (error < 0) ? error : 0;
 }
 
@@ -469,37 +460,8 @@ static inline int nfs_wb_page(struct inode *inode, struct page* page)
 /*
  * Allocate and free nfs_write_data structures
  */
-extern mempool_t *nfs_wdata_mempool;
-
-static inline struct nfs_write_data *nfs_writedata_alloc(unsigned int pagecount)
-{
-        struct nfs_write_data *p = mempool_alloc(nfs_wdata_mempool, SLAB_NOFS);
-
-        if (p) {
-                memset(p, 0, sizeof(*p));
-                INIT_LIST_HEAD(&p->pages);
-                if (pagecount < NFS_PAGEVEC_SIZE)
-                        p->pagevec = &p->page_array[0];
-                else {
-                        size_t size = ++pagecount * sizeof(struct page *);
-                        p->pagevec = kmalloc(size, GFP_NOFS);
-                        if (p->pagevec) {
-                                memset(p->pagevec, 0, size);
-                        } else {
-                                mempool_free(p, nfs_wdata_mempool);
-                                p = NULL;
-                        }
-                }
-        }
-        return p;
-}
-
-static inline void nfs_writedata_free(struct nfs_write_data *p)
-{
-        if (p && (p->pagevec != &p->page_array[0]))
-                kfree(p->pagevec);
-        mempool_free(p, nfs_wdata_mempool);
-}
+extern struct nfs_write_data *nfs_writedata_alloc(unsigned int pagecount);
+extern void nfs_writedata_free(struct nfs_write_data *p);
 
 /*
  * linux/fs/nfs/read.c
@@ -507,44 +469,14 @@ static inline void nfs_writedata_free(struct nfs_write_data *p)
 extern int  nfs_readpage(struct file *, struct page *);
 extern int  nfs_readpages(struct file *, struct address_space *,
                 struct list_head *, unsigned);
-extern void nfs_readpage_result(struct rpc_task *, void *);
-extern void  nfs_readdata_release(void *data);
-
+extern int  nfs_readpage_result(struct rpc_task *, struct nfs_read_data *);
+extern void nfs_readdata_release(void *data);
 
 /*
  * Allocate and free nfs_read_data structures
  */
-extern mempool_t *nfs_rdata_mempool;
-
-static inline struct nfs_read_data *nfs_readdata_alloc(unsigned int pagecount)
-{
-        struct nfs_read_data *p = mempool_alloc(nfs_rdata_mempool, SLAB_NOFS);
-
-        if (p) {
-                memset(p, 0, sizeof(*p));
-                INIT_LIST_HEAD(&p->pages);
-                if (pagecount < NFS_PAGEVEC_SIZE)
-                        p->pagevec = &p->page_array[0];
-                else {
-                        size_t size = ++pagecount * sizeof(struct page *);
-                        p->pagevec = kmalloc(size, GFP_NOFS);
-                        if (p->pagevec) {
-                                memset(p->pagevec, 0, size);
-                        } else {
-                                mempool_free(p, nfs_rdata_mempool);
-                                p = NULL;
-                        }
-                }
-        }
-        return p;
-}
-
-static inline void nfs_readdata_free(struct nfs_read_data *p)
-{
-        if (p && (p->pagevec != &p->page_array[0]))
-                kfree(p->pagevec);
-        mempool_free(p, nfs_rdata_mempool);
-}
+extern struct nfs_read_data *nfs_readdata_alloc(unsigned int pagecount);
+extern void nfs_readdata_free(struct nfs_read_data *p);
 
 /*
  * linux/fs/nfs3proc.c
diff --git a/include/linux/nfs_fs_i.h b/include/linux/nfs_fs_i.h
index e2c18dabff86..861730275ba0 100644
--- a/include/linux/nfs_fs_i.h
+++ b/include/linux/nfs_fs_i.h
@@ -12,8 +12,8 @@ struct nlm_lockowner;
  */
 struct nfs_lock_info {
         u32             state;
-        u32             flags;
         struct nlm_lockowner *owner;
+        struct list_head list;
 };
 
 struct nfs4_lock_state;
@@ -21,10 +21,4 @@ struct nfs4_lock_info {
         struct nfs4_lock_state *owner;
 };
 
-/*
- * Lock flag values
- */
-#define NFS_LCK_GRANTED         0x0001          /* lock has been granted */
-#define NFS_LCK_RECLAIM         0x0002          /* lock marked for reclaiming */
-
 #endif
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 3d3a305488cf..65dec21af774 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -4,6 +4,8 @@
 #include <linux/list.h>
 #include <linux/backing-dev.h>
 
+struct nfs_iostats;
+
 /*
  * NFS client parameters stored in the superblock.
  */
@@ -12,6 +14,7 @@ struct nfs_server {
         struct rpc_clnt *       client_sys;     /* 2nd handle for FSINFO */
         struct rpc_clnt *       client_acl;     /* ACL RPC client handle */
         struct nfs_rpc_ops *    rpc_ops;        /* NFS protocol vector */
+        struct nfs_iostats *    io_stats;       /* I/O statistics */
         struct backing_dev_info backing_dev_info;
         int                     flags;          /* various flags */
         unsigned int            caps;           /* server capabilities */
@@ -26,10 +29,13 @@ struct nfs_server {
         unsigned int            acregmax;
         unsigned int            acdirmin;
         unsigned int            acdirmax;
+        unsigned long           retrans_timeo;  /* retransmit timeout */
+        unsigned int            retrans_count;  /* number of retransmit tries */
         unsigned int            namelen;
         char *                  hostname;       /* remote hostname */
         struct nfs_fh           fh;
         struct sockaddr_in      addr;
+        unsigned long           mount_time;     /* when this fs was mounted */
 #ifdef CONFIG_NFS_V4
         /* Our own IP address, as a null-terminated string.
          * This is used to generate the clientid, and the callback address.
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 6d6f69ec5675..7fafc4c546b7 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -695,7 +695,6 @@ struct nfs_read_data {
 #ifdef CONFIG_NFS_V4
         unsigned long           timestamp;      /* For lease renewal */
 #endif
-        void (*complete) (struct nfs_read_data *, int);
         struct page             *page_array[NFS_PAGEVEC_SIZE + 1];
 };
 
@@ -714,7 +713,6 @@ struct nfs_write_data {
 #ifdef CONFIG_NFS_V4
         unsigned long           timestamp;      /* For lease renewal */
 #endif
-        void (*complete) (struct nfs_write_data *, int);
         struct page             *page_array[NFS_PAGEVEC_SIZE + 1];
 };
 
@@ -769,8 +767,11 @@ struct nfs_rpc_ops {
                              struct nfs_pathconf *);
         u32 *   (*decode_dirent)(u32 *, struct nfs_entry *, int plus);
         void    (*read_setup)   (struct nfs_read_data *);
+        int     (*read_done)  (struct rpc_task *, struct nfs_read_data *);
         void    (*write_setup)  (struct nfs_write_data *, int how);
+        int     (*write_done)  (struct rpc_task *, struct nfs_write_data *);
         void    (*commit_setup) (struct nfs_write_data *, int how);
+        int     (*commit_done) (struct rpc_task *, struct nfs_write_data *);
         int     (*file_open)   (struct inode *, struct file *);
         int     (*file_release) (struct inode *, struct file *);
         int     (*lock)(struct file *, int, struct file_lock *);
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 *);