1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _LINUX_PIPE_FS_I_H
3 #define _LINUX_PIPE_FS_I_H
5 #define PIPE_DEF_BUFFERS 16
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 */
14 * struct pipe_buffer - a linux kernel pipe buffer
15 * @page: the page containing the data for the pipe buffer
16 * @offset: offset of data inside the @page
17 * @len: length of data inside the @page
18 * @ops: operations associated with this buffer. See @pipe_buf_operations.
19 * @flags: pipe buffer flags. See above.
20 * @private: private data owned by the ops.
24 unsigned int offset, len;
25 const struct pipe_buf_operations *ops;
27 unsigned long private;
31 * struct pipe_inode_info - a linux kernel pipe
32 * @mutex: mutex protecting the whole thing
33 * @rd_wait: reader wait point in case of empty pipe
34 * @wr_wait: writer wait point in case of full pipe
35 * @head: The point of buffer production
36 * @tail: The point of buffer consumption
37 * @max_usage: The maximum number of slots that may be used in the ring
38 * @ring_size: total number of buffers (should be a power of 2)
39 * @tmp_page: cached released page
40 * @readers: number of current readers of this pipe
41 * @writers: number of current writers of this pipe
42 * @files: number of struct file referring this pipe (protected by ->i_lock)
43 * @r_counter: reader counter
44 * @w_counter: writer counter
45 * @fasync_readers: reader side fasync
46 * @fasync_writers: writer side fasync
47 * @bufs: the circular array of pipe buffers
48 * @user: the user who created this pipe
50 struct pipe_inode_info {
52 wait_queue_head_t rd_wait, wr_wait;
55 unsigned int max_usage;
56 unsigned int ring_size;
60 unsigned int r_counter;
61 unsigned int w_counter;
62 struct page *tmp_page;
63 struct fasync_struct *fasync_readers;
64 struct fasync_struct *fasync_writers;
65 struct pipe_buffer *bufs;
66 struct user_struct *user;
70 * Note on the nesting of these functions:
75 * That is, ->try_steal() must be called on a confirmed buffer. See below for
76 * the meaning of each operation. Also see the kerneldoc in fs/pipe.c for the
77 * pipe and generic variants of these hooks.
79 struct pipe_buf_operations {
81 * ->confirm() verifies that the data in the pipe buffer is there
82 * and that the contents are good. If the pages in the pipe belong
83 * to a file system, we may need to wait for IO completion in this
84 * hook. Returns 0 for good, or a negative error value in case of
85 * error. If not present all pages are considered good.
87 int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *);
90 * When the contents of this pipe buffer has been completely
91 * consumed by a reader, ->release() is called.
93 void (*release)(struct pipe_inode_info *, struct pipe_buffer *);
96 * Attempt to take ownership of the pipe buffer and its contents.
97 * ->try_steal() returns %true for success, in which case the contents
98 * of the pipe (the buf->page) is locked and now completely owned by the
99 * caller. The page may then be transferred to a different mapping, the
100 * most often used case is insertion into different file address space
103 bool (*try_steal)(struct pipe_inode_info *, struct pipe_buffer *);
106 * Get a reference to the pipe buffer.
108 bool (*get)(struct pipe_inode_info *, struct pipe_buffer *);
112 * pipe_empty - Return true if the pipe is empty
113 * @head: The pipe ring head pointer
114 * @tail: The pipe ring tail pointer
116 static inline bool pipe_empty(unsigned int head, unsigned int tail)
122 * pipe_occupancy - Return number of slots used in the pipe
123 * @head: The pipe ring head pointer
124 * @tail: The pipe ring tail pointer
126 static inline unsigned int pipe_occupancy(unsigned int head, unsigned int tail)
132 * pipe_full - Return true if the pipe is full
133 * @head: The pipe ring head pointer
134 * @tail: The pipe ring tail pointer
135 * @limit: The maximum amount of slots available.
137 static inline bool pipe_full(unsigned int head, unsigned int tail,
140 return pipe_occupancy(head, tail) >= limit;
144 * pipe_space_for_user - Return number of slots available to userspace
145 * @head: The pipe ring head pointer
146 * @tail: The pipe ring tail pointer
147 * @pipe: The pipe info structure
149 static inline unsigned int pipe_space_for_user(unsigned int head, unsigned int tail,
150 struct pipe_inode_info *pipe)
152 unsigned int p_occupancy, p_space;
154 p_occupancy = pipe_occupancy(head, tail);
155 if (p_occupancy >= pipe->max_usage)
157 p_space = pipe->ring_size - p_occupancy;
158 if (p_space > pipe->max_usage)
159 p_space = pipe->max_usage;
164 * pipe_buf_get - get a reference to a pipe_buffer
165 * @pipe: the pipe that the buffer belongs to
166 * @buf: the buffer to get a reference to
168 * Return: %true if the reference was successfully obtained.
170 static inline __must_check bool pipe_buf_get(struct pipe_inode_info *pipe,
171 struct pipe_buffer *buf)
173 return buf->ops->get(pipe, buf);
177 * pipe_buf_release - put a reference to a pipe_buffer
178 * @pipe: the pipe that the buffer belongs to
179 * @buf: the buffer to put a reference to
181 static inline void pipe_buf_release(struct pipe_inode_info *pipe,
182 struct pipe_buffer *buf)
184 const struct pipe_buf_operations *ops = buf->ops;
187 ops->release(pipe, buf);
191 * pipe_buf_confirm - verify contents of the pipe buffer
192 * @pipe: the pipe that the buffer belongs to
193 * @buf: the buffer to confirm
195 static inline int pipe_buf_confirm(struct pipe_inode_info *pipe,
196 struct pipe_buffer *buf)
198 if (!buf->ops->confirm)
200 return buf->ops->confirm(pipe, buf);
204 * pipe_buf_try_steal - attempt to take ownership of a pipe_buffer
205 * @pipe: the pipe that the buffer belongs to
206 * @buf: the buffer to attempt to steal
208 static inline bool pipe_buf_try_steal(struct pipe_inode_info *pipe,
209 struct pipe_buffer *buf)
211 if (!buf->ops->try_steal)
213 return buf->ops->try_steal(pipe, buf);
216 /* Differs from PIPE_BUF in that PIPE_SIZE is the length of the actual
217 memory allocation, whereas PIPE_BUF makes atomicity guarantees. */
218 #define PIPE_SIZE PAGE_SIZE
220 /* Pipe lock and unlock operations */
221 void pipe_lock(struct pipe_inode_info *);
222 void pipe_unlock(struct pipe_inode_info *);
223 void pipe_double_lock(struct pipe_inode_info *, struct pipe_inode_info *);
225 extern unsigned int pipe_max_size;
226 extern unsigned long pipe_user_pages_hard;
227 extern unsigned long pipe_user_pages_soft;
229 /* Drop the inode semaphore and wait for a pipe event, atomically */
230 void pipe_wait(struct pipe_inode_info *pipe);
232 struct pipe_inode_info *alloc_pipe_info(void);
233 void free_pipe_info(struct pipe_inode_info *);
235 /* Generic pipe buffer ops functions */
236 bool generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *);
237 bool generic_pipe_buf_try_steal(struct pipe_inode_info *, struct pipe_buffer *);
238 void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *);
240 extern const struct pipe_buf_operations nosteal_pipe_buf_ops;
242 /* for F_SETPIPE_SZ and F_GETPIPE_SZ */
243 long pipe_fcntl(struct file *, unsigned int, unsigned long arg);
244 struct pipe_inode_info *get_pipe_info(struct file *file);
246 int create_pipe_files(struct file **, int);
247 unsigned int round_pipe_size(unsigned long size);