Merge branch 'splice-2.6.23' of git://git.kernel.dk/data/git/linux-2.6-block

* 'splice-2.6.23' of git://git.kernel.dk/data/git/linux-2.6-block:
  pipe: add documentation and comments
  pipe: change the ->pin() operation to ->confirm()
  Remove remnants of sendfile()
  xip sendfile removal
  splice: completely document external interface with kerneldoc
  sendfile: remove bad_sendfile() from bad_file_ops
  shmem: convert to using splice instead of sendfile()
  relay: use splice_to_pipe() instead of open-coding the pipe loop
  pipe: allow passing around of ops private pointer
  splice: divorce the splice structure/function definitions from the pipe header
  splice: relay support
  sendfile: convert nfsd to splice_direct_to_actor()
  sendfile: convert nfs to using splice_read()
  loop: convert to using splice_direct_to_actor() instead of sendfile()
  splice: add void cookie to the actor data
  sendfile: kill generic_file_sendfile()
  sendfile: remove .sendfile from filesystems that use generic_file_sendfile()
  sys_sendfile: switch to using ->splice_read, if available
  vmsplice: add vmsplice-to-user support
  splice: abstract out actor data

4 files changed, 156 insertions, 43 deletions

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 6a41f4cab14c..4f0b3bf5983c 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1054,7 +1054,7 @@ struct block_device_operations {
 };
 
 /*
- * "descriptor" for what we're up to with a read for sendfile().
+ * "descriptor" for what we're up to with a read.
  * This allows us to use the same read code yet
  * have multiple different users of the data that
  * we read from a file.
@@ -1105,7 +1105,6 @@ struct file_operations {
         int (*aio_fsync) (struct kiocb *, int datasync);
         int (*fasync) (int, struct file *, int);
         int (*lock) (struct file *, int, struct file_lock *);
-        ssize_t (*sendfile) (struct file *, loff_t *, size_t, read_actor_t, void *);
         ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
         unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
         int (*check_flags)(int);
@@ -1762,7 +1761,6 @@ extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,
                 unsigned long, loff_t, loff_t *, size_t, ssize_t);
 extern ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos);
 extern ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos);
-extern ssize_t generic_file_sendfile(struct file *, loff_t *, size_t, read_actor_t, void *);
 extern void do_generic_mapping_read(struct address_space *mapping,
                                     struct file_ra_state *, struct file *,
                                     loff_t *, read_descriptor_t *, read_actor_t);
@@ -1792,9 +1790,6 @@ extern int nonseekable_open(struct inode * inode, struct file * filp);
 #ifdef CONFIG_FS_XIP
 extern ssize_t xip_file_read(struct file *filp, char __user *buf, size_t len,
                              loff_t *ppos);
-extern ssize_t xip_file_sendfile(struct file *in_file, loff_t *ppos,
-                                 size_t count, read_actor_t actor,
-                                 void *target);
 extern int xip_file_mmap(struct file * file, struct vm_area_struct * vma);
 extern ssize_t xip_file_write(struct file *filp, const char __user *buf,
                               size_t len, loff_t *ppos);
diff --git a/include/linux/pipe_fs_i.h b/include/linux/pipe_fs_i.h
index c8884f971228..8e4120285f72 100644
--- a/include/linux/pipe_fs_i.h
+++ b/include/linux/pipe_fs_i.h
@@ -9,13 +9,39 @@
 #define PIPE_BUF_FLAG_ATOMIC    0x02    /* was atomically mapped */
 #define PIPE_BUF_FLAG_GIFT      0x04    /* page is a gift */
 
+/**
+ *      struct pipe_buffer - a linux kernel pipe buffer
+ *      @page: the page containing the data for the pipe buffer
+ *      @offset: offset of data inside the @page
+ *      @len: length of data inside the @page
+ *      @ops: operations associated with this buffer. See @pipe_buf_operations.
+ *      @flags: pipe buffer flags. See above.
+ *      @private: private data owned by the ops.
+ **/
 struct pipe_buffer {
         struct page *page;
         unsigned int offset, len;
         const struct pipe_buf_operations *ops;
         unsigned int flags;
+        unsigned long private;
 };
 
