blob: 9faecf1b4a27b52f053aba802e5ac3e4f9c9a183 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/pipe.c
3 *
4 * Copyright (C) 1991, 1992, 1999 Linus Torvalds
5 */
6
7#include <linux/mm.h>
8#include <linux/file.h>
9#include <linux/poll.h>
10#include <linux/slab.h>
11#include <linux/module.h>
12#include <linux/init.h>
13#include <linux/fs.h>
Jens Axboe35f3d142010-05-20 10:43:18 +020014#include <linux/log2.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/mount.h>
Muthu Kumarb502bd12012-03-23 15:01:50 -070016#include <linux/magic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/pipe_fs_i.h>
18#include <linux/uio.h>
19#include <linux/highmem.h>
Jens Axboe5274f052006-03-30 15:15:30 +020020#include <linux/pagemap.h>
Al Virodb349502007-02-07 01:48:00 -050021#include <linux/audit.h>
Ulrich Drepperba719ba2008-05-06 20:42:38 -070022#include <linux/syscalls.h>
Jens Axboeb492e952010-05-19 21:03:16 +020023#include <linux/fcntl.h>
Vladimir Davydovd86133b2016-07-26 15:24:33 -070024#include <linux/memcontrol.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
26#include <asm/uaccess.h>
27#include <asm/ioctls.h>
28
Al Viro599a0ac2013-03-12 09:58:10 -040029#include "internal.h"
30
Linus Torvalds1da177e2005-04-16 15:20:36 -070031/*
Jens Axboeb492e952010-05-19 21:03:16 +020032 * The max size that a non-root user is allowed to grow the pipe. Can
Jens Axboeff9da692010-06-03 14:54:39 +020033 * be set by root in /proc/sys/fs/pipe-max-size
Jens Axboeb492e952010-05-19 21:03:16 +020034 */
Jens Axboeff9da692010-06-03 14:54:39 +020035unsigned int pipe_max_size = 1048576;
36
37/*
38 * Minimum pipe size, as required by POSIX
39 */
40unsigned int pipe_min_size = PAGE_SIZE;
Jens Axboeb492e952010-05-19 21:03:16 +020041
Willy Tarreau759c0112016-01-18 16:36:09 +010042/* Maximum allocatable pages per user. Hard limit is unset by default, soft
43 * matches default values.
44 */
45unsigned long pipe_user_pages_hard;
46unsigned long pipe_user_pages_soft = PIPE_DEF_BUFFERS * INR_OPEN_CUR;
47
Jens Axboeb492e952010-05-19 21:03:16 +020048/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 * We use a start+len construction, which provides full use of the
50 * allocated memory.
51 * -- Florian Coosmann (FGC)
52 *
53 * Reads with count = 0 should always return 0.
54 * -- Julian Bradfield 1999-06-07.
55 *
56 * FIFOs and Pipes now generate SIGIO for both readers and writers.
57 * -- Jeremy Elson <jelson@circlemud.org> 2001-08-16
58 *
59 * pipe_read & write cleanup
60 * -- Manfred Spraul <manfred@colorfullife.com> 2002-05-09
61 */
62
Miklos Szeredi61e0d472009-04-14 19:48:41 +020063static void pipe_lock_nested(struct pipe_inode_info *pipe, int subclass)
64{
Al Viro6447a3c2013-03-21 11:01:38 -040065 if (pipe->files)
Al Viro72b0d9a2013-03-21 02:32:24 -040066 mutex_lock_nested(&pipe->mutex, subclass);
Miklos Szeredi61e0d472009-04-14 19:48:41 +020067}
68
69void pipe_lock(struct pipe_inode_info *pipe)
70{
71 /*
72 * pipe_lock() nests non-pipe inode locks (for writing to a file)
73 */
74 pipe_lock_nested(pipe, I_MUTEX_PARENT);
75}
76EXPORT_SYMBOL(pipe_lock);
77
78void pipe_unlock(struct pipe_inode_info *pipe)
79{
Al Viro6447a3c2013-03-21 11:01:38 -040080 if (pipe->files)
Al Viro72b0d9a2013-03-21 02:32:24 -040081 mutex_unlock(&pipe->mutex);
Miklos Szeredi61e0d472009-04-14 19:48:41 +020082}
83EXPORT_SYMBOL(pipe_unlock);
84
Al Viroebec73f2013-03-21 12:24:01 -040085static inline void __pipe_lock(struct pipe_inode_info *pipe)
86{
87 mutex_lock_nested(&pipe->mutex, I_MUTEX_PARENT);
88}
89
90static inline void __pipe_unlock(struct pipe_inode_info *pipe)
91{
92 mutex_unlock(&pipe->mutex);
93}
94
Miklos Szeredi61e0d472009-04-14 19:48:41 +020095void pipe_double_lock(struct pipe_inode_info *pipe1,
96 struct pipe_inode_info *pipe2)
97{
98 BUG_ON(pipe1 == pipe2);
99
100 if (pipe1 < pipe2) {
101 pipe_lock_nested(pipe1, I_MUTEX_PARENT);
102 pipe_lock_nested(pipe2, I_MUTEX_CHILD);
103 } else {
Peter Zijlstra023d43c2009-07-21 10:09:23 +0200104 pipe_lock_nested(pipe2, I_MUTEX_PARENT);
105 pipe_lock_nested(pipe1, I_MUTEX_CHILD);
Miklos Szeredi61e0d472009-04-14 19:48:41 +0200106 }
107}
108
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109/* Drop the inode semaphore and wait for a pipe event, atomically */
Ingo Molnar3a326a22006-04-10 15:18:35 +0200110void pipe_wait(struct pipe_inode_info *pipe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111{
112 DEFINE_WAIT(wait);
113
Ingo Molnard79fc0f2005-09-10 00:26:12 -0700114 /*
115 * Pipes are system-local resources, so sleeping on them
116 * is considered a noninteractive wait:
117 */
Mike Galbraithaf927232007-10-15 17:00:13 +0200118 prepare_to_wait(&pipe->wait, &wait, TASK_INTERRUPTIBLE);
Miklos Szeredi61e0d472009-04-14 19:48:41 +0200119 pipe_unlock(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 schedule();
Ingo Molnar3a326a22006-04-10 15:18:35 +0200121 finish_wait(&pipe->wait, &wait);
Miklos Szeredi61e0d472009-04-14 19:48:41 +0200122 pipe_lock(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123}
124
Ingo Molnar341b4462006-04-11 13:57:45 +0200125static void anon_pipe_buf_release(struct pipe_inode_info *pipe,
126 struct pipe_buffer *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127{
128 struct page *page = buf->page;
129
Jens Axboe5274f052006-03-30 15:15:30 +0200130 /*
131 * If nobody else uses this page, and we don't already have a
132 * temporary page, let's keep track of it as a one-deep
Ingo Molnar341b4462006-04-11 13:57:45 +0200133 * allocation cache. (Otherwise just release our reference to it)
Jens Axboe5274f052006-03-30 15:15:30 +0200134 */
Ingo Molnar341b4462006-04-11 13:57:45 +0200135 if (page_count(page) == 1 && !pipe->tmp_page)
Ingo Molnar923f4f22006-04-11 13:53:33 +0200136 pipe->tmp_page = page;
Ingo Molnar341b4462006-04-11 13:57:45 +0200137 else
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300138 put_page(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139}
140
Vladimir Davydovd86133b2016-07-26 15:24:33 -0700141static int anon_pipe_buf_steal(struct pipe_inode_info *pipe,
142 struct pipe_buffer *buf)
143{
144 struct page *page = buf->page;
145
146 if (page_count(page) == 1) {
Vladimir Davydovc4159a72016-08-08 23:03:12 +0300147 if (memcg_kmem_enabled())
Vladimir Davydovd86133b2016-07-26 15:24:33 -0700148 memcg_kmem_uncharge(page, 0);
Vladimir Davydovd86133b2016-07-26 15:24:33 -0700149 __SetPageLocked(page);
150 return 0;
151 }
152 return 1;
153}
154
Jens Axboe08457182007-06-12 20:51:32 +0200155/**
Randy Dunlapb51d63c2008-02-13 15:03:22 -0800156 * generic_pipe_buf_steal - attempt to take ownership of a &pipe_buffer
Jens Axboe08457182007-06-12 20:51:32 +0200157 * @pipe: the pipe that the buffer belongs to
158 * @buf: the buffer to attempt to steal
159 *
160 * Description:
Randy Dunlapb51d63c2008-02-13 15:03:22 -0800161 * This function attempts to steal the &struct page attached to
Jens Axboe08457182007-06-12 20:51:32 +0200162 * @buf. If successful, this function returns 0 and returns with
163 * the page locked. The caller may then reuse the page for whatever
Randy Dunlapb51d63c2008-02-13 15:03:22 -0800164 * he wishes; the typical use is insertion into a different file
Jens Axboe08457182007-06-12 20:51:32 +0200165 * page cache.
166 */
Jens Axboe330ab712006-05-02 15:29:57 +0200167int generic_pipe_buf_steal(struct pipe_inode_info *pipe,
168 struct pipe_buffer *buf)
Jens Axboe5abc97a2006-03-30 15:16:46 +0200169{
Jens Axboe46e678c2006-04-30 16:36:32 +0200170 struct page *page = buf->page;
171
Jens Axboe08457182007-06-12 20:51:32 +0200172 /*
173 * A reference of one is golden, that means that the owner of this
174 * page is the only one holding a reference to it. lock the page
175 * and return OK.
176 */
Jens Axboe46e678c2006-04-30 16:36:32 +0200177 if (page_count(page) == 1) {
Jens Axboe46e678c2006-04-30 16:36:32 +0200178 lock_page(page);
179 return 0;
180 }
181
182 return 1;
Jens Axboe5abc97a2006-03-30 15:16:46 +0200183}
Miklos Szeredi51921cb2010-05-26 08:44:22 +0200184EXPORT_SYMBOL(generic_pipe_buf_steal);
Jens Axboe5abc97a2006-03-30 15:16:46 +0200185
Jens Axboe08457182007-06-12 20:51:32 +0200186/**
Randy Dunlapb51d63c2008-02-13 15:03:22 -0800187 * generic_pipe_buf_get - get a reference to a &struct pipe_buffer
Jens Axboe08457182007-06-12 20:51:32 +0200188 * @pipe: the pipe that the buffer belongs to
189 * @buf: the buffer to get a reference to
190 *
191 * Description:
192 * This function grabs an extra reference to @buf. It's used in
193 * in the tee() system call, when we duplicate the buffers in one
194 * pipe into another.
195 */
196void generic_pipe_buf_get(struct pipe_inode_info *pipe, struct pipe_buffer *buf)
Jens Axboe70524492006-04-11 15:51:17 +0200197{
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300198 get_page(buf->page);
Jens Axboe70524492006-04-11 15:51:17 +0200199}
Miklos Szeredi51921cb2010-05-26 08:44:22 +0200200EXPORT_SYMBOL(generic_pipe_buf_get);
Jens Axboe70524492006-04-11 15:51:17 +0200201
Jens Axboe08457182007-06-12 20:51:32 +0200202/**
203 * generic_pipe_buf_confirm - verify contents of the pipe buffer
Randy Dunlap79685b82007-07-27 08:08:51 +0200204 * @info: the pipe that the buffer belongs to
Jens Axboe08457182007-06-12 20:51:32 +0200205 * @buf: the buffer to confirm
206 *
207 * Description:
208 * This function does nothing, because the generic pipe code uses
209 * pages that are always good when inserted into the pipe.
210 */
Jens Axboecac36bb02007-06-14 13:10:48 +0200211int generic_pipe_buf_confirm(struct pipe_inode_info *info,
212 struct pipe_buffer *buf)
Jens Axboef84d7512006-05-01 19:59:03 +0200213{
214 return 0;
215}
Miklos Szeredi51921cb2010-05-26 08:44:22 +0200216EXPORT_SYMBOL(generic_pipe_buf_confirm);
Jens Axboef84d7512006-05-01 19:59:03 +0200217
Miklos Szeredi68181732009-05-07 15:37:36 +0200218/**
219 * generic_pipe_buf_release - put a reference to a &struct pipe_buffer
220 * @pipe: the pipe that the buffer belongs to
221 * @buf: the buffer to put a reference to
222 *
223 * Description:
224 * This function releases a reference to @buf.
225 */
226void generic_pipe_buf_release(struct pipe_inode_info *pipe,
227 struct pipe_buffer *buf)
228{
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300229 put_page(buf->page);
Miklos Szeredi68181732009-05-07 15:37:36 +0200230}
Miklos Szeredi51921cb2010-05-26 08:44:22 +0200231EXPORT_SYMBOL(generic_pipe_buf_release);
Miklos Szeredi68181732009-05-07 15:37:36 +0200232
Eric Dumazetd4c3cca2006-12-13 00:34:04 -0800233static const struct pipe_buf_operations anon_pipe_buf_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 .can_merge = 1,
Jens Axboecac36bb02007-06-14 13:10:48 +0200235 .confirm = generic_pipe_buf_confirm,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 .release = anon_pipe_buf_release,
Vladimir Davydovd86133b2016-07-26 15:24:33 -0700237 .steal = anon_pipe_buf_steal,
Jens Axboef84d7512006-05-01 19:59:03 +0200238 .get = generic_pipe_buf_get,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239};
240
Linus Torvalds98830352012-04-29 13:12:42 -0700241static const struct pipe_buf_operations packet_pipe_buf_ops = {
242 .can_merge = 0,
Linus Torvalds98830352012-04-29 13:12:42 -0700243 .confirm = generic_pipe_buf_confirm,
244 .release = anon_pipe_buf_release,
Vladimir Davydovd86133b2016-07-26 15:24:33 -0700245 .steal = anon_pipe_buf_steal,
Linus Torvalds98830352012-04-29 13:12:42 -0700246 .get = generic_pipe_buf_get,
247};
248
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249static ssize_t
Al Virofb9096a2014-04-02 19:56:54 -0400250pipe_read(struct kiocb *iocb, struct iov_iter *to)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251{
Al Virofb9096a2014-04-02 19:56:54 -0400252 size_t total_len = iov_iter_count(to);
Badari Pulavartyee0b3e62006-09-30 23:28:47 -0700253 struct file *filp = iocb->ki_filp;
Al Virode32ec42013-03-21 11:16:56 -0400254 struct pipe_inode_info *pipe = filp->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 int do_wakeup;
256 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 /* Null read succeeds. */
259 if (unlikely(total_len == 0))
260 return 0;
261
262 do_wakeup = 0;
263 ret = 0;
Al Viroebec73f2013-03-21 12:24:01 -0400264 __pipe_lock(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 for (;;) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200266 int bufs = pipe->nrbufs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 if (bufs) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200268 int curbuf = pipe->curbuf;
269 struct pipe_buffer *buf = pipe->bufs + curbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 size_t chars = buf->len;
Al Viro637b58c2014-02-03 19:11:42 -0500271 size_t written;
272 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
274 if (chars > total_len)
275 chars = total_len;
276
Miklos Szeredifba597d2016-09-27 10:45:12 +0200277 error = pipe_buf_confirm(pipe, buf);
Jens Axboef84d7512006-05-01 19:59:03 +0200278 if (error) {
Jens Axboe5274f052006-03-30 15:15:30 +0200279 if (!ret)
Nicolas Kaisere5953cb2010-10-21 14:56:00 +0200280 ret = error;
Jens Axboe5274f052006-03-30 15:15:30 +0200281 break;
282 }
Jens Axboef84d7512006-05-01 19:59:03 +0200283
Al Virofb9096a2014-04-02 19:56:54 -0400284 written = copy_page_to_iter(buf->page, buf->offset, chars, to);
Al Viro637b58c2014-02-03 19:11:42 -0500285 if (unlikely(written < chars)) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200286 if (!ret)
Al Viro637b58c2014-02-03 19:11:42 -0500287 ret = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 break;
289 }
290 ret += chars;
291 buf->offset += chars;
292 buf->len -= chars;
Linus Torvalds98830352012-04-29 13:12:42 -0700293
294 /* Was it a packet buffer? Clean up and exit */
295 if (buf->flags & PIPE_BUF_FLAG_PACKET) {
296 total_len = chars;
297 buf->len = 0;
298 }
299
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 if (!buf->len) {
Miklos Szeredia7796382016-09-27 10:45:12 +0200301 pipe_buf_release(pipe, buf);
Jens Axboe35f3d142010-05-20 10:43:18 +0200302 curbuf = (curbuf + 1) & (pipe->buffers - 1);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200303 pipe->curbuf = curbuf;
304 pipe->nrbufs = --bufs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 do_wakeup = 1;
306 }
307 total_len -= chars;
308 if (!total_len)
309 break; /* common path: read succeeded */
310 }
311 if (bufs) /* More to do? */
312 continue;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200313 if (!pipe->writers)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 break;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200315 if (!pipe->waiting_writers) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 /* syscall merging: Usually we must not sleep
317 * if O_NONBLOCK is set, or if we got some data.
318 * But if a writer sleeps in kernel space, then
319 * we can wait for that data without violating POSIX.
320 */
321 if (ret)
322 break;
323 if (filp->f_flags & O_NONBLOCK) {
324 ret = -EAGAIN;
325 break;
326 }
327 }
328 if (signal_pending(current)) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200329 if (!ret)
330 ret = -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 break;
332 }
333 if (do_wakeup) {
Linus Torvalds28e58ee2011-01-20 16:21:59 -0800334 wake_up_interruptible_sync_poll(&pipe->wait, POLLOUT | POLLWRNORM);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200335 kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200337 pipe_wait(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 }
Al Viroebec73f2013-03-21 12:24:01 -0400339 __pipe_unlock(pipe);
Ingo Molnar341b4462006-04-11 13:57:45 +0200340
341 /* Signal writers asynchronously that there is more room. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 if (do_wakeup) {
Linus Torvalds28e58ee2011-01-20 16:21:59 -0800343 wake_up_interruptible_sync_poll(&pipe->wait, POLLOUT | POLLWRNORM);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200344 kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 }
346 if (ret > 0)
347 file_accessed(filp);
348 return ret;
349}
350
Linus Torvalds98830352012-04-29 13:12:42 -0700351static inline int is_packetized(struct file *file)
352{
353 return (file->f_flags & O_DIRECT) != 0;
354}
355
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356static ssize_t
Al Virof0d1bec2014-04-03 15:05:18 -0400357pipe_write(struct kiocb *iocb, struct iov_iter *from)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358{
Badari Pulavartyee0b3e62006-09-30 23:28:47 -0700359 struct file *filp = iocb->ki_filp;
Al Virode32ec42013-03-21 11:16:56 -0400360 struct pipe_inode_info *pipe = filp->private_data;
Al Virof0d1bec2014-04-03 15:05:18 -0400361 ssize_t ret = 0;
362 int do_wakeup = 0;
363 size_t total_len = iov_iter_count(from);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 ssize_t chars;
365
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 /* Null write succeeds. */
367 if (unlikely(total_len == 0))
368 return 0;
369
Al Viroebec73f2013-03-21 12:24:01 -0400370 __pipe_lock(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371
Ingo Molnar923f4f22006-04-11 13:53:33 +0200372 if (!pipe->readers) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 send_sig(SIGPIPE, current, 0);
374 ret = -EPIPE;
375 goto out;
376 }
377
378 /* We try to merge small writes */
379 chars = total_len & (PAGE_SIZE-1); /* size of the last buffer */
Ingo Molnar923f4f22006-04-11 13:53:33 +0200380 if (pipe->nrbufs && chars != 0) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200381 int lastbuf = (pipe->curbuf + pipe->nrbufs - 1) &
Jens Axboe35f3d142010-05-20 10:43:18 +0200382 (pipe->buffers - 1);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200383 struct pipe_buffer *buf = pipe->bufs + lastbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 int offset = buf->offset + buf->len;
Ingo Molnar341b4462006-04-11 13:57:45 +0200385
Miklos Szeredifba597d2016-09-27 10:45:12 +0200386 if (buf->ops->can_merge && offset + chars <= PAGE_SIZE) {
387 ret = pipe_buf_confirm(pipe, buf);
Eric Biggers6ae08062015-10-17 16:26:09 -0500388 if (ret)
Jens Axboe5274f052006-03-30 15:15:30 +0200389 goto out;
Jens Axboef84d7512006-05-01 19:59:03 +0200390
Al Virof0d1bec2014-04-03 15:05:18 -0400391 ret = copy_page_from_iter(buf->page, offset, chars, from);
392 if (unlikely(ret < chars)) {
Eric Biggers6ae08062015-10-17 16:26:09 -0500393 ret = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 goto out;
Jens Axboef6762b72006-05-01 20:02:05 +0200395 }
Al Virof0d1bec2014-04-03 15:05:18 -0400396 do_wakeup = 1;
Eric Biggers6ae08062015-10-17 16:26:09 -0500397 buf->len += ret;
Al Virof0d1bec2014-04-03 15:05:18 -0400398 if (!iov_iter_count(from))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 goto out;
400 }
401 }
402
403 for (;;) {
404 int bufs;
Ingo Molnar341b4462006-04-11 13:57:45 +0200405
Ingo Molnar923f4f22006-04-11 13:53:33 +0200406 if (!pipe->readers) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 send_sig(SIGPIPE, current, 0);
Ingo Molnar341b4462006-04-11 13:57:45 +0200408 if (!ret)
409 ret = -EPIPE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 break;
411 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200412 bufs = pipe->nrbufs;
Jens Axboe35f3d142010-05-20 10:43:18 +0200413 if (bufs < pipe->buffers) {
414 int newbuf = (pipe->curbuf + bufs) & (pipe->buffers-1);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200415 struct pipe_buffer *buf = pipe->bufs + newbuf;
416 struct page *page = pipe->tmp_page;
Al Virof0d1bec2014-04-03 15:05:18 -0400417 int copied;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
419 if (!page) {
Vladimir Davydovd86133b2016-07-26 15:24:33 -0700420 page = alloc_page(GFP_HIGHUSER | __GFP_ACCOUNT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 if (unlikely(!page)) {
422 ret = ret ? : -ENOMEM;
423 break;
424 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200425 pipe->tmp_page = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 }
Ingo Molnar341b4462006-04-11 13:57:45 +0200427 /* Always wake up, even if the copy fails. Otherwise
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 * we lock up (O_NONBLOCK-)readers that sleep due to
429 * syscall merging.
430 * FIXME! Is this really true?
431 */
432 do_wakeup = 1;
Al Virof0d1bec2014-04-03 15:05:18 -0400433 copied = copy_page_from_iter(page, 0, PAGE_SIZE, from);
434 if (unlikely(copied < PAGE_SIZE && iov_iter_count(from))) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200435 if (!ret)
Al Virof0d1bec2014-04-03 15:05:18 -0400436 ret = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 break;
438 }
Al Virof0d1bec2014-04-03 15:05:18 -0400439 ret += copied;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440
441 /* Insert it into the buffer array */
442 buf->page = page;
443 buf->ops = &anon_pipe_buf_ops;
444 buf->offset = 0;
Al Virof0d1bec2014-04-03 15:05:18 -0400445 buf->len = copied;
Linus Torvalds98830352012-04-29 13:12:42 -0700446 buf->flags = 0;
447 if (is_packetized(filp)) {
448 buf->ops = &packet_pipe_buf_ops;
449 buf->flags = PIPE_BUF_FLAG_PACKET;
450 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200451 pipe->nrbufs = ++bufs;
452 pipe->tmp_page = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
Al Virof0d1bec2014-04-03 15:05:18 -0400454 if (!iov_iter_count(from))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 break;
456 }
Jens Axboe35f3d142010-05-20 10:43:18 +0200457 if (bufs < pipe->buffers)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 continue;
459 if (filp->f_flags & O_NONBLOCK) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200460 if (!ret)
461 ret = -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 break;
463 }
464 if (signal_pending(current)) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200465 if (!ret)
466 ret = -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 break;
468 }
469 if (do_wakeup) {
Linus Torvalds28e58ee2011-01-20 16:21:59 -0800470 wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLRDNORM);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200471 kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 do_wakeup = 0;
473 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200474 pipe->waiting_writers++;
475 pipe_wait(pipe);
476 pipe->waiting_writers--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 }
478out:
Al Viroebec73f2013-03-21 12:24:01 -0400479 __pipe_unlock(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 if (do_wakeup) {
Linus Torvalds28e58ee2011-01-20 16:21:59 -0800481 wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLRDNORM);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200482 kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 }
Dmitry Monakhov7e775f42014-01-23 15:55:21 -0800484 if (ret > 0 && sb_start_write_trylock(file_inode(filp)->i_sb)) {
Josef Bacikc3b2da32012-03-26 09:59:21 -0400485 int err = file_update_time(filp);
486 if (err)
487 ret = err;
Dmitry Monakhov7e775f42014-01-23 15:55:21 -0800488 sb_end_write(file_inode(filp)->i_sb);
Josef Bacikc3b2da32012-03-26 09:59:21 -0400489 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 return ret;
491}
492
Andi Kleend59d0b12008-02-08 04:21:23 -0800493static long pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494{
Al Virode32ec42013-03-21 11:16:56 -0400495 struct pipe_inode_info *pipe = filp->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 int count, buf, nrbufs;
497
498 switch (cmd) {
499 case FIONREAD:
Al Viroebec73f2013-03-21 12:24:01 -0400500 __pipe_lock(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 count = 0;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200502 buf = pipe->curbuf;
503 nrbufs = pipe->nrbufs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 while (--nrbufs >= 0) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200505 count += pipe->bufs[buf].len;
Jens Axboe35f3d142010-05-20 10:43:18 +0200506 buf = (buf+1) & (pipe->buffers - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 }
Al Viroebec73f2013-03-21 12:24:01 -0400508 __pipe_unlock(pipe);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200509
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 return put_user(count, (int __user *)arg);
511 default:
Will Deacon46ce3412012-05-25 11:39:13 +0100512 return -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 }
514}
515
516/* No kernel lock held - fine */
517static unsigned int
518pipe_poll(struct file *filp, poll_table *wait)
519{
520 unsigned int mask;
Al Virode32ec42013-03-21 11:16:56 -0400521 struct pipe_inode_info *pipe = filp->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 int nrbufs;
523
Ingo Molnar923f4f22006-04-11 13:53:33 +0200524 poll_wait(filp, &pipe->wait, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
526 /* Reading only -- no need for acquiring the semaphore. */
Ingo Molnar923f4f22006-04-11 13:53:33 +0200527 nrbufs = pipe->nrbufs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 mask = 0;
529 if (filp->f_mode & FMODE_READ) {
530 mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200531 if (!pipe->writers && filp->f_version != pipe->w_counter)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 mask |= POLLHUP;
533 }
534
535 if (filp->f_mode & FMODE_WRITE) {
Jens Axboe35f3d142010-05-20 10:43:18 +0200536 mask |= (nrbufs < pipe->buffers) ? POLLOUT | POLLWRNORM : 0;
Pekka Enberg5e5d7a22005-09-06 15:17:48 -0700537 /*
538 * Most Unices do not set POLLERR for FIFOs but on Linux they
539 * behave exactly like pipes for poll().
540 */
Ingo Molnar923f4f22006-04-11 13:53:33 +0200541 if (!pipe->readers)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 mask |= POLLERR;
543 }
544
545 return mask;
546}
547
Linus Torvaldsb0d8d222013-12-02 09:44:51 -0800548static void put_pipe_info(struct inode *inode, struct pipe_inode_info *pipe)
549{
550 int kill = 0;
551
552 spin_lock(&inode->i_lock);
553 if (!--pipe->files) {
554 inode->i_pipe = NULL;
555 kill = 1;
556 }
557 spin_unlock(&inode->i_lock);
558
559 if (kill)
560 free_pipe_info(pipe);
561}
562
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563static int
Al Viro599a0ac2013-03-12 09:58:10 -0400564pipe_release(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565{
Linus Torvaldsb0d8d222013-12-02 09:44:51 -0800566 struct pipe_inode_info *pipe = file->private_data;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200567
Al Viroebec73f2013-03-21 12:24:01 -0400568 __pipe_lock(pipe);
Al Viro599a0ac2013-03-12 09:58:10 -0400569 if (file->f_mode & FMODE_READ)
570 pipe->readers--;
571 if (file->f_mode & FMODE_WRITE)
572 pipe->writers--;
Ingo Molnar341b4462006-04-11 13:57:45 +0200573
Al Viroba5bb142013-03-21 02:21:19 -0400574 if (pipe->readers || pipe->writers) {
Linus Torvalds28e58ee2011-01-20 16:21:59 -0800575 wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM | POLLERR | POLLHUP);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200576 kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
577 kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 }
Al Viroebec73f2013-03-21 12:24:01 -0400579 __pipe_unlock(pipe);
Al Viroba5bb142013-03-21 02:21:19 -0400580
Linus Torvaldsb0d8d222013-12-02 09:44:51 -0800581 put_pipe_info(inode, pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 return 0;
583}
584
585static int
Al Viro599a0ac2013-03-12 09:58:10 -0400586pipe_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587{
Al Virode32ec42013-03-21 11:16:56 -0400588 struct pipe_inode_info *pipe = filp->private_data;
Al Viro599a0ac2013-03-12 09:58:10 -0400589 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
Al Viroebec73f2013-03-21 12:24:01 -0400591 __pipe_lock(pipe);
Al Viro599a0ac2013-03-12 09:58:10 -0400592 if (filp->f_mode & FMODE_READ)
593 retval = fasync_helper(fd, filp, on, &pipe->fasync_readers);
594 if ((filp->f_mode & FMODE_WRITE) && retval >= 0) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200595 retval = fasync_helper(fd, filp, on, &pipe->fasync_writers);
Al Viro599a0ac2013-03-12 09:58:10 -0400596 if (retval < 0 && (filp->f_mode & FMODE_READ))
597 /* this can happen only if on == T */
Oleg Nesterove5bc49b2009-03-12 14:31:28 -0700598 fasync_helper(-1, filp, 0, &pipe->fasync_readers);
599 }
Al Viroebec73f2013-03-21 12:24:01 -0400600 __pipe_unlock(pipe);
Jonathan Corbet60aa4922009-02-01 14:52:56 -0700601 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602}
603
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700604static unsigned long account_pipe_buffers(struct user_struct *user,
Willy Tarreau759c0112016-01-18 16:36:09 +0100605 unsigned long old, unsigned long new)
606{
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700607 return atomic_long_add_return(new - old, &user->pipe_bufs);
Willy Tarreau759c0112016-01-18 16:36:09 +0100608}
609
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700610static bool too_many_pipe_buffers_soft(unsigned long user_bufs)
Willy Tarreau759c0112016-01-18 16:36:09 +0100611{
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700612 return pipe_user_pages_soft && user_bufs >= pipe_user_pages_soft;
Willy Tarreau759c0112016-01-18 16:36:09 +0100613}
614
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700615static bool too_many_pipe_buffers_hard(unsigned long user_bufs)
Willy Tarreau759c0112016-01-18 16:36:09 +0100616{
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700617 return pipe_user_pages_hard && user_bufs >= pipe_user_pages_hard;
Willy Tarreau759c0112016-01-18 16:36:09 +0100618}
619
Al Viro7bee1302013-03-21 11:04:15 -0400620struct pipe_inode_info *alloc_pipe_info(void)
Ingo Molnar3a326a22006-04-10 15:18:35 +0200621{
Ingo Molnar923f4f22006-04-11 13:53:33 +0200622 struct pipe_inode_info *pipe;
Michael Kerrisk (man-pages)09b4d192016-10-11 13:53:34 -0700623 unsigned long pipe_bufs = PIPE_DEF_BUFFERS;
624 struct user_struct *user = get_current_user();
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700625 unsigned long user_bufs;
Ingo Molnar3a326a22006-04-10 15:18:35 +0200626
Vladimir Davydovd86133b2016-07-26 15:24:33 -0700627 pipe = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL_ACCOUNT);
Michael Kerrisk (man-pages)09b4d192016-10-11 13:53:34 -0700628 if (pipe == NULL)
629 goto out_free_uid;
Willy Tarreau759c0112016-01-18 16:36:09 +0100630
Michael Kerrisk (man-pages)086e7742016-10-11 13:53:43 -0700631 if (pipe_bufs * PAGE_SIZE > pipe_max_size && !capable(CAP_SYS_RESOURCE))
632 pipe_bufs = pipe_max_size >> PAGE_SHIFT;
633
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700634 user_bufs = account_pipe_buffers(user, 0, pipe_bufs);
Michael Kerrisk (man-pages)a005ca02016-10-11 13:53:37 -0700635
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700636 if (too_many_pipe_buffers_soft(user_bufs)) {
637 user_bufs = account_pipe_buffers(user, pipe_bufs, 1);
Michael Kerrisk (man-pages)a005ca02016-10-11 13:53:37 -0700638 pipe_bufs = 1;
Ingo Molnar3a326a22006-04-10 15:18:35 +0200639 }
640
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700641 if (too_many_pipe_buffers_hard(user_bufs))
Michael Kerrisk (man-pages)a005ca02016-10-11 13:53:37 -0700642 goto out_revert_acct;
643
644 pipe->bufs = kcalloc(pipe_bufs, sizeof(struct pipe_buffer),
645 GFP_KERNEL_ACCOUNT);
646
Michael Kerrisk (man-pages)09b4d192016-10-11 13:53:34 -0700647 if (pipe->bufs) {
648 init_waitqueue_head(&pipe->wait);
649 pipe->r_counter = pipe->w_counter = 1;
650 pipe->buffers = pipe_bufs;
651 pipe->user = user;
Michael Kerrisk (man-pages)09b4d192016-10-11 13:53:34 -0700652 mutex_init(&pipe->mutex);
653 return pipe;
654 }
655
Michael Kerrisk (man-pages)a005ca02016-10-11 13:53:37 -0700656out_revert_acct:
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700657 (void) account_pipe_buffers(user, pipe_bufs, 0);
Michael Kerrisk (man-pages)09b4d192016-10-11 13:53:34 -0700658 kfree(pipe);
659out_free_uid:
660 free_uid(user);
Jens Axboe35f3d142010-05-20 10:43:18 +0200661 return NULL;
Ingo Molnar3a326a22006-04-10 15:18:35 +0200662}
663
Al Viro4b8a8f12013-03-21 11:06:46 -0400664void free_pipe_info(struct pipe_inode_info *pipe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665{
666 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700668 (void) account_pipe_buffers(pipe->user, pipe->buffers, 0);
Willy Tarreau759c0112016-01-18 16:36:09 +0100669 free_uid(pipe->user);
Jens Axboe35f3d142010-05-20 10:43:18 +0200670 for (i = 0; i < pipe->buffers; i++) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200671 struct pipe_buffer *buf = pipe->bufs + i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 if (buf->ops)
Miklos Szeredia7796382016-09-27 10:45:12 +0200673 pipe_buf_release(pipe, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200675 if (pipe->tmp_page)
676 __free_page(pipe->tmp_page);
Jens Axboe35f3d142010-05-20 10:43:18 +0200677 kfree(pipe->bufs);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200678 kfree(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679}
680
Eric Dumazetfa3536c2006-03-26 01:37:24 -0800681static struct vfsmount *pipe_mnt __read_mostly;
Ingo Molnar341b4462006-04-11 13:57:45 +0200682
Eric Dumazetc23fbb62007-05-08 00:26:18 -0700683/*
684 * pipefs_dname() is called from d_path().
685 */
686static char *pipefs_dname(struct dentry *dentry, char *buffer, int buflen)
687{
688 return dynamic_dname(dentry, buffer, buflen, "pipe:[%lu]",
David Howells75c3cfa2015-03-17 22:26:12 +0000689 d_inode(dentry)->i_ino);
Eric Dumazetc23fbb62007-05-08 00:26:18 -0700690}
691
Al Viro3ba13d12009-02-20 06:02:22 +0000692static const struct dentry_operations pipefs_dentry_operations = {
Eric Dumazetc23fbb62007-05-08 00:26:18 -0700693 .d_dname = pipefs_dname,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694};
695
696static struct inode * get_pipe_inode(void)
697{
Eric Dumazeta209dfc2011-07-26 11:36:34 +0200698 struct inode *inode = new_inode_pseudo(pipe_mnt->mnt_sb);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200699 struct pipe_inode_info *pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700
701 if (!inode)
702 goto fail_inode;
703
Christoph Hellwig85fe4022010-10-23 11:19:54 -0400704 inode->i_ino = get_next_ino();
705
Al Viro7bee1302013-03-21 11:04:15 -0400706 pipe = alloc_pipe_info();
Ingo Molnar923f4f22006-04-11 13:53:33 +0200707 if (!pipe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 goto fail_iput;
Ingo Molnar3a326a22006-04-10 15:18:35 +0200709
Al Viroba5bb142013-03-21 02:21:19 -0400710 inode->i_pipe = pipe;
711 pipe->files = 2;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200712 pipe->readers = pipe->writers = 1;
Al Viro599a0ac2013-03-12 09:58:10 -0400713 inode->i_fop = &pipefifo_fops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
715 /*
716 * Mark the inode dirty from the very beginning,
717 * that way it will never be moved to the dirty
718 * list because "mark_inode_dirty()" will think
719 * that it already _is_ on the dirty list.
720 */
721 inode->i_state = I_DIRTY;
722 inode->i_mode = S_IFIFO | S_IRUSR | S_IWUSR;
David Howellsda9592e2008-11-14 10:39:05 +1100723 inode->i_uid = current_fsuid();
724 inode->i_gid = current_fsgid();
Deepa Dinamani078cd822016-09-14 07:48:04 -0700725 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200726
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 return inode;
728
729fail_iput:
730 iput(inode);
Ingo Molnar341b4462006-04-11 13:57:45 +0200731
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732fail_inode:
733 return NULL;
734}
735
Al Viroe4fad8e2012-07-21 15:33:25 +0400736int create_pipe_files(struct file **res, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737{
Andi Kleend6cbd282006-09-30 23:29:26 -0700738 int err;
Al Viroe4fad8e2012-07-21 15:33:25 +0400739 struct inode *inode = get_pipe_inode();
Andi Kleend6cbd282006-09-30 23:29:26 -0700740 struct file *f;
Al Viro2c48b9c2009-08-09 00:52:35 +0400741 struct path path;
Al Viroe4fad8e2012-07-21 15:33:25 +0400742 static struct qstr name = { .name = "" };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 if (!inode)
Al Viroe4fad8e2012-07-21 15:33:25 +0400745 return -ENFILE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746
Andi Kleend6cbd282006-09-30 23:29:26 -0700747 err = -ENOMEM;
Nick Piggin4b936882011-01-07 17:50:07 +1100748 path.dentry = d_alloc_pseudo(pipe_mnt->mnt_sb, &name);
Al Viro2c48b9c2009-08-09 00:52:35 +0400749 if (!path.dentry)
Andi Kleend6cbd282006-09-30 23:29:26 -0700750 goto err_inode;
Al Viro2c48b9c2009-08-09 00:52:35 +0400751 path.mnt = mntget(pipe_mnt);
Ingo Molnar341b4462006-04-11 13:57:45 +0200752
Al Viro2c48b9c2009-08-09 00:52:35 +0400753 d_instantiate(path.dentry, inode);
Dave Hansen430e2852008-02-15 14:37:26 -0800754
Al Viro599a0ac2013-03-12 09:58:10 -0400755 f = alloc_file(&path, FMODE_WRITE, &pipefifo_fops);
Eric Biggerse9bb1f92015-10-17 16:26:08 -0500756 if (IS_ERR(f)) {
757 err = PTR_ERR(f);
Dave Hansen430e2852008-02-15 14:37:26 -0800758 goto err_dentry;
Eric Biggerse9bb1f92015-10-17 16:26:08 -0500759 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
Linus Torvalds98830352012-04-29 13:12:42 -0700761 f->f_flags = O_WRONLY | (flags & (O_NONBLOCK | O_DIRECT));
Al Virode32ec42013-03-21 11:16:56 -0400762 f->private_data = inode->i_pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
Al Viro599a0ac2013-03-12 09:58:10 -0400764 res[0] = alloc_file(&path, FMODE_READ, &pipefifo_fops);
Eric Biggerse9bb1f92015-10-17 16:26:08 -0500765 if (IS_ERR(res[0])) {
766 err = PTR_ERR(res[0]);
Al Viroe4fad8e2012-07-21 15:33:25 +0400767 goto err_file;
Eric Biggerse9bb1f92015-10-17 16:26:08 -0500768 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769
Al Viroe4fad8e2012-07-21 15:33:25 +0400770 path_get(&path);
Al Virode32ec42013-03-21 11:16:56 -0400771 res[0]->private_data = inode->i_pipe;
Al Viroe4fad8e2012-07-21 15:33:25 +0400772 res[0]->f_flags = O_RDONLY | (flags & O_NONBLOCK);
773 res[1] = f;
774 return 0;
775
776err_file:
777 put_filp(f);
778err_dentry:
Al Viro4b8a8f12013-03-21 11:06:46 -0400779 free_pipe_info(inode->i_pipe);
Al Viro2c48b9c2009-08-09 00:52:35 +0400780 path_put(&path);
Al Viroe4fad8e2012-07-21 15:33:25 +0400781 return err;
Al Viroed152432008-04-22 19:51:27 -0400782
Al Viroe4fad8e2012-07-21 15:33:25 +0400783err_inode:
Al Viro4b8a8f12013-03-21 11:06:46 -0400784 free_pipe_info(inode->i_pipe);
Andi Kleend6cbd282006-09-30 23:29:26 -0700785 iput(inode);
Al Viroe4fad8e2012-07-21 15:33:25 +0400786 return err;
Andi Kleend6cbd282006-09-30 23:29:26 -0700787}
788
Al Viro5b249b12012-08-19 12:17:29 -0400789static int __do_pipe_flags(int *fd, struct file **files, int flags)
Andi Kleend6cbd282006-09-30 23:29:26 -0700790{
Andi Kleend6cbd282006-09-30 23:29:26 -0700791 int error;
792 int fdw, fdr;
793
Linus Torvalds98830352012-04-29 13:12:42 -0700794 if (flags & ~(O_CLOEXEC | O_NONBLOCK | O_DIRECT))
Ulrich Dreppered8cae82008-07-23 21:29:30 -0700795 return -EINVAL;
796
Al Viroe4fad8e2012-07-21 15:33:25 +0400797 error = create_pipe_files(files, flags);
798 if (error)
799 return error;
Andi Kleend6cbd282006-09-30 23:29:26 -0700800
Ulrich Dreppered8cae82008-07-23 21:29:30 -0700801 error = get_unused_fd_flags(flags);
Andi Kleend6cbd282006-09-30 23:29:26 -0700802 if (error < 0)
803 goto err_read_pipe;
804 fdr = error;
805
Ulrich Dreppered8cae82008-07-23 21:29:30 -0700806 error = get_unused_fd_flags(flags);
Andi Kleend6cbd282006-09-30 23:29:26 -0700807 if (error < 0)
808 goto err_fdr;
809 fdw = error;
810
Al Viro157cf642008-12-14 04:57:47 -0500811 audit_fd_pair(fdr, fdw);
Andi Kleend6cbd282006-09-30 23:29:26 -0700812 fd[0] = fdr;
813 fd[1] = fdw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 return 0;
815
Andi Kleend6cbd282006-09-30 23:29:26 -0700816 err_fdr:
817 put_unused_fd(fdr);
818 err_read_pipe:
Al Viroe4fad8e2012-07-21 15:33:25 +0400819 fput(files[0]);
820 fput(files[1]);
Andi Kleend6cbd282006-09-30 23:29:26 -0700821 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822}
823
Al Viro5b249b12012-08-19 12:17:29 -0400824int do_pipe_flags(int *fd, int flags)
825{
826 struct file *files[2];
827 int error = __do_pipe_flags(fd, files, flags);
828 if (!error) {
829 fd_install(fd[0], files[0]);
830 fd_install(fd[1], files[1]);
831 }
832 return error;
833}
834
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835/*
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400836 * sys_pipe() is the normal C calling standard for creating
837 * a pipe. It's not the way Unix traditionally does this, though.
838 */
Heiko Carstensd4e82042009-01-14 14:14:34 +0100839SYSCALL_DEFINE2(pipe2, int __user *, fildes, int, flags)
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400840{
Al Viro5b249b12012-08-19 12:17:29 -0400841 struct file *files[2];
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400842 int fd[2];
843 int error;
844
Al Viro5b249b12012-08-19 12:17:29 -0400845 error = __do_pipe_flags(fd, files, flags);
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400846 if (!error) {
Al Viro5b249b12012-08-19 12:17:29 -0400847 if (unlikely(copy_to_user(fildes, fd, sizeof(fd)))) {
848 fput(files[0]);
849 fput(files[1]);
850 put_unused_fd(fd[0]);
851 put_unused_fd(fd[1]);
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400852 error = -EFAULT;
Al Viro5b249b12012-08-19 12:17:29 -0400853 } else {
854 fd_install(fd[0], files[0]);
855 fd_install(fd[1], files[1]);
Ulrich Drepperba719ba2008-05-06 20:42:38 -0700856 }
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400857 }
858 return error;
859}
860
Heiko Carstens2b664212009-01-14 14:14:35 +0100861SYSCALL_DEFINE1(pipe, int __user *, fildes)
Ulrich Dreppered8cae82008-07-23 21:29:30 -0700862{
863 return sys_pipe2(fildes, 0);
864}
865
Al Virofc7478a2013-03-21 02:07:59 -0400866static int wait_for_partner(struct pipe_inode_info *pipe, unsigned int *cnt)
Al Virof776c732013-03-12 09:46:27 -0400867{
868 int cur = *cnt;
869
870 while (cur == *cnt) {
Al Virofc7478a2013-03-21 02:07:59 -0400871 pipe_wait(pipe);
Al Virof776c732013-03-12 09:46:27 -0400872 if (signal_pending(current))
873 break;
874 }
875 return cur == *cnt ? -ERESTARTSYS : 0;
876}
877
Al Virofc7478a2013-03-21 02:07:59 -0400878static void wake_up_partner(struct pipe_inode_info *pipe)
Al Virof776c732013-03-12 09:46:27 -0400879{
Al Virofc7478a2013-03-21 02:07:59 -0400880 wake_up_interruptible(&pipe->wait);
Al Virof776c732013-03-12 09:46:27 -0400881}
882
883static int fifo_open(struct inode *inode, struct file *filp)
884{
885 struct pipe_inode_info *pipe;
Al Viro599a0ac2013-03-12 09:58:10 -0400886 bool is_pipe = inode->i_sb->s_magic == PIPEFS_MAGIC;
Al Virof776c732013-03-12 09:46:27 -0400887 int ret;
888
Al Viroba5bb142013-03-21 02:21:19 -0400889 filp->f_version = 0;
890
891 spin_lock(&inode->i_lock);
892 if (inode->i_pipe) {
893 pipe = inode->i_pipe;
894 pipe->files++;
895 spin_unlock(&inode->i_lock);
896 } else {
897 spin_unlock(&inode->i_lock);
Al Viro7bee1302013-03-21 11:04:15 -0400898 pipe = alloc_pipe_info();
Al Virof776c732013-03-12 09:46:27 -0400899 if (!pipe)
Al Viroba5bb142013-03-21 02:21:19 -0400900 return -ENOMEM;
901 pipe->files = 1;
902 spin_lock(&inode->i_lock);
903 if (unlikely(inode->i_pipe)) {
904 inode->i_pipe->files++;
905 spin_unlock(&inode->i_lock);
Al Viro4b8a8f12013-03-21 11:06:46 -0400906 free_pipe_info(pipe);
Al Viroba5bb142013-03-21 02:21:19 -0400907 pipe = inode->i_pipe;
908 } else {
909 inode->i_pipe = pipe;
910 spin_unlock(&inode->i_lock);
911 }
Al Virof776c732013-03-12 09:46:27 -0400912 }
Al Virode32ec42013-03-21 11:16:56 -0400913 filp->private_data = pipe;
Al Viroba5bb142013-03-21 02:21:19 -0400914 /* OK, we have a pipe and it's pinned down */
915
Al Viroebec73f2013-03-21 12:24:01 -0400916 __pipe_lock(pipe);
Al Virof776c732013-03-12 09:46:27 -0400917
918 /* We can only do regular read/write on fifos */
919 filp->f_mode &= (FMODE_READ | FMODE_WRITE);
920
921 switch (filp->f_mode) {
922 case FMODE_READ:
923 /*
924 * O_RDONLY
925 * POSIX.1 says that O_NONBLOCK means return with the FIFO
926 * opened, even when there is no process writing the FIFO.
927 */
Al Virof776c732013-03-12 09:46:27 -0400928 pipe->r_counter++;
929 if (pipe->readers++ == 0)
Al Virofc7478a2013-03-21 02:07:59 -0400930 wake_up_partner(pipe);
Al Virof776c732013-03-12 09:46:27 -0400931
Al Viro599a0ac2013-03-12 09:58:10 -0400932 if (!is_pipe && !pipe->writers) {
Al Virof776c732013-03-12 09:46:27 -0400933 if ((filp->f_flags & O_NONBLOCK)) {
934 /* suppress POLLHUP until we have
935 * seen a writer */
936 filp->f_version = pipe->w_counter;
937 } else {
Al Virofc7478a2013-03-21 02:07:59 -0400938 if (wait_for_partner(pipe, &pipe->w_counter))
Al Virof776c732013-03-12 09:46:27 -0400939 goto err_rd;
940 }
941 }
942 break;
943
944 case FMODE_WRITE:
945 /*
946 * O_WRONLY
947 * POSIX.1 says that O_NONBLOCK means return -1 with
948 * errno=ENXIO when there is no process reading the FIFO.
949 */
950 ret = -ENXIO;
Al Viro599a0ac2013-03-12 09:58:10 -0400951 if (!is_pipe && (filp->f_flags & O_NONBLOCK) && !pipe->readers)
Al Virof776c732013-03-12 09:46:27 -0400952 goto err;
953
Al Virof776c732013-03-12 09:46:27 -0400954 pipe->w_counter++;
955 if (!pipe->writers++)
Al Virofc7478a2013-03-21 02:07:59 -0400956 wake_up_partner(pipe);
Al Virof776c732013-03-12 09:46:27 -0400957
Al Viro599a0ac2013-03-12 09:58:10 -0400958 if (!is_pipe && !pipe->readers) {
Al Virofc7478a2013-03-21 02:07:59 -0400959 if (wait_for_partner(pipe, &pipe->r_counter))
Al Virof776c732013-03-12 09:46:27 -0400960 goto err_wr;
961 }
962 break;
963
964 case FMODE_READ | FMODE_WRITE:
965 /*
966 * O_RDWR
967 * POSIX.1 leaves this case "undefined" when O_NONBLOCK is set.
968 * This implementation will NEVER block on a O_RDWR open, since
969 * the process can at least talk to itself.
970 */
Al Virof776c732013-03-12 09:46:27 -0400971
972 pipe->readers++;
973 pipe->writers++;
974 pipe->r_counter++;
975 pipe->w_counter++;
976 if (pipe->readers == 1 || pipe->writers == 1)
Al Virofc7478a2013-03-21 02:07:59 -0400977 wake_up_partner(pipe);
Al Virof776c732013-03-12 09:46:27 -0400978 break;
979
980 default:
981 ret = -EINVAL;
982 goto err;
983 }
984
985 /* Ok! */
Al Viroebec73f2013-03-21 12:24:01 -0400986 __pipe_unlock(pipe);
Al Virof776c732013-03-12 09:46:27 -0400987 return 0;
988
989err_rd:
990 if (!--pipe->readers)
991 wake_up_interruptible(&pipe->wait);
992 ret = -ERESTARTSYS;
993 goto err;
994
995err_wr:
996 if (!--pipe->writers)
997 wake_up_interruptible(&pipe->wait);
998 ret = -ERESTARTSYS;
999 goto err;
1000
1001err:
Al Viroebec73f2013-03-21 12:24:01 -04001002 __pipe_unlock(pipe);
Linus Torvaldsb0d8d222013-12-02 09:44:51 -08001003
1004 put_pipe_info(inode, pipe);
Al Virof776c732013-03-12 09:46:27 -04001005 return ret;
1006}
1007
Al Viro599a0ac2013-03-12 09:58:10 -04001008const struct file_operations pipefifo_fops = {
1009 .open = fifo_open,
1010 .llseek = no_llseek,
Al Virofb9096a2014-04-02 19:56:54 -04001011 .read_iter = pipe_read,
Al Virof0d1bec2014-04-03 15:05:18 -04001012 .write_iter = pipe_write,
Al Viro599a0ac2013-03-12 09:58:10 -04001013 .poll = pipe_poll,
1014 .unlocked_ioctl = pipe_ioctl,
1015 .release = pipe_release,
1016 .fasync = pipe_fasync,
Al Virof776c732013-03-12 09:46:27 -04001017};
1018
Ulrich Drepperd35c7b02008-05-03 15:10:37 -04001019/*
Michael Kerrisk (man-pages)f491bd72016-10-11 13:53:22 -07001020 * Currently we rely on the pipe array holding a power-of-2 number
Joe Lawrence5b13f592017-11-17 15:29:21 -08001021 * of pages. Returns 0 on error.
Michael Kerrisk (man-pages)f491bd72016-10-11 13:53:22 -07001022 */
1023static inline unsigned int round_pipe_size(unsigned int size)
1024{
1025 unsigned long nr_pages;
1026
Joe Lawrence5b13f592017-11-17 15:29:21 -08001027 if (size < pipe_min_size)
1028 size = pipe_min_size;
1029
Michael Kerrisk (man-pages)f491bd72016-10-11 13:53:22 -07001030 nr_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
Joe Lawrence5b13f592017-11-17 15:29:21 -08001031 if (nr_pages == 0)
1032 return 0;
1033
Michael Kerrisk (man-pages)f491bd72016-10-11 13:53:22 -07001034 return roundup_pow_of_two(nr_pages) << PAGE_SHIFT;
1035}
1036
1037/*
Jens Axboe35f3d142010-05-20 10:43:18 +02001038 * Allocate a new array of pipe buffers and copy the info over. Returns the
1039 * pipe size if successful, or return -ERROR on error.
1040 */
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001041static long pipe_set_size(struct pipe_inode_info *pipe, unsigned long arg)
Jens Axboe35f3d142010-05-20 10:43:18 +02001042{
1043 struct pipe_buffer *bufs;
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001044 unsigned int size, nr_pages;
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -07001045 unsigned long user_bufs;
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001046 long ret = 0;
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001047
1048 size = round_pipe_size(arg);
Joe Lawrence5b13f592017-11-17 15:29:21 -08001049 if (size == 0)
1050 return -EINVAL;
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001051 nr_pages = size >> PAGE_SHIFT;
1052
1053 if (!nr_pages)
1054 return -EINVAL;
1055
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001056 /*
1057 * If trying to increase the pipe capacity, check that an
1058 * unprivileged user is not trying to exceed various limits
1059 * (soft limit check here, hard limit check just below).
1060 * Decreasing the pipe capacity is always permitted, even
1061 * if the user is currently over a limit.
1062 */
1063 if (nr_pages > pipe->buffers &&
1064 size > pipe_max_size && !capable(CAP_SYS_RESOURCE))
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001065 return -EPERM;
1066
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -07001067 user_bufs = account_pipe_buffers(pipe->user, pipe->buffers, nr_pages);
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001068
1069 if (nr_pages > pipe->buffers &&
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -07001070 (too_many_pipe_buffers_hard(user_bufs) ||
1071 too_many_pipe_buffers_soft(user_bufs)) &&
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001072 !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN)) {
1073 ret = -EPERM;
1074 goto out_revert_acct;
1075 }
Jens Axboe35f3d142010-05-20 10:43:18 +02001076
1077 /*
Jens Axboe35f3d142010-05-20 10:43:18 +02001078 * We can shrink the pipe, if arg >= pipe->nrbufs. Since we don't
1079 * expect a lot of shrink+grow operations, just free and allocate
1080 * again like we would do for growing. If the pipe currently
1081 * contains more buffers than arg, then return busy.
1082 */
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001083 if (nr_pages < pipe->nrbufs) {
1084 ret = -EBUSY;
1085 goto out_revert_acct;
1086 }
Jens Axboe35f3d142010-05-20 10:43:18 +02001087
Vladimir Davydovd86133b2016-07-26 15:24:33 -07001088 bufs = kcalloc(nr_pages, sizeof(*bufs),
1089 GFP_KERNEL_ACCOUNT | __GFP_NOWARN);
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001090 if (unlikely(!bufs)) {
1091 ret = -ENOMEM;
1092 goto out_revert_acct;
1093 }
Jens Axboe35f3d142010-05-20 10:43:18 +02001094
1095 /*
1096 * The pipe array wraps around, so just start the new one at zero
1097 * and adjust the indexes.
1098 */
1099 if (pipe->nrbufs) {
Miklos Szeredi1d862f42010-06-08 16:28:45 +02001100 unsigned int tail;
1101 unsigned int head;
Jens Axboe35f3d142010-05-20 10:43:18 +02001102
Miklos Szeredi1d862f42010-06-08 16:28:45 +02001103 tail = pipe->curbuf + pipe->nrbufs;
1104 if (tail < pipe->buffers)
1105 tail = 0;
1106 else
1107 tail &= (pipe->buffers - 1);
1108
1109 head = pipe->nrbufs - tail;
Jens Axboe35f3d142010-05-20 10:43:18 +02001110 if (head)
1111 memcpy(bufs, pipe->bufs + pipe->curbuf, head * sizeof(struct pipe_buffer));
1112 if (tail)
Miklos Szeredi1d862f42010-06-08 16:28:45 +02001113 memcpy(bufs + head, pipe->bufs, tail * sizeof(struct pipe_buffer));
Jens Axboe35f3d142010-05-20 10:43:18 +02001114 }
1115
1116 pipe->curbuf = 0;
1117 kfree(pipe->bufs);
1118 pipe->bufs = bufs;
Jens Axboeb9598db2010-05-24 19:34:43 +02001119 pipe->buffers = nr_pages;
1120 return nr_pages * PAGE_SIZE;
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001121
1122out_revert_acct:
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -07001123 (void) account_pipe_buffers(pipe->user, nr_pages, pipe->buffers);
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001124 return ret;
Jens Axboe35f3d142010-05-20 10:43:18 +02001125}
1126
Jens Axboeff9da692010-06-03 14:54:39 +02001127/*
Jens Axboeff9da692010-06-03 14:54:39 +02001128 * This should work even if CONFIG_PROC_FS isn't set, as proc_dointvec_minmax
1129 * will return an error.
1130 */
1131int pipe_proc_fn(struct ctl_table *table, int write, void __user *buf,
1132 size_t *lenp, loff_t *ppos)
1133{
Joe Lawrence5b13f592017-11-17 15:29:21 -08001134 unsigned int rounded_pipe_max_size;
Jens Axboeff9da692010-06-03 14:54:39 +02001135 int ret;
1136
1137 ret = proc_dointvec_minmax(table, write, buf, lenp, ppos);
1138 if (ret < 0 || !write)
1139 return ret;
1140
Joe Lawrence5b13f592017-11-17 15:29:21 -08001141 rounded_pipe_max_size = round_pipe_size(pipe_max_size);
1142 if (rounded_pipe_max_size == 0)
1143 return -EINVAL;
1144
1145 pipe_max_size = rounded_pipe_max_size;
Jens Axboeff9da692010-06-03 14:54:39 +02001146 return ret;
1147}
1148
Linus Torvalds72083642010-11-28 16:27:19 -08001149/*
1150 * After the inode slimming patch, i_pipe/i_bdev/i_cdev share the same
1151 * location, so checking ->i_pipe is not enough to verify that this is a
1152 * pipe.
1153 */
1154struct pipe_inode_info *get_pipe_info(struct file *file)
1155{
Al Virode32ec42013-03-21 11:16:56 -04001156 return file->f_op == &pipefifo_fops ? file->private_data : NULL;
Linus Torvalds72083642010-11-28 16:27:19 -08001157}
1158
Jens Axboe35f3d142010-05-20 10:43:18 +02001159long pipe_fcntl(struct file *file, unsigned int cmd, unsigned long arg)
1160{
1161 struct pipe_inode_info *pipe;
1162 long ret;
1163
Linus Torvaldsc66fb342010-11-28 14:09:57 -08001164 pipe = get_pipe_info(file);
Jens Axboe35f3d142010-05-20 10:43:18 +02001165 if (!pipe)
1166 return -EBADF;
1167
Al Viroebec73f2013-03-21 12:24:01 -04001168 __pipe_lock(pipe);
Jens Axboe35f3d142010-05-20 10:43:18 +02001169
1170 switch (cmd) {
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001171 case F_SETPIPE_SZ:
1172 ret = pipe_set_size(pipe, arg);
Jens Axboe35f3d142010-05-20 10:43:18 +02001173 break;
1174 case F_GETPIPE_SZ:
Jens Axboeb9598db2010-05-24 19:34:43 +02001175 ret = pipe->buffers * PAGE_SIZE;
Jens Axboe35f3d142010-05-20 10:43:18 +02001176 break;
1177 default:
1178 ret = -EINVAL;
1179 break;
1180 }
1181
Al Viroebec73f2013-03-21 12:24:01 -04001182 __pipe_unlock(pipe);
Jens Axboe35f3d142010-05-20 10:43:18 +02001183 return ret;
1184}
1185
Nick Pigginff0c7d12011-01-07 17:49:50 +11001186static const struct super_operations pipefs_ops = {
1187 .destroy_inode = free_inode_nonrcu,
Pavel Emelyanovd70ef972011-10-31 17:10:04 -07001188 .statfs = simple_statfs,
Nick Pigginff0c7d12011-01-07 17:49:50 +11001189};
1190
Jens Axboe35f3d142010-05-20 10:43:18 +02001191/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 * pipefs should _never_ be mounted by userland - too much of security hassle,
1193 * no real gain from having the whole whorehouse mounted. So we don't need
1194 * any operations on the root directory. However, we need a non-trivial
1195 * d_name - pipe: will go nicely and kill the special-casing in procfs.
1196 */
Al Viro51139ad2010-07-25 23:47:46 +04001197static struct dentry *pipefs_mount(struct file_system_type *fs_type,
1198 int flags, const char *dev_name, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199{
Al Viroc74a1cb2011-01-12 16:59:34 -05001200 return mount_pseudo(fs_type, "pipe:", &pipefs_ops,
1201 &pipefs_dentry_operations, PIPEFS_MAGIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202}
1203
1204static struct file_system_type pipe_fs_type = {
1205 .name = "pipefs",
Al Viro51139ad2010-07-25 23:47:46 +04001206 .mount = pipefs_mount,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 .kill_sb = kill_anon_super,
1208};
1209
1210static int __init init_pipe_fs(void)
1211{
1212 int err = register_filesystem(&pipe_fs_type);
Ingo Molnar341b4462006-04-11 13:57:45 +02001213
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214 if (!err) {
1215 pipe_mnt = kern_mount(&pipe_fs_type);
1216 if (IS_ERR(pipe_mnt)) {
1217 err = PTR_ERR(pipe_mnt);
1218 unregister_filesystem(&pipe_fs_type);
1219 }
1220 }
1221 return err;
1222}
1223
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224fs_initcall(init_pipe_fs);