9 files changed, 168 insertions, 97 deletions

diff --git a/include/linux/lockd/bind.h b/include/linux/lockd/bind.h
index 6f1637c61e10..3d25bcd139d1 100644
--- a/include/linux/lockd/bind.h
+++ b/include/linux/lockd/bind.h
@@ -33,9 +33,26 @@ struct nlmsvc_binding {
 extern struct nlmsvc_binding *  nlmsvc_ops;
 
 /*
+ * Similar to nfs_client_initdata, but without the NFS-specific
+ * rpc_ops field.
+ */
+struct nlmclnt_initdata {
+        const char              *hostname;
+        const struct sockaddr   *address;
+        size_t                  addrlen;
+        unsigned short          protocol;
+        u32                     nfs_version;
+};
+
+/*
  * Functions exported by the lockd module
  */
-extern int      nlmclnt_proc(struct inode *, int, struct file_lock *);
+
+extern struct nlm_host *nlmclnt_init(const struct nlmclnt_initdata *nlm_init);
+extern void     nlmclnt_done(struct nlm_host *host);
+
+extern int      nlmclnt_proc(struct nlm_host *host, int cmd,
+                                        struct file_lock *fl);
 extern int      lockd_up(int proto);
 extern void     lockd_down(void);
 
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 2d15d4aac094..099ddb4481c0 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -196,28 +196,67 @@ struct nfs_inode {
 #define NFS_INO_STALE           (2)             /* possible stale inode */
 #define NFS_INO_ACL_LRU_SET     (3)             /* Inode is on the LRU list */
 
-static inline struct nfs_inode *NFS_I(struct inode *inode)
+static inline struct nfs_inode *NFS_I(const struct inode *inode)
 {
         return container_of(inode, struct nfs_inode, vfs_inode);
 }
-#define NFS_SB(s)               ((struct nfs_server *)(s->s_fs_info))
 
-#define NFS_FH(inode)                   (&NFS_I(inode)->fh)
-#define NFS_SERVER(inode)               (NFS_SB(inode->i_sb))
-#define NFS_CLIENT(inode)               (NFS_SERVER(inode)->client)
-#define NFS_PROTO(inode)                (NFS_SERVER(inode)->nfs_client->rpc_ops)
-#define NFS_COOKIEVERF(inode)           (NFS_I(inode)->cookieverf)
-#define NFS_MINATTRTIMEO(inode) \
-        (S_ISDIR(inode->i_mode)? NFS_SERVER(inode)->acdirmin \
-                               : NFS_SERVER(inode)->acregmin)
-#define NFS_MAXATTRTIMEO(inode) \
-        (S_ISDIR(inode->i_mode)? NFS_SERVER(inode)->acdirmax \
-                               : NFS_SERVER(inode)->acregmax)
+static inline struct nfs_server *NFS_SB(const struct super_block *s)
+{
+        return (struct nfs_server *)(s->s_fs_info);
+}
+
+static inline struct nfs_fh *NFS_FH(const struct inode *inode)
+{
+        return &NFS_I(inode)->fh;
+}
+
+static inline struct nfs_server *NFS_SERVER(const struct inode *inode)
+{
+        return NFS_SB(inode->i_sb);
+}
+
+static inline struct rpc_clnt *NFS_CLIENT(const struct inode *inode)
+{
+        return NFS_SERVER(inode)->client;
+}
+
+static inline const struct nfs_rpc_ops *NFS_PROTO(const struct inode *inode)
+{
+        return NFS_SERVER(inode)->nfs_client->rpc_ops;
+}
+
+static inline __be32 *NFS_COOKIEVERF(const struct inode *inode)
+{
+        return NFS_I(inode)->cookieverf;
+}
+
+static inline unsigned NFS_MINATTRTIMEO(const struct inode *inode)
+{
+        struct nfs_server *nfss = NFS_SERVER(inode);
+        return S_ISDIR(inode->i_mode) ? nfss->acdirmin : nfss->acregmin;
+}
 
-#define NFS_FLAGS(inode)                (NFS_I(inode)->flags)
-#define NFS_STALE(inode)                (test_bit(NFS_INO_STALE, &NFS_FLAGS(inode)))
+static inline unsigned NFS_MAXATTRTIMEO(const struct inode *inode)
+{
+        struct nfs_server *nfss = NFS_SERVER(inode);
+        return S_ISDIR(inode->i_mode) ? nfss->acdirmax : nfss->acregmax;
+}
 
-#define NFS_FILEID(inode)               (NFS_I(inode)->fileid)
+static inline int NFS_STALE(const struct inode *inode)
+{
+        return test_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
+}
+
+static inline __u64 NFS_FILEID(const struct inode *inode)
+{
+        return NFS_I(inode)->fileid;
+}
+
+static inline void set_nfs_fileid(struct inode *inode, __u64 fileid)
+{
+        NFS_I(inode)->fileid = fileid;
+}
 
 static inline void nfs_mark_for_revalidate(struct inode *inode)
 {
@@ -237,7 +276,7 @@ static inline int nfs_server_capable(struct inode *inode, int cap)
 
 static inline int NFS_USE_READDIRPLUS(struct inode *inode)
 {
-        return test_bit(NFS_INO_ADVISE_RDPLUS, &NFS_FLAGS(inode));
+        return test_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
 }
 
 static inline void nfs_set_verifier(struct dentry * dentry, unsigned long verf)
@@ -366,6 +405,7 @@ extern const struct inode_operations nfs3_dir_inode_operations;
 extern const struct file_operations nfs_dir_operations;
 extern struct dentry_operations nfs_dentry_operations;
 
+extern void nfs_force_lookup_revalidate(struct inode *dir);
 extern int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fh, struct nfs_fattr *fattr);
 extern int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags);
 extern void nfs_access_zap_cache(struct inode *inode);
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 0cac49bc0955..3423c6761bf7 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -3,8 +3,12 @@
 
 #include <linux/list.h>
 #include <linux/backing-dev.h>
+#include <linux/wait.h>
+
+#include <asm/atomic.h>
 
 struct nfs_iostats;
+struct nlm_host;
 
 /*
  * The nfs_client identifies our client state to the server.
@@ -14,20 +18,19 @@ struct nfs_client {
         int                     cl_cons_state;  /* current construction state (-ve: init error) */
 #define NFS_CS_READY            0               /* ready to be used */
 #define NFS_CS_INITING          1               /* busy initialising */
-        int                     cl_nfsversion;  /* NFS protocol version */
         unsigned long           cl_res_state;   /* NFS resources state */
 #define NFS_CS_CALLBACK         1               /* - callback started */
 #define NFS_CS_IDMAP            2               /* - idmap started */
 #define NFS_CS_RENEWD           3               /* - renewd started */
-        struct sockaddr_in      cl_addr;        /* server identifier */
+        struct sockaddr_storage cl_addr;        /* server identifier */
+        size_t                  cl_addrlen;
         char *                  cl_hostname;    /* hostname of server */
         struct list_head        cl_share_link;  /* link in global client list */
         struct list_head        cl_superblocks; /* List of nfs_server structs */
 
         struct rpc_clnt *       cl_rpcclient;
         const struct nfs_rpc_ops *rpc_ops;      /* NFS protocol vector */
-        unsigned long           retrans_timeo;  /* retransmit timeout */
-        unsigned int            retrans_count;  /* number of retransmit tries */
+        int                     cl_proto;       /* Network transport protocol */
 
 #ifdef CONFIG_NFS_V4
         u64                     cl_clientid;    /* constant */
@@ -62,7 +65,7 @@ struct nfs_client {
         /* Our own IP address, as a null-terminated string.
          * This is used to generate the clientid, and the callback address.
          */
-        char                    cl_ipaddr[16];
+        char                    cl_ipaddr[48];
         unsigned char           cl_id_uniquifier;
 #endif
 };
@@ -78,6 +81,7 @@ struct nfs_server {
         struct list_head        master_link;    /* link in master servers list */
         struct rpc_clnt *       client;         /* RPC client handle */
         struct rpc_clnt *       client_acl;     /* ACL RPC client handle */
+        struct nlm_host         *nlm_host;      /* NLM client handle */
         struct nfs_iostats *    io_stats;       /* I/O statistics */
         struct backing_dev_info backing_dev_info;
         atomic_long_t           writeback;      /* number of writeback pages */
@@ -110,6 +114,9 @@ struct nfs_server {
                                                    filesystem */
 #endif
         void (*destroy)(struct nfs_server *);
+
+        atomic_t active; /* Keep trace of any activity to this server */
+        wait_queue_head_t active_wq;  /* Wait for any activity to stop  */
 };
 
 /* Server capabilities */
diff --git a/include/linux/nfs_page.h b/include/linux/nfs_page.h
index 30dbcc185e69..a1676e19e491 100644
--- a/include/linux/nfs_page.h
+++ b/include/linux/nfs_page.h
@@ -83,6 +83,7 @@ extern	void nfs_pageio_complete(struct nfs_pageio_descriptor *desc);
 extern  void nfs_pageio_cond_complete(struct nfs_pageio_descriptor *, pgoff_t);
 extern  int nfs_wait_on_request(struct nfs_page *);
 extern  void nfs_unlock_request(struct nfs_page *req);
+extern  int nfs_set_page_tag_locked(struct nfs_page *req);
 extern  void nfs_clear_page_tag_locked(struct nfs_page *req);
 
 
@@ -95,18 +96,6 @@ nfs_lock_request_dontget(struct nfs_page *req)
         return !test_and_set_bit(PG_BUSY, &req->wb_flags);
 }
 
-/*
- * Lock the page of an asynchronous request and take a reference
- */
-static inline int
-nfs_lock_request(struct nfs_page *req)
-{
-        if (test_and_set_bit(PG_BUSY, &req->wb_flags))
-                return 0;
-        kref_get(&req->wb_kref);
-        return 1;
-}
-
 /**
  * nfs_list_add_request - Insert a request into a list
  * @req: request
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index daab252f2e5c..f301d0b8babc 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -666,16 +666,17 @@ struct nfs4_rename_res {
         struct nfs_fattr *              new_fattr;
 };
 
+#define NFS4_SETCLIENTID_NAMELEN        (56)
 struct nfs4_setclientid {
-        const nfs4_verifier *           sc_verifier;      /* request */
+        const nfs4_verifier *           sc_verifier;
         unsigned int                    sc_name_len;
-        char                            sc_name[48];      /* request */
-        u32                             sc_prog;          /* request */
+        char                            sc_name[NFS4_SETCLIENTID_NAMELEN];
+        u32                             sc_prog;
         unsigned int                    sc_netid_len;
-        char                            sc_netid[4];      /* request */
+        char                            sc_netid[RPCBIND_MAXNETIDLEN];
         unsigned int                    sc_uaddr_len;
-        char                            sc_uaddr[24];     /* request */
-        u32                             sc_cb_ident;      /* request */
+        char                            sc_uaddr[RPCBIND_MAXUADDRLEN];
+        u32                             sc_cb_ident;
 };
 
 struct nfs4_statfs_arg {
@@ -773,7 +774,7 @@ struct nfs_access_entry;
  * RPC procedure vector for NFSv2/NFSv3 demuxing
  */
 struct nfs_rpc_ops {
-        int     version;                /* Protocol version */
+        u32     version;                /* Protocol version */
         struct dentry_operations *dentry_ops;
         const struct inode_operations *dir_inode_ops;
         const struct inode_operations *file_inode_ops;
@@ -816,11 +817,11 @@ struct nfs_rpc_ops {
                              struct nfs_pathconf *);
         int     (*set_capabilities)(struct nfs_server *, struct nfs_fh *);
         __be32 *(*decode_dirent)(__be32 *, struct nfs_entry *, int plus);
-        void    (*read_setup)   (struct nfs_read_data *);
+        void    (*read_setup)   (struct nfs_read_data *, struct rpc_message *);
         int     (*read_done)  (struct rpc_task *, struct nfs_read_data *);
-        void    (*write_setup)  (struct nfs_write_data *, int how);
+        void    (*write_setup)  (struct nfs_write_data *, struct rpc_message *);
         int     (*write_done)  (struct rpc_task *, struct nfs_write_data *);
-        void    (*commit_setup) (struct nfs_write_data *, int how);
+        void    (*commit_setup) (struct nfs_write_data *, struct rpc_message *);
         int     (*commit_done) (struct rpc_task *, struct nfs_write_data *);
         int     (*file_open)   (struct inode *, struct file *);
         int     (*file_release) (struct inode *, struct file *);
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
index d9d5c5ad826c..3e9addc741c1 100644
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -46,6 +46,7 @@ struct rpc_clnt {
                                 cl_autobind : 1;/* use getport() */
 
         struct rpc_rtt *        cl_rtt;         /* RTO estimator data */
+        const struct rpc_timeout *cl_timeout;   /* Timeout strategy */
 
         int                     cl_nodelen;     /* nodename length */
         char                    cl_nodename[UNX_MAXNODENAME];
@@ -54,6 +55,7 @@ struct rpc_clnt {
         struct dentry *         cl_dentry;      /* inode */
         struct rpc_clnt *       cl_parent;      /* Points to parent of clones */
         struct rpc_rtt          cl_rtt_default;
+        struct rpc_timeout      cl_timeout_default;
         struct rpc_program *    cl_program;
         char                    cl_inline_name[32];
 };
@@ -99,7 +101,7 @@ struct rpc_create_args {
         struct sockaddr         *address;
         size_t                  addrsize;
         struct sockaddr         *saddress;
-        struct rpc_timeout      *timeout;
+        const struct rpc_timeout *timeout;
         char                    *servername;
         struct rpc_program      *program;
         u32                     version;
@@ -123,11 +125,10 @@ void		rpc_shutdown_client(struct rpc_clnt *);
 void            rpc_release_client(struct rpc_clnt *);
 
 int             rpcb_register(u32, u32, int, unsigned short, int *);
-int             rpcb_getport_sync(struct sockaddr_in *, __u32, __u32, int);
+int             rpcb_getport_sync(struct sockaddr_in *, u32, u32, int);
 void            rpcb_getport_async(struct rpc_task *);
 
-void            rpc_call_setup(struct rpc_task *, struct rpc_message *, int);
-
+void            rpc_call_start(struct rpc_task *);
 int             rpc_call_async(struct rpc_clnt *clnt, struct rpc_message *msg,
                                int flags, const struct rpc_call_ops *tk_ops,
                                void *calldata);
@@ -142,7 +143,7 @@ void		rpc_setbufsize(struct rpc_clnt *, unsigned int, unsigned int);
 size_t          rpc_max_payload(struct rpc_clnt *);
 void            rpc_force_rebind(struct rpc_clnt *);
 size_t          rpc_peeraddr(struct rpc_clnt *, struct sockaddr *, size_t);
-char *          rpc_peeraddr2str(struct rpc_clnt *, enum rpc_display_format_t);
+const char      *rpc_peeraddr2str(struct rpc_clnt *, enum rpc_display_format_t);
 
 #endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_CLNT_H */
diff --git a/include/linux/sunrpc/msg_prot.h b/include/linux/sunrpc/msg_prot.h
index c4beb5775111..70df4f1d8847 100644
--- a/include/linux/sunrpc/msg_prot.h
+++ b/include/linux/sunrpc/msg_prot.h
@@ -152,5 +152,44 @@ typedef __be32	rpc_fraghdr;
  */
 #define RPCBIND_MAXNETIDLEN     (4u)
 
+/*
+ * Universal addresses are introduced in RFC 1833 and further spelled
+ * out in RFC 3530.  RPCBIND_MAXUADDRLEN defines a maximum byte length
+ * of a universal address for use in allocating buffers and character
+ * arrays.
+ *
+ * Quoting RFC 3530, section 2.2:
+ *
+ * For TCP over IPv4 and for UDP over IPv4, the format of r_addr is the
+ * US-ASCII string:
+ *
+ *      h1.h2.h3.h4.p1.p2
+ *
+ * The prefix, "h1.h2.h3.h4", is the standard textual form for
+ * representing an IPv4 address, which is always four octets long.
+ * Assuming big-endian ordering, h1, h2, h3, and h4, are respectively,
+ * the first through fourth octets each converted to ASCII-decimal.
+ * Assuming big-endian ordering, p1 and p2 are, respectively, the first
+ * and second octets each converted to ASCII-decimal.  For example, if a
+ * host, in big-endian order, has an address of 0x0A010307 and there is
+ * a service listening on, in big endian order, port 0x020F (decimal
+ * 527), then the complete universal address is "10.1.3.7.2.15".
+ *
+ * ...
+ *
+ * For TCP over IPv6 and for UDP over IPv6, the format of r_addr is the
+ * US-ASCII string:
+ *
+ *      x1:x2:x3:x4:x5:x6:x7:x8.p1.p2
+ *
+ * The suffix "p1.p2" is the service port, and is computed the same way
+ * as with universal addresses for TCP and UDP over IPv4.  The prefix,
+ * "x1:x2:x3:x4:x5:x6:x7:x8", is the standard textual form for
+ * representing an IPv6 address as defined in Section 2.2 of [RFC2373].
+ * Additionally, the two alternative forms specified in Section 2.2 of
+ * [RFC2373] are also acceptable.
+ */
+#define RPCBIND_MAXUADDRLEN     (56u)
+
 #endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_MSGPROT_H_ */
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index 8ea077db0099..ce3d1b132729 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -56,8 +56,6 @@ struct rpc_task {
         __u8                    tk_garb_retry;
         __u8                    tk_cred_retry;
 
-        unsigned long           tk_cookie;      /* Cookie for batching tasks */
-
         /*
          * timeout_fn   to be executed by timer bottom half
          * callback     to be executed after waking up
@@ -78,7 +76,6 @@ struct rpc_task {
         struct timer_list       tk_timer;       /* kernel timer */
         unsigned long           tk_timeout;     /* timeout for rpc_sleep() */
         unsigned short          tk_flags;       /* misc flags */
-        unsigned char           tk_priority : 2;/* Task priority */
         unsigned long           tk_runstate;    /* Task run status */
         struct workqueue_struct *tk_workqueue;  /* Normally rpciod, but could
                                                  * be any workqueue
@@ -94,6 +91,9 @@ struct rpc_task {
         unsigned long           tk_start;       /* RPC task init timestamp */
         long                    tk_rtt;         /* round-trip time (jiffies) */
 
+        pid_t                   tk_owner;       /* Process id for batching tasks */
+        unsigned char           tk_priority : 2;/* Task priority */
+
 #ifdef RPC_DEBUG
         unsigned short          tk_pid;         /* debugging aid */
 #endif
@@ -117,6 +117,15 @@ struct rpc_call_ops {
         void (*rpc_release)(void *);
 };
 
+struct rpc_task_setup {
+        struct rpc_task *task;
+        struct rpc_clnt *rpc_client;
+        const struct rpc_message *rpc_message;
+        const struct rpc_call_ops *callback_ops;
+        void *callback_data;
+        unsigned short flags;
+        signed char priority;
+};
 
 /*
  * RPC task flags
@@ -180,10 +189,10 @@ struct rpc_call_ops {
  * Note: if you change these, you must also change
  * the task initialization definitions below.
  */
-#define RPC_PRIORITY_LOW        0
-#define RPC_PRIORITY_NORMAL     1
-#define RPC_PRIORITY_HIGH       2
-#define RPC_NR_PRIORITY         (RPC_PRIORITY_HIGH+1)
+#define RPC_PRIORITY_LOW        (-1)
+#define RPC_PRIORITY_NORMAL     (0)
+#define RPC_PRIORITY_HIGH       (1)
+#define RPC_NR_PRIORITY         (1 + RPC_PRIORITY_HIGH - RPC_PRIORITY_LOW)
 
 /*
  * RPC synchronization objects
@@ -191,7 +200,7 @@ struct rpc_call_ops {
 struct rpc_wait_queue {
         spinlock_t              lock;
         struct list_head        tasks[RPC_NR_PRIORITY]; /* task queue for each priority level */
-        unsigned long           cookie;                 /* cookie of last task serviced */
+        pid_t                   owner;                  /* process id of last task serviced */
         unsigned char           maxpriority;            /* maximum priority (0 if queue is not a priority queue) */
         unsigned char           priority;               /* current priority */
         unsigned char           count;                  /* # task groups remaining serviced so far */
@@ -208,41 +217,13 @@ struct rpc_wait_queue {
  * performance of NFS operations such as read/write.
  */
 #define RPC_BATCH_COUNT                 16
-
-#ifndef RPC_DEBUG
-# define RPC_WAITQ_INIT(var,qname) { \
-                .lock = __SPIN_LOCK_UNLOCKED(var.lock), \
-                .tasks = { \
-                        [0] = LIST_HEAD_INIT(var.tasks[0]), \
-                        [1] = LIST_HEAD_INIT(var.tasks[1]), \
-                        [2] = LIST_HEAD_INIT(var.tasks[2]), \
-                }, \
-        }
-#else
-# define RPC_WAITQ_INIT(var,qname) { \
-                .lock = __SPIN_LOCK_UNLOCKED(var.lock), \
-                .tasks = { \
-                        [0] = LIST_HEAD_INIT(var.tasks[0]), \
-                        [1] = LIST_HEAD_INIT(var.tasks[1]), \
-                        [2] = LIST_HEAD_INIT(var.tasks[2]), \
-                }, \
-                .name = qname, \
-        }
-#endif
-# define RPC_WAITQ(var,qname)      struct rpc_wait_queue var = RPC_WAITQ_INIT(var,qname)
-
 #define RPC_IS_PRIORITY(q)              ((q)->maxpriority > 0)
 
 /*
  * Function prototypes
  */
-struct rpc_task *rpc_new_task(struct rpc_clnt *, int flags,
-                                const struct rpc_call_ops *ops, void *data);
-struct rpc_task *rpc_run_task(struct rpc_clnt *clnt, int flags,
-                                const struct rpc_call_ops *ops, void *data);
-void            rpc_init_task(struct rpc_task *task, struct rpc_clnt *clnt,
-                                int flags, const struct rpc_call_ops *ops,
-                                void *data);
+struct rpc_task *rpc_new_task(const struct rpc_task_setup *);
+struct rpc_task *rpc_run_task(const struct rpc_task_setup *);
 void            rpc_put_task(struct rpc_task *);
 void            rpc_exit_task(struct rpc_task *);
 void            rpc_release_calldata(const struct rpc_call_ops *, void *);
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 30b17b3bc1a9..b3ff9a815e6f 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -120,7 +120,7 @@ struct rpc_xprt {
         struct kref             kref;           /* Reference count */
         struct rpc_xprt_ops *   ops;            /* transport methods */
 
-        struct rpc_timeout      timeout;        /* timeout parms */
+        const struct rpc_timeout *timeout;      /* timeout parms */
         struct sockaddr_storage addr;           /* server address */
         size_t                  addrlen;        /* size of server address */
         int                     prot;           /* IP protocol */
@@ -183,7 +183,7 @@ struct rpc_xprt {
                                         bklog_u;        /* backlog queue utilization */
         } stat;
 
-        char *                  address_strings[RPC_DISPLAY_MAX];
+        const char              *address_strings[RPC_DISPLAY_MAX];
 };
 
 struct xprt_create {
@@ -191,7 +191,6 @@ struct xprt_create {
         struct sockaddr *       srcaddr;        /* optional local address */
         struct sockaddr *       dstaddr;        /* remote peer address */
         size_t                  addrlen;
-        struct rpc_timeout *    timeout;        /* optional timeout parameters */
 };
 
 struct xprt_class {
@@ -203,11 +202,6 @@ struct xprt_class {
 };
 
 /*
- * Transport operations used by ULPs
- */
-void                    xprt_set_timeout(struct rpc_timeout *to, unsigned int retr, unsigned long incr);
-
-/*
  * Generic internal transport functions
  */
 struct rpc_xprt         *xprt_create_transport(struct xprt_create *args);
@@ -245,7 +239,8 @@ void			xprt_adjust_cwnd(struct rpc_task *task, int result);
 struct rpc_rqst *       xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid);
 void                    xprt_complete_rqst(struct rpc_task *task, int copied);
 void                    xprt_release_rqst_cong(struct rpc_task *task);
-void                    xprt_disconnect(struct rpc_xprt *xprt);
+void                    xprt_disconnect_done(struct rpc_xprt *xprt);
+void                    xprt_force_disconnect(struct rpc_xprt *xprt);
 
 /*
  * Reserved bit positions in xprt->state
@@ -256,6 +251,7 @@ void			xprt_disconnect(struct rpc_xprt *xprt);
 #define XPRT_CLOSE_WAIT         (3)
 #define XPRT_BOUND              (4)
 #define XPRT_BINDING            (5)
+#define XPRT_CLOSING            (6)
 
 static inline void xprt_set_connected(struct rpc_xprt *xprt)
 {