1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _LINUX_PIPE_FS_I_H 3 #define _LINUX_PIPE_FS_I_H 4 5 #define PIPE_DEF_BUFFERS 16 6 7 #define PIPE_BUF_FLAG_LRU 0x01 /* page is on the LRU */ 8 #define PIPE_BUF_FLAG_ATOMIC 0x02 /* was atomically mapped */ 9 #define PIPE_BUF_FLAG_GIFT 0x04 /* page is a gift */ 10 #define PIPE_BUF_FLAG_PACKET 0x08 /* read() as a packet */ 11 #define PIPE_BUF_FLAG_CAN_MERGE 0x10 /* can merge buffers */ 12 #define PIPE_BUF_FLAG_WHOLE 0x20 /* read() must return entire buffer or error */ 13 #ifdef CONFIG_WATCH_QUEUE 14 #define PIPE_BUF_FLAG_LOSS 0x40 /* Message loss happened after this buffer */ 15 #endif 16 17 /** 18 * struct pipe_buffer - a linux kernel pipe buffer 19 * @page: the page containing the data for the pipe buffer 20 * @offset: offset of data inside the @page 21 * @len: length of data inside the @page 22 * @ops: operations associated with this buffer. See @pipe_buf_operations. 23 * @flags: pipe buffer flags. See above. 24 * @private: private data owned by the ops. 25 **/ 26 struct pipe_buffer { 27 struct page *page; 28 unsigned int offset, len; 29 const struct pipe_buf_operations *ops; 30 unsigned int flags; 31 unsigned long private; 32 }; 33 34 /** 35 * struct pipe_inode_info - a linux kernel pipe 36 * @mutex: mutex protecting the whole thing 37 * @rd_wait: reader wait point in case of empty pipe 38 * @wr_wait: writer wait point in case of full pipe 39 * @head: The point of buffer production 40 * @tail: The point of buffer consumption 41 * @note_loss: The next read() should insert a data-lost message 42 * @max_usage: The maximum number of slots that may be used in the ring 43 * @ring_size: total number of buffers (should be a power of 2) 44 * @nr_accounted: The amount this pipe accounts for in user->pipe_bufs 45 * @tmp_page: cached released page 46 * @readers: number of current readers of this pipe 47 * @writers: number of current writers of this pipe 48 * @files: number of struct file referring this pipe (protected by ->i_lock) 49 * @r_counter: reader counter 50 * @w_counter: writer counter 51 * @poll_usage: is this pipe used for epoll, which has crazy wakeups? 52 * @fasync_readers: reader side fasync 53 * @fasync_writers: writer side fasync 54 * @bufs: the circular array of pipe buffers 55 * @user: the user who created this pipe 56 * @watch_queue: If this pipe is a watch_queue, this is the stuff for that 57 **/ 58 struct pipe_inode_info { 59 struct mutex mutex; 60 wait_queue_head_t rd_wait, wr_wait; 61 unsigned int head; 62 unsigned int tail; 63 unsigned int max_usage; 64 unsigned int ring_size; 65 unsigned int nr_accounted; 66 unsigned int readers; 67 unsigned int writers; 68 unsigned int files; 69 unsigned int r_counter; 70 unsigned int w_counter; 71 bool poll_usage; 72 #ifdef CONFIG_WATCH_QUEUE 73 bool note_loss; 74 #endif 75 struct page *tmp_page; 76 struct fasync_struct *fasync_readers; 77 struct fasync_struct *fasync_writers; 78 struct pipe_buffer *bufs; 79 struct user_struct *user; 80 #ifdef CONFIG_WATCH_QUEUE 81 struct watch_queue *watch_queue; 82 #endif 83 }; 84 85 /* 86 * Note on the nesting of these functions: 87 * 88 * ->confirm() 89 * ->try_steal() 90 * 91 * That is, ->try_steal() must be called on a confirmed buffer. See below for 92 * the meaning of each operation. Also see the kerneldoc in fs/pipe.c for the 93 * pipe and generic variants of these hooks. 94 */ 95 struct pipe_buf_operations { 96 /* 97 * ->confirm() verifies that the data in the pipe buffer is there 98 * and that the contents are good. If the pages in the pipe belong 99 * to a file system, we may need to wait for IO completion in this 100 * hook. Returns 0 for good, or a negative error value in case of 101 * error. If not present all pages are considered good. 102 */ 103 int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *); 104 105 /* 106 * When the contents of this pipe buffer has been completely 107 * consumed by a reader, ->release() is called. 108 */ 109 void (*release)(struct pipe_inode_info *, struct pipe_buffer *); 110 111 /* 112 * Attempt to take ownership of the pipe buffer and its contents. 113 * ->try_steal() returns %true for success, in which case the contents 114 * of the pipe (the buf->page) is locked and now completely owned by the 115 * caller. The page may then be transferred to a different mapping, the 116 * most often used case is insertion into different file address space 117 * cache. 118 */ 119 bool (*try_steal)(struct pipe_inode_info *, struct pipe_buffer *); 120 121 /* 122 * Get a reference to the pipe buffer. 123 */ 124 bool (*get)(struct pipe_inode_info *, struct pipe_buffer *); 125 }; 126 127 /** 128 * pipe_has_watch_queue - Check whether the pipe is a watch_queue, 129 * i.e. it was created with O_NOTIFICATION_PIPE 130 * @pipe: The pipe to check 131 * 132 * Return: true if pipe is a watch queue, false otherwise. 133 */ pipe_has_watch_queue(const struct pipe_inode_info * pipe)134 static inline bool pipe_has_watch_queue(const struct pipe_inode_info *pipe) 135 { 136 #ifdef CONFIG_WATCH_QUEUE 137 return pipe->watch_queue != NULL; 138 #else 139 return false; 140 #endif 141 } 142 143 /** 144 * pipe_empty - Return true if the pipe is empty 145 * @head: The pipe ring head pointer 146 * @tail: The pipe ring tail pointer 147 */ pipe_empty(unsigned int head,unsigned int tail)148 static inline bool pipe_empty(unsigned int head, unsigned int tail) 149 { 150 return head == tail; 151 } 152 153 /** 154 * pipe_occupancy - Return number of slots used in the pipe 155 * @head: The pipe ring head pointer 156 * @tail: The pipe ring tail pointer 157 */ pipe_occupancy(unsigned int head,unsigned int tail)158 static inline unsigned int pipe_occupancy(unsigned int head, unsigned int tail) 159 { 160 return head - tail; 161 } 162 163 /** 164 * pipe_full - Return true if the pipe is full 165 * @head: The pipe ring head pointer 166 * @tail: The pipe ring tail pointer 167 * @limit: The maximum amount of slots available. 168 */ pipe_full(unsigned int head,unsigned int tail,unsigned int limit)169 static inline bool pipe_full(unsigned int head, unsigned int tail, 170 unsigned int limit) 171 { 172 return pipe_occupancy(head, tail) >= limit; 173 } 174 175 /** 176 * pipe_buf - Return the pipe buffer for the specified slot in the pipe ring 177 * @pipe: The pipe to access 178 * @slot: The slot of interest 179 */ pipe_buf(const struct pipe_inode_info * pipe,unsigned int slot)180 static inline struct pipe_buffer *pipe_buf(const struct pipe_inode_info *pipe, 181 unsigned int slot) 182 { 183 return &pipe->bufs[slot & (pipe->ring_size - 1)]; 184 } 185 186 /** 187 * pipe_head_buf - Return the pipe buffer at the head of the pipe ring 188 * @pipe: The pipe to access 189 */ pipe_head_buf(const struct pipe_inode_info * pipe)190 static inline struct pipe_buffer *pipe_head_buf(const struct pipe_inode_info *pipe) 191 { 192 return pipe_buf(pipe, pipe->head); 193 } 194 195 /** 196 * pipe_buf_get - get a reference to a pipe_buffer 197 * @pipe: the pipe that the buffer belongs to 198 * @buf: the buffer to get a reference to 199 * 200 * Return: %true if the reference was successfully obtained. 201 */ pipe_buf_get(struct pipe_inode_info * pipe,struct pipe_buffer * buf)202 static inline __must_check bool pipe_buf_get(struct pipe_inode_info *pipe, 203 struct pipe_buffer *buf) 204 { 205 return buf->ops->get(pipe, buf); 206 } 207 208 /** 209 * pipe_buf_release - put a reference to a pipe_buffer 210 * @pipe: the pipe that the buffer belongs to 211 * @buf: the buffer to put a reference to 212 */ pipe_buf_release(struct pipe_inode_info * pipe,struct pipe_buffer * buf)213 static inline void pipe_buf_release(struct pipe_inode_info *pipe, 214 struct pipe_buffer *buf) 215 { 216 const struct pipe_buf_operations *ops = buf->ops; 217 218 buf->ops = NULL; 219 ops->release(pipe, buf); 220 } 221 222 /** 223 * pipe_buf_confirm - verify contents of the pipe buffer 224 * @pipe: the pipe that the buffer belongs to 225 * @buf: the buffer to confirm 226 */ pipe_buf_confirm(struct pipe_inode_info * pipe,struct pipe_buffer * buf)227 static inline int pipe_buf_confirm(struct pipe_inode_info *pipe, 228 struct pipe_buffer *buf) 229 { 230 if (!buf->ops->confirm) 231 return 0; 232 return buf->ops->confirm(pipe, buf); 233 } 234 235 /** 236 * pipe_buf_try_steal - attempt to take ownership of a pipe_buffer 237 * @pipe: the pipe that the buffer belongs to 238 * @buf: the buffer to attempt to steal 239 */ pipe_buf_try_steal(struct pipe_inode_info * pipe,struct pipe_buffer * buf)240 static inline bool pipe_buf_try_steal(struct pipe_inode_info *pipe, 241 struct pipe_buffer *buf) 242 { 243 if (!buf->ops->try_steal) 244 return false; 245 return buf->ops->try_steal(pipe, buf); 246 } 247 pipe_discard_from(struct pipe_inode_info * pipe,unsigned int old_head)248 static inline void pipe_discard_from(struct pipe_inode_info *pipe, 249 unsigned int old_head) 250 { 251 unsigned int mask = pipe->ring_size - 1; 252 253 while (pipe->head > old_head) 254 pipe_buf_release(pipe, &pipe->bufs[--pipe->head & mask]); 255 } 256 257 /* Differs from PIPE_BUF in that PIPE_SIZE is the length of the actual 258 memory allocation, whereas PIPE_BUF makes atomicity guarantees. */ 259 #define PIPE_SIZE PAGE_SIZE 260 261 /* Pipe lock and unlock operations */ 262 void pipe_lock(struct pipe_inode_info *); 263 void pipe_unlock(struct pipe_inode_info *); 264 void pipe_double_lock(struct pipe_inode_info *, struct pipe_inode_info *); 265 266 /* Wait for a pipe to be readable/writable while dropping the pipe lock */ 267 void pipe_wait_readable(struct pipe_inode_info *); 268 void pipe_wait_writable(struct pipe_inode_info *); 269 270 struct pipe_inode_info *alloc_pipe_info(void); 271 void free_pipe_info(struct pipe_inode_info *); 272 273 /* Generic pipe buffer ops functions */ 274 bool generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *); 275 bool generic_pipe_buf_try_steal(struct pipe_inode_info *, struct pipe_buffer *); 276 void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *); 277 278 extern const struct pipe_buf_operations nosteal_pipe_buf_ops; 279 280 unsigned long account_pipe_buffers(struct user_struct *user, 281 unsigned long old, unsigned long new); 282 bool too_many_pipe_buffers_soft(unsigned long user_bufs); 283 bool too_many_pipe_buffers_hard(unsigned long user_bufs); 284 bool pipe_is_unprivileged_user(void); 285 286 /* for F_SETPIPE_SZ and F_GETPIPE_SZ */ 287 int pipe_resize_ring(struct pipe_inode_info *pipe, unsigned int nr_slots); 288 long pipe_fcntl(struct file *, unsigned int, unsigned int arg); 289 struct pipe_inode_info *get_pipe_info(struct file *file, bool for_splice); 290 291 int create_pipe_files(struct file **, int); 292 unsigned int round_pipe_size(unsigned int size); 293 294 #endif 295