+/**
+ *      struct pipe_inode_info - a linux kernel pipe
+ *      @wait: reader/writer wait point in case of empty/full pipe
+ *      @nrbufs: the number of non-empty pipe buffers in this pipe
+ *      @curbuf: the current pipe buffer entry
+ *      @tmp_page: cached released page
+ *      @readers: number of current readers of this pipe
+ *      @writers: number of current writers of this pipe
+ *      @waiting_writers: number of writers blocked waiting for room
+ *      @r_counter: reader counter
+ *      @w_counter: writer counter
+ *      @fasync_readers: reader side fasync
+ *      @fasync_writers: writer side fasync
+ *      @inode: inode this pipe is attached to
+ *      @bufs: the circular array of pipe buffers
+ **/
 struct pipe_inode_info {
         wait_queue_head_t wait;
         unsigned int nrbufs, curbuf;
@@ -34,22 +60,73 @@ struct pipe_inode_info {
 /*
  * Note on the nesting of these functions:
  *
- * ->pin()
+ * ->confirm()
  *      ->steal()
  *      ...
  *      ->map()
  *      ...
  *      ->unmap()
  *
- * That is, ->map() must be called on a pinned buffer, same goes for ->steal().
+ * That is, ->map() must be called on a confirmed buffer,
+ * same goes for ->steal(). See below for the meaning of each
+ * operation. Also see kerneldoc in fs/pipe.c for the pipe
+ * and generic variants of these hooks.
  */
 struct pipe_buf_operations {
+        /*
+         * This is set to 1, if the generic pipe read/write may coalesce
+         * data into an existing buffer. If this is set to 0, a new pipe
+         * page segment is always used for new data.
+         */
         int can_merge;
+
+        /*
+         * ->map() returns a virtual address mapping of the pipe buffer.
+         * The last integer flag reflects whether this should be an atomic
+         * mapping or not. The atomic map is faster, however you can't take
+         * page faults before calling ->unmap() again. So if you need to eg
+         * access user data through copy_to/from_user(), then you must get
+         * a non-atomic map. ->map() uses the KM_USER0 atomic slot for
+         * atomic maps, so you can't map more than one pipe_buffer at once
+         * and you have to be careful if mapping another page as source
+         * or destination for a copy (IOW, it has to use something else
+         * than KM_USER0).
+         */
         void * (*map)(struct pipe_inode_info *, struct pipe_buffer *, int);
+
+        /*
+         * Undoes ->map(), finishes the virtual mapping of the pipe buffer.
+         */
         void (*unmap)(struct pipe_inode_info *, struct pipe_buffer *, void *);
-        int (*pin)(struct pipe_inode_info *, struct pipe_buffer *);
+
+        /*
+         * ->confirm() verifies that the data in the pipe buffer is there
+         * and that the contents are good. If the pages in the pipe belong
+         * to a file system, we may need to wait for IO completion in this
+         * hook. Returns 0 for good, or a negative error value in case of
+         * error.
+         */
+        int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *);
+
+        /*
+         * When the contents of this pipe buffer has been completely
+         * consumed by a reader, ->release() is called.
+         */
         void (*release)(struct pipe_inode_info *, struct pipe_buffer *);
+
+        /*
+         * Attempt to take ownership of the pipe buffer and its contents.
+         * ->steal() returns 0 for success, in which case the contents
+         * of the pipe (the buf->page) is locked and now completely owned
+         * by the caller. The page may then be transferred to a different
+         * mapping, the most often used case is insertion into different
+         * file address space cache.
+         */
         int (*steal)(struct pipe_inode_info *, struct pipe_buffer *);
+
+        /*
+         * Get a reference to the pipe buffer.
+         */
         void (*get)(struct pipe_inode_info *, struct pipe_buffer *);
 };
 
@@ -68,39 +145,7 @@ void __free_pipe_info(struct pipe_inode_info *);
 void *generic_pipe_buf_map(struct pipe_inode_info *, struct pipe_buffer *, int);
 void generic_pipe_buf_unmap(struct pipe_inode_info *, struct pipe_buffer *, void *);
 void generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *);
-int generic_pipe_buf_pin(struct pipe_inode_info *, struct pipe_buffer *);
+int generic_pipe_buf_confirm(struct pipe_inode_info *, struct pipe_buffer *);
 int generic_pipe_buf_steal(struct pipe_inode_info *, struct pipe_buffer *);
 
