forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-10-22 8ac6c7a54ed1b98d142dce24b11c6de6a1e239a5 
 kernel/include/linux/pipe_fs_i.h
....@@ -8,6 +8,11 @@
88 #define PIPE_BUF_FLAG_ATOMIC	0x02	/* was atomically mapped */
99 #define PIPE_BUF_FLAG_GIFT	0x04	/* page is a gift */
1010 #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
1116 
1217 /**
1318  *	struct pipe_buffer - a linux kernel pipe buffer
....@@ -29,30 +34,40 @@
2934 /**
3035  *	struct pipe_inode_info - a linux kernel pipe
3136  *	@mutex: mutex protecting the whole thing
32
- *	@wait: reader/writer wait point in case of empty/full pipe
33
- *	@nrbufs: the number of non-empty pipe buffers in this pipe
34
- *	@buffers: total number of buffers (should be a power of 2)
35
- *	@curbuf: the current pipe buffer entry
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
3645  *	@tmp_page: cached released page
3746  *	@readers: number of current readers of this pipe
3847  *	@writers: number of current writers of this pipe
3948  *	@files: number of struct file referring this pipe (protected by ->i_lock)
40
- *	@waiting_writers: number of writers blocked waiting for room
4149  *	@r_counter: reader counter
4250  *	@w_counter: writer counter
4351  *	@fasync_readers: reader side fasync
4452  *	@fasync_writers: writer side fasync
4553  *	@bufs: the circular array of pipe buffers
4654  *	@user: the user who created this pipe
55
+ *	@watch_queue: If this pipe is a watch_queue, this is the stuff for that
4756  **/
4857 struct pipe_inode_info {
4958 	struct mutex mutex;
50
-	wait_queue_head_t wait;
51
-	unsigned int nrbufs, curbuf, buffers;
59
+	wait_queue_head_t rd_wait, wr_wait;
60
+	unsigned int head;
61
+	unsigned int tail;
62
+	unsigned int max_usage;
63
+	unsigned int ring_size;
64
+#ifdef CONFIG_WATCH_QUEUE
65
+	bool note_loss;
66
+#endif
67
+	unsigned int nr_accounted;
5268 	unsigned int readers;
5369 	unsigned int writers;
5470 	unsigned int files;
55
-	unsigned int waiting_writers;
5671 	unsigned int r_counter;
5772 	unsigned int w_counter;
5873 	struct page *tmp_page;
....@@ -60,32 +75,28 @@
6075 	struct fasync_struct *fasync_writers;
6176 	struct pipe_buffer *bufs;
6277 	struct user_struct *user;
78
+#ifdef CONFIG_WATCH_QUEUE
79
+	struct watch_queue *watch_queue;
80
+#endif
6381 };
6482 
6583 /*
6684  * Note on the nesting of these functions:
6785  *
6886  * ->confirm()
69
- *	->steal()
87
+ *	->try_steal()
7088  *
71
- * That is, ->steal() must be called on a confirmed buffer.
72
- * See below for the meaning of each operation. Also see kerneldoc
73
- * in fs/pipe.c for the pipe and generic variants of these hooks.
89
+ * That is, ->try_steal() must be called on a confirmed buffer.  See below for
90
+ * the meaning of each operation.  Also see the kerneldoc in fs/pipe.c for the
91
+ * pipe and generic variants of these hooks.
7492  */
7593 struct pipe_buf_operations {
76
-	/*
77
-	 * This is set to 1, if the generic pipe read/write may coalesce
78
-	 * data into an existing buffer. If this is set to 0, a new pipe
79
-	 * page segment is always used for new data.
80
-	 */
81
-	int can_merge;
82
-
8394 	/*
8495 	 * ->confirm() verifies that the data in the pipe buffer is there
8596 	 * and that the contents are good. If the pages in the pipe belong
8697 	 * to a file system, we may need to wait for IO completion in this
8798 	 * hook. Returns 0 for good, or a negative error value in case of
88
-	 * error.
99
+	 * error.  If not present all pages are considered good.
89100 	 */
90101 	int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *);
91102 
....@@ -97,19 +108,71 @@
97108 
98109 	/*
99110 	 * Attempt to take ownership of the pipe buffer and its contents.
100
-	 * ->steal() returns 0 for success, in which case the contents
101
-	 * of the pipe (the buf->page) is locked and now completely owned
102
-	 * by the caller. The page may then be transferred to a different
103
-	 * mapping, the most often used case is insertion into different
104
-	 * file address space cache.
111
+	 * ->try_steal() returns %true for success, in which case the contents
112
+	 * of the pipe (the buf->page) is locked and now completely owned by the
113
+	 * caller. The page may then be transferred to a different mapping, the
114
+	 * most often used case is insertion into different file address space
115
+	 * cache.
105116 	 */
106
-	int (*steal)(struct pipe_inode_info *, struct pipe_buffer *);
117
+	bool (*try_steal)(struct pipe_inode_info *, struct pipe_buffer *);
107118 
108119 	/*
109120 	 * Get a reference to the pipe buffer.
110121 	 */
111122 	bool (*get)(struct pipe_inode_info *, struct pipe_buffer *);
112123 };
124
+
125
+/**
126
+ * pipe_empty - Return true if the pipe is empty
127
+ * @head: The pipe ring head pointer
128
+ * @tail: The pipe ring tail pointer
129
+ */
130
+static inline bool pipe_empty(unsigned int head, unsigned int tail)
131
+{
132
+	return head == tail;
133
+}
134
+
135
+/**
136
+ * pipe_occupancy - Return number of slots used in the pipe
137
+ * @head: The pipe ring head pointer
138
+ * @tail: The pipe ring tail pointer
139
+ */
140
+static inline unsigned int pipe_occupancy(unsigned int head, unsigned int tail)
141
+{
142
+	return head - tail;
143
+}
144
+
145
+/**
146
+ * pipe_full - Return true if the pipe is full
147
+ * @head: The pipe ring head pointer
148
+ * @tail: The pipe ring tail pointer
149
+ * @limit: The maximum amount of slots available.
150
+ */
151
+static inline bool pipe_full(unsigned int head, unsigned int tail,
152
+			     unsigned int limit)
153
+{
154
+	return pipe_occupancy(head, tail) >= limit;
155
+}
156
+
157
+/**
158
+ * pipe_space_for_user - Return number of slots available to userspace
159
+ * @head: The pipe ring head pointer
160
+ * @tail: The pipe ring tail pointer
161
+ * @pipe: The pipe info structure
162
+ */
163
+static inline unsigned int pipe_space_for_user(unsigned int head, unsigned int tail,
164
+					       struct pipe_inode_info *pipe)
165
+{
166
+	unsigned int p_occupancy, p_space;
167
+
168
+	p_occupancy = pipe_occupancy(head, tail);
169
+	if (p_occupancy >= pipe->max_usage)
170
+		return 0;
171
+	p_space = pipe->ring_size - p_occupancy;
172
+	if (p_space > pipe->max_usage)
173
+		p_space = pipe->max_usage;
174
+	return p_space;
175
+}
113176 
114177 /**
115178  * pipe_buf_get - get a reference to a pipe_buffer
....@@ -146,18 +209,22 @@
146209 static inline int pipe_buf_confirm(struct pipe_inode_info *pipe,
147210 				   struct pipe_buffer *buf)
148211 {
212
+	if (!buf->ops->confirm)
213
+		return 0;
149214 	return buf->ops->confirm(pipe, buf);
150215 }
151216 
152217 /**
153
- * pipe_buf_steal - attempt to take ownership of a pipe_buffer
218
+ * pipe_buf_try_steal - attempt to take ownership of a pipe_buffer
154219  * @pipe:	the pipe that the buffer belongs to
155220  * @buf:	the buffer to attempt to steal
156221  */
157
-static inline int pipe_buf_steal(struct pipe_inode_info *pipe,
158
-				 struct pipe_buffer *buf)
222
+static inline bool pipe_buf_try_steal(struct pipe_inode_info *pipe,
223
+		struct pipe_buffer *buf)
159224 {
160
-	return buf->ops->steal(pipe, buf);
225
+	if (!buf->ops->try_steal)
226
+		return false;
227
+	return buf->ops->try_steal(pipe, buf);
161228 }
162229 
163230 /* Differs from PIPE_BUF in that PIPE_SIZE is the length of the actual
....@@ -173,25 +240,30 @@
173240 extern unsigned long pipe_user_pages_hard;
174241 extern unsigned long pipe_user_pages_soft;
175242 
176
-/* Drop the inode semaphore and wait for a pipe event, atomically */
177
-void pipe_wait(struct pipe_inode_info *pipe);
243
+/* Wait for a pipe to be readable/writable while dropping the pipe lock */
244
+void pipe_wait_readable(struct pipe_inode_info *);
245
+void pipe_wait_writable(struct pipe_inode_info *);
178246 
179247 struct pipe_inode_info *alloc_pipe_info(void);
180248 void free_pipe_info(struct pipe_inode_info *);
181249 
182250 /* Generic pipe buffer ops functions */
183251 bool generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *);
184
-int generic_pipe_buf_confirm(struct pipe_inode_info *, struct pipe_buffer *);
185
-int generic_pipe_buf_steal(struct pipe_inode_info *, struct pipe_buffer *);
186
-int generic_pipe_buf_nosteal(struct pipe_inode_info *, struct pipe_buffer *);
252
+bool generic_pipe_buf_try_steal(struct pipe_inode_info *, struct pipe_buffer *);
187253 void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *);
188
-void pipe_buf_mark_unmergeable(struct pipe_buffer *buf);
189254 
190255 extern const struct pipe_buf_operations nosteal_pipe_buf_ops;
191256 
257
+unsigned long account_pipe_buffers(struct user_struct *user,
258
+				   unsigned long old, unsigned long new);
259
+bool too_many_pipe_buffers_soft(unsigned long user_bufs);
260
+bool too_many_pipe_buffers_hard(unsigned long user_bufs);
261
+bool pipe_is_unprivileged_user(void);
262
+
192263 /* for F_SETPIPE_SZ and F_GETPIPE_SZ */
264
+int pipe_resize_ring(struct pipe_inode_info *pipe, unsigned int nr_slots);
193265 long pipe_fcntl(struct file *, unsigned int, unsigned long arg);
194
-struct pipe_inode_info *get_pipe_info(struct file *file);
266
+struct pipe_inode_info *get_pipe_info(struct file *file, bool for_splice);
195267 
196268 int create_pipe_files(struct file **, int);
197269 unsigned int round_pipe_size(unsigned long size);