pipe: add documentation and comments

As per Andrew Mortons request, here's a set of documentation for
the generic pipe_buf_operations hooks, the pipe, and pipe_buffer
structures.

Signed-off-by: Jens Axboe <jens.axboe@oracle.com>

1 files changed, 76 insertions, 1 deletions

diff --git a/include/linux/pipe_fs_i.h b/include/linux/pipe_fs_i.h
index cc09fe89bf07..8e4120285f72 100644
--- a/include/linux/pipe_fs_i.h
+++ b/include/linux/pipe_fs_i.h
@@ -9,6 +9,15 @@
 #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;
@@ -17,6 +26,22 @@ struct pipe_buffer {
         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;
@@ -43,15 +68,65 @@ struct pipe_inode_info {
  *      ->unmap()
  *
  * That is, ->map() must be called on a confirmed buffer,
- * same goes for ->steal().
+ * 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 *);
+
+        /*
+         * ->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 *);
 };