-/*
- * splice is tied to pipes as a transport (at least for now), so we'll just
- * add the splice flags here.
- */
-#define SPLICE_F_MOVE   (0x01)  /* move pages instead of copying */
-#define SPLICE_F_NONBLOCK (0x02) /* don't block on the pipe splicing (but */
-                                 /* we may still block on the fd we splice */
-                                 /* from/to, of course */
-#define SPLICE_F_MORE   (0x04)  /* expect more data */
-#define SPLICE_F_GIFT   (0x08)  /* pages passed in are a gift */
-
-/*
- * Passed to the actors
- */
-struct splice_desc {
-        unsigned int len, total_len;    /* current and remaining length */
-        unsigned int flags;             /* splice flags */
-        struct file *file;              /* file to read/write */
-        loff_t pos;                     /* file position */
-};
-
-typedef int (splice_actor)(struct pipe_inode_info *, struct pipe_buffer *,
-                           struct splice_desc *);
-
-extern ssize_t splice_from_pipe(struct pipe_inode_info *, struct file *,
-                                loff_t *, size_t, unsigned int,
-                                splice_actor *);
-
-extern ssize_t __splice_from_pipe(struct pipe_inode_info *, struct file *,
-                                  loff_t *, size_t, unsigned int,
-                                  splice_actor *);
-
 #endif
diff --git a/include/linux/splice.h b/include/linux/splice.h
new file mode 100644
index 000000000000..33e447f98a54
--- /dev/null
+++ b/include/linux/splice.h
@@ -0,0 +1,73 @@
+/*
+ * Function declerations and data structures related to the splice
+ * implementation.
+ *
+ * Copyright (C) 2007 Jens Axboe <jens.axboe@oracle.com>
+ *
+ */
+#ifndef SPLICE_H
+#define SPLICE_H
+
+#include <linux/pipe_fs_i.h>
+
+/*
+ * splice is tied to pipes as a transport (at least for now), so we'll just
+ * add the splice flags here.
+ */
+#define SPLICE_F_MOVE   (0x01)  /* move pages instead of copying */
+#define SPLICE_F_NONBLOCK (0x02) /* don't block on the pipe splicing (but */
+                                 /* we may still block on the fd we splice */
+                                 /* from/to, of course */
+#define SPLICE_F_MORE   (0x04)  /* expect more data */
+#define SPLICE_F_GIFT   (0x08)  /* pages passed in are a gift */
+
+/*
+ * Passed to the actors
+ */
+struct splice_desc {
+        unsigned int len, total_len;    /* current and remaining length */
+        unsigned int flags;             /* splice flags */
+        /*
+         * actor() private data
+         */
+        union {
+                void __user *userptr;   /* memory to write to */
+                struct file *file;      /* file to read/write */
+                void *data;             /* cookie */
+        } u;
+        loff_t pos;                     /* file position */
+};
+
+struct partial_page {
+        unsigned int offset;
+        unsigned int len;
+        unsigned long private;
+};
+
+/*
+ * Passed to splice_to_pipe
+ */
+struct splice_pipe_desc {
+        struct page **pages;            /* page map */
+        struct partial_page *partial;   /* pages[] may not be contig */
+        int nr_pages;                   /* number of pages in map */
+        unsigned int flags;             /* splice flags */
+        const struct pipe_buf_operations *ops;/* ops associated with output pipe */
+};
+
+typedef int (splice_actor)(struct pipe_inode_info *, struct pipe_buffer *,
+                           struct splice_desc *);
+typedef int (splice_direct_actor)(struct pipe_inode_info *,
+                                  struct splice_desc *);
+
+extern ssize_t splice_from_pipe(struct pipe_inode_info *, struct file *,
+                                loff_t *, size_t, unsigned int,
+                                splice_actor *);
+extern ssize_t __splice_from_pipe(struct pipe_inode_info *,
+                                  struct splice_desc *, splice_actor *);
+extern ssize_t splice_to_pipe(struct pipe_inode_info *,
+                              struct splice_pipe_desc *);
+extern ssize_t splice_direct_to_actor(struct file *, struct splice_desc *,
+                                      splice_direct_actor *);
+
+#endif
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index 4a7ae8ab6eb8..129d50f2225c 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -253,7 +253,7 @@ struct svc_rqst {
                                                  * determine what device number
                                                  * to report (real or virtual)
                                                  */
-        int                     rq_sendfile_ok; /* turned off in gss privacy
+        int                     rq_splice_ok;   /* turned off in gss privacy
                                                  * to prevent encrypting page
                                                  * cache pages */
         wait_queue_head_t       rq_wait;        /* synchronization */