| 1 | #ifndef _LINUX_PIPE_FS_I_H |
| 2 | #define _LINUX_PIPE_FS_I_H |
| 3 | |
| 4 | #define PIPE_DEF_BUFFERS 16 |
| 5 | |
| 6 | #define PIPE_BUF_FLAG_LRU 0x01 /* page is on the LRU */ |
| 7 | #define PIPE_BUF_FLAG_ATOMIC 0x02 /* was atomically mapped */ |
| 8 | #define PIPE_BUF_FLAG_GIFT 0x04 /* page is a gift */ |
| 9 | #define PIPE_BUF_FLAG_PACKET 0x08 /* read() as a packet */ |
| 10 | |
| 11 | /** |
| 12 | * struct pipe_buffer - a linux kernel pipe buffer |
| 13 | * @page: the page containing the data for the pipe buffer |
| 14 | * @offset: offset of data inside the @page |
| 15 | * @len: length of data inside the @page |
| 16 | * @ops: operations associated with this buffer. See @pipe_buf_operations. |
| 17 | * @flags: pipe buffer flags. See above. |
| 18 | * @private: private data owned by the ops. |
| 19 | **/ |
| 20 | struct pipe_buffer { |
| 21 | struct page *page; |
| 22 | unsigned int offset, len; |
| 23 | const struct pipe_buf_operations *ops; |
| 24 | unsigned int flags; |
| 25 | unsigned long private; |
| 26 | }; |
| 27 | |
| 28 | /** |
| 29 | * struct pipe_inode_info - a linux kernel pipe |
| 30 | * @mutex: mutex protecting the whole thing |
| 31 | * @wait: reader/writer wait point in case of empty/full pipe |
| 32 | * @nrbufs: the number of non-empty pipe buffers in this pipe |
| 33 | * @buffers: total number of buffers (should be a power of 2) |
| 34 | * @curbuf: the current pipe buffer entry |
| 35 | * @tmp_page: cached released page |
| 36 | * @readers: number of current readers of this pipe |
| 37 | * @writers: number of current writers of this pipe |
| 38 | * @files: number of struct file refering this pipe (protected by ->i_lock) |
| 39 | * @waiting_writers: number of writers blocked waiting for room |
| 40 | * @r_counter: reader counter |
| 41 | * @w_counter: writer counter |
| 42 | * @fasync_readers: reader side fasync |
| 43 | * @fasync_writers: writer side fasync |
| 44 | * @bufs: the circular array of pipe buffers |
| 45 | * @user: the user who created this pipe |
| 46 | **/ |
| 47 | struct pipe_inode_info { |
| 48 | struct mutex mutex; |
| 49 | wait_queue_head_t wait; |
| 50 | unsigned int nrbufs, curbuf, buffers; |
| 51 | unsigned int readers; |
| 52 | unsigned int writers; |
| 53 | unsigned int files; |
| 54 | unsigned int waiting_writers; |
| 55 | unsigned int r_counter; |
| 56 | unsigned int w_counter; |
| 57 | struct page *tmp_page; |
| 58 | struct fasync_struct *fasync_readers; |
| 59 | struct fasync_struct *fasync_writers; |
| 60 | struct pipe_buffer *bufs; |
| 61 | struct user_struct *user; |
| 62 | }; |
| 63 | |
| 64 | /* |
| 65 | * Note on the nesting of these functions: |
| 66 | * |
| 67 | * ->confirm() |
| 68 | * ->steal() |
| 69 | * ... |
| 70 | * ->map() |
| 71 | * ... |
| 72 | * ->unmap() |
| 73 | * |
| 74 | * That is, ->map() must be called on a confirmed buffer, |
| 75 | * same goes for ->steal(). See below for the meaning of each |
| 76 | * operation. Also see kerneldoc in fs/pipe.c for the pipe |
| 77 | * and generic variants of these hooks. |
| 78 | */ |
| 79 | struct pipe_buf_operations { |
| 80 | /* |
| 81 | * This is set to 1, if the generic pipe read/write may coalesce |
| 82 | * data into an existing buffer. If this is set to 0, a new pipe |
| 83 | * page segment is always used for new data. |
| 84 | */ |
| 85 | int can_merge; |
| 86 | |
| 87 | /* |
| 88 | * ->map() returns a virtual address mapping of the pipe buffer. |
| 89 | * The last integer flag reflects whether this should be an atomic |
| 90 | * mapping or not. The atomic map is faster, however you can't take |
| 91 | * page faults before calling ->unmap() again. So if you need to eg |
| 92 | * access user data through copy_to/from_user(), then you must get |
| 93 | * a non-atomic map. ->map() uses the kmap_atomic slot for |
| 94 | * atomic maps, you have to be careful if mapping another page as |
| 95 | * source or destination for a copy. |
| 96 | */ |
| 97 | void * (*map)(struct pipe_inode_info *, struct pipe_buffer *, int); |
| 98 | |
| 99 | /* |
| 100 | * Undoes ->map(), finishes the virtual mapping of the pipe buffer. |
| 101 | */ |
| 102 | void (*unmap)(struct pipe_inode_info *, struct pipe_buffer *, void *); |
| 103 | |
| 104 | /* |
| 105 | * ->confirm() verifies that the data in the pipe buffer is there |
| 106 | * and that the contents are good. If the pages in the pipe belong |
| 107 | * to a file system, we may need to wait for IO completion in this |
| 108 | * hook. Returns 0 for good, or a negative error value in case of |
| 109 | * error. |
| 110 | */ |
| 111 | int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *); |
| 112 | |
| 113 | /* |
| 114 | * When the contents of this pipe buffer has been completely |
| 115 | * consumed by a reader, ->release() is called. |
| 116 | */ |
| 117 | void (*release)(struct pipe_inode_info *, struct pipe_buffer *); |
| 118 | |
| 119 | /* |
| 120 | * Attempt to take ownership of the pipe buffer and its contents. |
| 121 | * ->steal() returns 0 for success, in which case the contents |
| 122 | * of the pipe (the buf->page) is locked and now completely owned |
| 123 | * by the caller. The page may then be transferred to a different |
| 124 | * mapping, the most often used case is insertion into different |
| 125 | * file address space cache. |
| 126 | */ |
| 127 | int (*steal)(struct pipe_inode_info *, struct pipe_buffer *); |
| 128 | |
| 129 | /* |
| 130 | * Get a reference to the pipe buffer. |
| 131 | */ |
| 132 | void (*get)(struct pipe_inode_info *, struct pipe_buffer *); |
| 133 | }; |
| 134 | |
| 135 | /* Differs from PIPE_BUF in that PIPE_SIZE is the length of the actual |
| 136 | memory allocation, whereas PIPE_BUF makes atomicity guarantees. */ |
| 137 | #define PIPE_SIZE PAGE_SIZE |
| 138 | |
| 139 | /* Pipe lock and unlock operations */ |
| 140 | void pipe_lock(struct pipe_inode_info *); |
| 141 | void pipe_unlock(struct pipe_inode_info *); |
| 142 | void pipe_double_lock(struct pipe_inode_info *, struct pipe_inode_info *); |
| 143 | |
| 144 | extern unsigned int pipe_max_size, pipe_min_size; |
| 145 | extern unsigned long pipe_user_pages_hard; |
| 146 | extern unsigned long pipe_user_pages_soft; |
| 147 | int pipe_proc_fn(struct ctl_table *, int, void __user *, size_t *, loff_t *); |
| 148 | |
| 149 | |
| 150 | /* Drop the inode semaphore and wait for a pipe event, atomically */ |
| 151 | void pipe_wait(struct pipe_inode_info *pipe); |
| 152 | |
| 153 | struct pipe_inode_info *alloc_pipe_info(void); |
| 154 | void free_pipe_info(struct pipe_inode_info *); |
| 155 | |
| 156 | /* Generic pipe buffer ops functions */ |
| 157 | void *generic_pipe_buf_map(struct pipe_inode_info *, struct pipe_buffer *, int); |
| 158 | void generic_pipe_buf_unmap(struct pipe_inode_info *, struct pipe_buffer *, void *); |
| 159 | void generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *); |
| 160 | int generic_pipe_buf_confirm(struct pipe_inode_info *, struct pipe_buffer *); |
| 161 | int generic_pipe_buf_steal(struct pipe_inode_info *, struct pipe_buffer *); |
| 162 | void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *); |
| 163 | |
| 164 | extern const struct pipe_buf_operations nosteal_pipe_buf_ops; |
| 165 | |
| 166 | /* for F_SETPIPE_SZ and F_GETPIPE_SZ */ |
| 167 | long pipe_fcntl(struct file *, unsigned int, unsigned long arg); |
| 168 | struct pipe_inode_info *get_pipe_info(struct file *file); |
| 169 | |
| 170 | int create_pipe_files(struct file **, int); |
| 171 | |
| 172 | #endif |