14 files changed, 165 insertions, 97 deletions

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 115e72be25d0..2c9c48d65630 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -760,7 +760,7 @@ extern struct file_lock *posix_test_lock(struct file *, 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 void posix_unblock_lock(struct file *, 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);
 extern int __break_lease(struct inode *inode, unsigned int flags);
diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h
index 16d4e5a08e1d..95c8fea293ba 100644
--- a/include/linux/lockd/lockd.h
+++ b/include/linux/lockd/lockd.h
@@ -172,7 +172,7 @@ extern struct nlm_host *nlm_find_client(void);
 /*
  * Server-side lock handling
  */
-int               nlmsvc_async_call(struct nlm_rqst *, u32, rpc_action);
+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 *);
diff --git a/include/linux/moduleparam.h b/include/linux/moduleparam.h
index 368ec8e45bd0..b5c98c43779e 100644
--- a/include/linux/moduleparam.h
+++ b/include/linux/moduleparam.h
@@ -10,7 +10,7 @@
 #ifdef MODULE
 #define MODULE_PARAM_PREFIX /* empty */
 #else
-#define MODULE_PARAM_PREFIX __stringify(KBUILD_MODNAME) "."
+#define MODULE_PARAM_PREFIX KBUILD_MODNAME "."
 #endif
 
 #ifdef MODULE
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 2516adeccecf..547d649b274e 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -38,9 +38,6 @@
 # define NFS_DEBUG
 #endif
 
-#define NFS_MAX_FILE_IO_BUFFER_SIZE     32768
-#define NFS_DEF_FILE_IO_BUFFER_SIZE     4096
-
 /* Default timeout values */
 #define NFS_MAX_UDP_TIMEOUT     (60*HZ)
 #define NFS_MAX_TCP_TIMEOUT     (600*HZ)
@@ -65,6 +62,7 @@
 #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 */
+#define FLUSH_NOCOMMIT          32      /* Don't send the NFSv3/v4 COMMIT */
 
 #ifdef __KERNEL__
 
@@ -394,6 +392,17 @@ extern int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fh, struct nfs_
 extern struct inode_operations nfs_symlink_inode_operations;
 
 /*
+ * linux/fs/nfs/sysctl.c
+ */
+#ifdef CONFIG_SYSCTL
+extern int nfs_register_sysctl(void);
+extern void nfs_unregister_sysctl(void);
+#else
+#define nfs_register_sysctl() do { } while(0)
+#define nfs_unregister_sysctl() do { } while(0)
+#endif
+
+/*
  * linux/fs/nfs/unlink.c
  */
 extern int  nfs_async_unlink(struct dentry *);
@@ -406,10 +415,12 @@ 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);
+extern void nfs_writeback_done(struct rpc_task *task, void *data);
+extern void nfs_writedata_release(void *data);
 
 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
-extern void nfs_commit_done(struct rpc_task *);
+extern void nfs_commit_done(struct rpc_task *, void *data);
+extern void nfs_commit_release(void *data);
 #endif
 
 /*
@@ -460,18 +471,33 @@ static inline int nfs_wb_page(struct inode *inode, struct page* page)
  */
 extern mempool_t *nfs_wdata_mempool;
 
-static inline struct nfs_write_data *nfs_writedata_alloc(void)
+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);
 }
 
@@ -481,28 +507,45 @@ 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 *);
+extern void nfs_readpage_result(struct rpc_task *, void *);
+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(void)
+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)
+
+        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 void  nfs_readdata_release(struct rpc_task *task);
-
 /*
  * linux/fs/nfs3proc.c
  */
diff --git a/include/linux/nfs_idmap.h b/include/linux/nfs_idmap.h
index a0f1f25e0ead..102e56094296 100644
--- a/include/linux/nfs_idmap.h
+++ b/include/linux/nfs_idmap.h
@@ -71,6 +71,8 @@ int nfs_map_name_to_uid(struct nfs4_client *, const char *, size_t, __u32 *);
 int nfs_map_group_to_gid(struct nfs4_client *, const char *, size_t, __u32 *);
 int nfs_map_uid_to_name(struct nfs4_client *, __u32, char *);
 int nfs_map_gid_to_group(struct nfs4_client *, __u32, char *);
+
+extern unsigned int nfs_idmap_cache_timeout;
 #endif /* __KERNEL__ */
 
 #endif /* NFS_IDMAP_H */
diff --git a/include/linux/nfs_page.h b/include/linux/nfs_page.h
index da2e077b65e2..66e2ed658527 100644
--- a/include/linux/nfs_page.h
+++ b/include/linux/nfs_page.h
@@ -79,9 +79,7 @@ extern  void nfs_clear_page_writeback(struct nfs_page *req);
 static inline int
 nfs_lock_request_dontget(struct nfs_page *req)
 {
-        if (test_and_set_bit(PG_BUSY, &req->wb_flags))
-                return 0;
-        return 1;
+        return !test_and_set_bit(PG_BUSY, &req->wb_flags);
 }
 
 /*
@@ -125,9 +123,7 @@ nfs_list_remove_request(struct nfs_page *req)
 static inline int
 nfs_defer_commit(struct nfs_page *req)
 {
-        if (test_and_set_bit(PG_NEED_COMMIT, &req->wb_flags))
-                return 0;
-        return 1;
+        return !test_and_set_bit(PG_NEED_COMMIT, &req->wb_flags);
 }
 
 static inline void
@@ -141,9 +137,7 @@ nfs_clear_commit(struct nfs_page *req)
 static inline int
 nfs_defer_reschedule(struct nfs_page *req)
 {
-        if (test_and_set_bit(PG_NEED_RESCHED, &req->wb_flags))
-                return 0;
-        return 1;
+        return !test_and_set_bit(PG_NEED_RESCHED, &req->wb_flags);
 }
 
 static inline void
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 40718669b9c8..6d6f69ec5675 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -4,6 +4,16 @@
 #include <linux/sunrpc/xprt.h>
 #include <linux/nfsacl.h>
 
+/*
+ * To change the maximum rsize and wsize supported by the NFS client, adjust
+ * NFS_MAX_FILE_IO_SIZE.  64KB is a typical maximum, but some servers can
+ * support a megabyte or more.  The default is left at 4096 bytes, which is
+ * reasonable for NFS over UDP.
+ */
+#define NFS_MAX_FILE_IO_SIZE    (1048576U)
+#define NFS_DEF_FILE_IO_SIZE    (4096U)
+#define NFS_MIN_FILE_IO_SIZE    (1024U)
+
 struct nfs4_fsid {
         __u64 major;
         __u64 minor;
@@ -137,7 +147,7 @@ struct nfs_openres {
  */
 struct nfs_open_confirmargs {
         const struct nfs_fh *   fh;
-        nfs4_stateid            stateid;
+        nfs4_stateid *          stateid;
         struct nfs_seqid *      seqid;
 };
 
@@ -165,66 +175,62 @@ struct nfs_closeres {
  *  * Arguments to the lock,lockt, and locku call.
  *   */
 struct nfs_lowner {
-        __u64           clientid;
-        u32                     id;
+        __u64                   clientid;
+        u32                     id;
 };
 
-struct nfs_lock_opargs {
+struct nfs_lock_args {
+        struct nfs_fh *         fh;
+        struct file_lock *      fl;
         struct nfs_seqid *      lock_seqid;
         nfs4_stateid *          lock_stateid;
         struct nfs_seqid *      open_seqid;
         nfs4_stateid *          open_stateid;
-        struct nfs_lowner       lock_owner;
-        __u32                   reclaim;
-        __u32                   new_lock_owner;
+        struct nfs_lowner       lock_owner;
+        unsigned char           block : 1;
+        unsigned char           reclaim : 1;
+        unsigned char           new_lock_owner : 1;
 };
 
-struct nfs_locku_opargs {
+struct nfs_lock_res {
+        nfs4_stateid                    stateid;
+};
+
+struct nfs_locku_args {
+        struct nfs_fh *         fh;
+        struct file_lock *      fl;
         struct nfs_seqid *      seqid;
         nfs4_stateid *          stateid;
 };
 
-struct nfs_lockargs {
-        struct nfs_fh *         fh;
-        __u32                   type;
-        __u64                   offset; 
-        __u64                   length; 
-        union {
-                struct nfs_lock_opargs  *lock;    /* LOCK  */
-                struct nfs_lowner       *lockt;  /* LOCKT */
-                struct nfs_locku_opargs *locku;  /* LOCKU */
-        } u;
+struct nfs_locku_res {
+        nfs4_stateid                    stateid;
 };
 
-struct nfs_lock_denied {
-        __u64                   offset;
-        __u64                   length;
-        __u32                   type;
-        struct nfs_lowner       owner;
+struct nfs_lockt_args {
+        struct nfs_fh *         fh;
+        struct file_lock *      fl;
+        struct nfs_lowner       lock_owner;
 };
 
-struct nfs_lockres {
-        union {
-                nfs4_stateid            stateid;/* LOCK success, LOCKU */
-                struct nfs_lock_denied  denied; /* LOCK failed, LOCKT success */
-        } u;
-        const struct nfs_server *       server;
+struct nfs_lockt_res {
+        struct file_lock *      denied; /* LOCK, LOCKT failed */
 };
 
 struct nfs4_delegreturnargs {
         const struct nfs_fh *fhandle;
         const nfs4_stateid *stateid;
+        const u32 * bitmask;
+};
+
+struct nfs4_delegreturnres {
+        struct nfs_fattr * fattr;
+        const struct nfs_server *server;
 };
 
 /*
  * Arguments to the read call.
  */
-
-#define NFS_READ_MAXIOV         (9U)
-#if (NFS_READ_MAXIOV > (MAX_IOVEC -2))
-#error "NFS_READ_MAXIOV is too large"
-#endif
-
 struct nfs_readargs {
         struct nfs_fh *         fh;
         struct nfs_open_context *context;
@@ -243,11 +249,6 @@ struct nfs_readres {
 /*
  * Arguments to the write call.
  */
-#define NFS_WRITE_MAXIOV        (9U)
-#if (NFS_WRITE_MAXIOV > (MAX_IOVEC -2))
-#error "NFS_WRITE_MAXIOV is too large"
-#endif
-
 struct nfs_writeargs {
         struct nfs_fh *         fh;
         struct nfs_open_context *context;
@@ -678,6 +679,8 @@ struct nfs4_server_caps_res {
 
 struct nfs_page;
 
+#define NFS_PAGEVEC_SIZE        (8U)
+
 struct nfs_read_data {
         int                     flags;
         struct rpc_task         task;
@@ -686,13 +689,14 @@ struct nfs_read_data {
         struct nfs_fattr        fattr;  /* fattr storage */
         struct list_head        pages;  /* Coalesced read requests */
         struct nfs_page         *req;   /* multi ops per nfs_page */
-        struct page             *pagevec[NFS_READ_MAXIOV];
+        struct page             **pagevec;
         struct nfs_readargs args;
         struct nfs_readres  res;
 #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];
 };
 
 struct nfs_write_data {
@@ -704,13 +708,14 @@ struct nfs_write_data {
         struct nfs_writeverf    verf;
         struct list_head        pages;          /* Coalesced requests we wish to flush */
         struct nfs_page         *req;           /* multi ops per nfs_page */
-        struct page             *pagevec[NFS_WRITE_MAXIOV];
+        struct page             **pagevec;
         struct nfs_writeargs    args;           /* argument struct */
         struct nfs_writeres     res;            /* result struct */
 #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];
 };
 
 struct nfs_access_entry;
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
index ab151bbb66df..f147e6b84332 100644
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -49,7 +49,6 @@ struct rpc_clnt {
 
         unsigned int            cl_softrtry : 1,/* soft timeouts */
                                 cl_intr     : 1,/* interruptible */
-                                cl_chatty   : 1,/* be verbose */
                                 cl_autobind : 1,/* use getport() */
                                 cl_oneshot  : 1,/* dispose after use */
                                 cl_dead     : 1;/* abandoned */
@@ -126,7 +125,8 @@ int		rpc_register(u32, u32, int, unsigned short, int *);
 void            rpc_call_setup(struct rpc_task *, struct rpc_message *, int);
 
 int             rpc_call_async(struct rpc_clnt *clnt, struct rpc_message *msg,
-                               int flags, rpc_action callback, void *clntdata);
+                               int flags, const struct rpc_call_ops *tk_ops,
+                               void *calldata);
 int             rpc_call_sync(struct rpc_clnt *clnt, struct rpc_message *msg,
                               int flags);
 void            rpc_restart_call(struct rpc_task *);
@@ -134,6 +134,7 @@ void		rpc_clnt_sigmask(struct rpc_clnt *clnt, sigset_t *oldset);
 void            rpc_clnt_sigunmask(struct rpc_clnt *clnt, sigset_t *oldset);
 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 *);
 int             rpc_ping(struct rpc_clnt *clnt, int flags);
 
 static __inline__
diff --git a/include/linux/sunrpc/gss_spkm3.h b/include/linux/sunrpc/gss_spkm3.h
index 0beb2cf00a84..336e218c2782 100644
--- a/include/linux/sunrpc/gss_spkm3.h
+++ b/include/linux/sunrpc/gss_spkm3.h
@@ -48,7 +48,7 @@ u32 spkm3_read_token(struct spkm3_ctx *ctx, struct xdr_netobj *read_token, struc
 #define CKSUMTYPE_RSA_MD5            0x0007
 
 s32 make_checksum(s32 cksumtype, char *header, int hdrlen, struct xdr_buf *body,
-                   struct xdr_netobj *cksum);
+                   int body_offset, struct xdr_netobj *cksum);
 void asn1_bitstring_len(struct xdr_netobj *in, int *enclen, int *zerobits);
 int decode_asn1_bitstring(struct xdr_netobj *out, char *in, int enclen, 
                    int explen);
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index 4d77e90d0b30..8b25629accd8 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -27,6 +27,7 @@ struct rpc_message {
         struct rpc_cred *       rpc_cred;       /* Credentials */
 };
 
+struct rpc_call_ops;
 struct rpc_wait_queue;
 struct rpc_wait {
         struct list_head        list;           /* wait queue links */
@@ -41,6 +42,7 @@ struct rpc_task {
 #ifdef RPC_DEBUG
         unsigned long           tk_magic;       /* 0xf00baa */
 #endif
+        atomic_t                tk_count;       /* Reference count */
         struct list_head        tk_task;        /* global list of tasks */
         struct rpc_clnt *       tk_client;      /* RPC client */
         struct rpc_rqst *       tk_rqstp;       /* RPC request */
@@ -50,8 +52,6 @@ struct rpc_task {
          * RPC call state
          */
         struct rpc_message      tk_msg;         /* RPC call info */
-        __u32 *                 tk_buffer;      /* XDR buffer */
-        size_t                  tk_bufsize;
         __u8                    tk_garb_retry;
         __u8                    tk_cred_retry;
 
@@ -61,13 +61,12 @@ struct rpc_task {
          * timeout_fn   to be executed by timer bottom half
          * callback     to be executed after waking up
          * action       next procedure for async tasks
-         * exit         exit async task and report to caller
+         * tk_ops       caller callbacks
          */
         void                    (*tk_timeout_fn)(struct rpc_task *);
         void                    (*tk_callback)(struct rpc_task *);
         void                    (*tk_action)(struct rpc_task *);
-        void                    (*tk_exit)(struct rpc_task *);
-        void                    (*tk_release)(struct rpc_task *);
+        const struct rpc_call_ops *tk_ops;
         void *                  tk_calldata;
 
         /*
@@ -78,7 +77,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_active   : 1;/* Task has been activated */
         unsigned char           tk_priority : 2;/* Task priority */
         unsigned long           tk_runstate;    /* Task run status */
         struct workqueue_struct *tk_workqueue;  /* Normally rpciod, but could
@@ -111,6 +109,13 @@ struct rpc_task {
 
 typedef void                    (*rpc_action)(struct rpc_task *);
 
+struct rpc_call_ops {
+        void (*rpc_call_prepare)(struct rpc_task *, void *);
+        void (*rpc_call_done)(struct rpc_task *, void *);
+        void (*rpc_release)(void *);
+};
+
+
 /*
  * RPC task flags
  */
@@ -129,7 +134,6 @@ typedef void			(*rpc_action)(struct rpc_task *);
 #define RPC_IS_SWAPPER(t)       ((t)->tk_flags & RPC_TASK_SWAPPER)
 #define RPC_DO_ROOTOVERRIDE(t)  ((t)->tk_flags & RPC_TASK_ROOTCREDS)
 #define RPC_ASSASSINATED(t)     ((t)->tk_flags & RPC_TASK_KILLED)
-#define RPC_IS_ACTIVATED(t)     ((t)->tk_active)
 #define RPC_DO_CALLBACK(t)      ((t)->tk_callback != NULL)
 #define RPC_IS_SOFT(t)          ((t)->tk_flags & RPC_TASK_SOFT)
 #define RPC_TASK_UNINTERRUPTIBLE(t) ((t)->tk_flags & RPC_TASK_NOINTR)
@@ -138,6 +142,7 @@ typedef void			(*rpc_action)(struct rpc_task *);
 #define RPC_TASK_QUEUED         1
 #define RPC_TASK_WAKEUP         2
 #define RPC_TASK_HAS_TIMER      3
+#define RPC_TASK_ACTIVE         4
 
 #define RPC_IS_RUNNING(t)       (test_bit(RPC_TASK_RUNNING, &(t)->tk_runstate))
 #define rpc_set_running(t)      (set_bit(RPC_TASK_RUNNING, &(t)->tk_runstate))
@@ -168,6 +173,15 @@ typedef void			(*rpc_action)(struct rpc_task *);
                 smp_mb__after_clear_bit(); \
         } while (0)
 
+#define RPC_IS_ACTIVATED(t)     (test_bit(RPC_TASK_ACTIVE, &(t)->tk_runstate))
+#define rpc_set_active(t)       (set_bit(RPC_TASK_ACTIVE, &(t)->tk_runstate))
+#define rpc_clear_active(t)     \
+        do { \
+                smp_mb__before_clear_bit(); \
+                clear_bit(RPC_TASK_ACTIVE, &(t)->tk_runstate); \
+                smp_mb__after_clear_bit(); \
+        } while(0)
+
 /*
  * Task priorities.
  * Note: if you change these, you must also change
@@ -228,11 +242,16 @@ struct rpc_wait_queue {
 /*
  * Function prototypes
  */
-struct rpc_task *rpc_new_task(struct rpc_clnt *, rpc_action, int flags);
+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);
 struct rpc_task *rpc_new_child(struct rpc_clnt *, struct rpc_task *parent);
-void            rpc_init_task(struct rpc_task *, struct rpc_clnt *,
-                                        rpc_action exitfunc, int flags);
+void            rpc_init_task(struct rpc_task *task, struct rpc_clnt *clnt,
+                                int flags, const struct rpc_call_ops *ops,
+                                void *data);
 void            rpc_release_task(struct rpc_task *);
+void            rpc_exit_task(struct rpc_task *);
 void            rpc_killall_tasks(struct rpc_clnt *);
 int             rpc_execute(struct rpc_task *);
 void            rpc_run_child(struct rpc_task *parent, struct rpc_task *child,
@@ -247,9 +266,11 @@ struct rpc_task *rpc_wake_up_next(struct rpc_wait_queue *);
 void            rpc_wake_up_status(struct rpc_wait_queue *, int);
 void            rpc_delay(struct rpc_task *, unsigned long);
 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
@@ -259,7 +280,12 @@ void		rpc_destroy_mempool(void);
 static inline void rpc_exit(struct rpc_task *task, int status)
 {
         task->tk_status = status;
-        task->tk_action = NULL;
+        task->tk_action = rpc_exit_task;
+}
+
+static inline int rpc_wait_for_completion_task(struct rpc_task *task)
+{
+        return __rpc_wait_for_completion_task(task, NULL);
 }
 
 #ifdef RPC_DEBUG
diff --git a/include/linux/sunrpc/xdr.h b/include/linux/sunrpc/xdr.h
index 5da968729cf8..84c35d42d250 100644
--- a/include/linux/sunrpc/xdr.h
+++ b/include/linux/sunrpc/xdr.h
@@ -91,7 +91,6 @@ struct xdr_buf {
 u32 *   xdr_encode_opaque_fixed(u32 *p, const void *ptr, unsigned int len);
 u32 *   xdr_encode_opaque(u32 *p, const void *ptr, unsigned int len);
 u32 *   xdr_encode_string(u32 *p, const char *s);
-u32 *   xdr_decode_string(u32 *p, char **sp, int *lenp, int maxlen);
 u32 *   xdr_decode_string_inplace(u32 *p, char **sp, int *lenp, int maxlen);
 u32 *   xdr_encode_netobj(u32 *p, const struct xdr_netobj *);
 u32 *   xdr_decode_netobj(u32 *p, struct xdr_netobj *);
@@ -135,11 +134,6 @@ xdr_adjust_iovec(struct kvec *iov, u32 *p)
 }
 
 /*
- * Maximum number of iov's we use.
- */
-#define MAX_IOVEC       (12)
-
-/*
  * XDR buffer helper functions
  */
 extern void xdr_shift_buf(struct xdr_buf *, size_t);
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 3b8b6e823c70..6ef99b14ff09 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -79,21 +79,19 @@ struct rpc_rqst {
         void (*rq_release_snd_buf)(struct rpc_rqst *); /* release rq_enc_pages */
         struct list_head        rq_list;
 
+        __u32 *                 rq_buffer;      /* XDR encode buffer */
+        size_t                  rq_bufsize;
+
         struct xdr_buf          rq_private_buf;         /* The receive buffer
                                                          * used in the softirq.
                                                          */
         unsigned long           rq_majortimeo;  /* major timeout alarm */
         unsigned long           rq_timeout;     /* Current timeout value */
         unsigned int            rq_retries;     /* # of retries */
-        /*
-         * For authentication (e.g. auth_des)
-         */
-        u32                     rq_creddata[2];
         
         /*
          * Partial send handling
          */
-        
         u32                     rq_bytes_sent;  /* Bytes we have sent */
 
         unsigned long           rq_xtime;       /* when transmitted */
@@ -106,7 +104,10 @@ struct rpc_xprt_ops {
         void            (*set_buffer_size)(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize);
         int             (*reserve_xprt)(struct rpc_task *task);
         void            (*release_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
+        void            (*set_port)(struct rpc_xprt *xprt, unsigned short port);
         void            (*connect)(struct rpc_task *task);
+        void *          (*buf_alloc)(struct rpc_task *task, size_t size);
+        void            (*buf_free)(struct rpc_task *task);
         int             (*send_request)(struct rpc_task *task);
         void            (*set_retrans_timeout)(struct rpc_task *task);
         void            (*timer)(struct rpc_task *task);
@@ -253,6 +254,7 @@ int			xs_setup_tcp(struct rpc_xprt *xprt, struct rpc_timeout *to);
 #define XPRT_LOCKED             (0)
 #define XPRT_CONNECTED          (1)
 #define XPRT_CONNECTING         (2)
+#define XPRT_CLOSE_WAIT         (3)
 
 static inline void xprt_set_connected(struct rpc_xprt *xprt)
 {
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index 64a36ba43b2f..b096159086e8 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -53,10 +53,11 @@ struct writeback_control {
         loff_t start;
         loff_t end;
 
-        unsigned nonblocking:1;                 /* Don't get stuck on request queues */
-        unsigned encountered_congestion:1;      /* An output: a queue is full */
-        unsigned for_kupdate:1;                 /* A kupdate writeback */
-        unsigned for_reclaim:1;                 /* Invoked from the page allocator */
+        unsigned nonblocking:1;         /* Don't get stuck on request queues */
+        unsigned encountered_congestion:1; /* An output: a queue is full */
+        unsigned for_kupdate:1;         /* A kupdate writeback */
+        unsigned for_reclaim:1;         /* Invoked from the page allocator */
+        unsigned for_writepages:1;      /* This is a writepages() call */
 };
 
 /*
diff --git a/include/media/saa7146.h b/include/media/saa7146.h
index e5be2b9b846b..2bc634fcb7bb 100644
--- a/include/media/saa7146.h
+++ b/include/media/saa7146.h
@@ -21,14 +21,14 @@
 
 extern unsigned int saa7146_debug;
 
-//#define DEBUG_PROLOG printk("(0x%08x)(0x%08x) %s: %s(): ",(dev==0?-1:(dev->mem==0?-1:saa7146_read(dev,RPS_ADDR0))),(dev==0?-1:(dev->mem==0?-1:saa7146_read(dev,IER))),__stringify(KBUILD_MODNAME),__FUNCTION__)
+//#define DEBUG_PROLOG printk("(0x%08x)(0x%08x) %s: %s(): ",(dev==0?-1:(dev->mem==0?-1:saa7146_read(dev,RPS_ADDR0))),(dev==0?-1:(dev->mem==0?-1:saa7146_read(dev,IER))),KBUILD_MODNAME,__FUNCTION__)
 
 #ifndef DEBUG_VARIABLE
         #define DEBUG_VARIABLE saa7146_debug
 #endif
 
-#define DEBUG_PROLOG printk("%s: %s(): ",__stringify(KBUILD_MODNAME),__FUNCTION__)
-#define INFO(x) { printk("%s: ",__stringify(KBUILD_MODNAME)); printk x; }
+#define DEBUG_PROLOG printk("%s: %s(): ",KBUILD_MODNAME,__FUNCTION__)
+#define INFO(x) { printk("%s: ",KBUILD_MODNAME); printk x; }
 
 #define ERR(x) { DEBUG_PROLOG; printk x; }