blob: 34345535f63d60d6b9bb72ad662ec2c75242aa0b [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{
Eric Biggers71baf272018-02-06 15:41:56 -0800612 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{
Eric Biggers71baf272018-02-06 15:41:56 -0800617 return pipe_user_pages_hard && user_bufs > pipe_user_pages_hard;
Willy Tarreau759c0112016-01-18 16:36:09 +0100618}
619
Eric Biggersa705c242018-02-06 15:41:53 -0800620static bool is_unprivileged_user(void)
621{
622 return !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN);
623}
624
Al Viro7bee1302013-03-21 11:04:15 -0400625struct pipe_inode_info *alloc_pipe_info(void)
Ingo Molnar3a326a22006-04-10 15:18:35 +0200626{
Ingo Molnar923f4f22006-04-11 13:53:33 +0200627 struct pipe_inode_info *pipe;
Michael Kerrisk (man-pages)09b4d192016-10-11 13:53:34 -0700628 unsigned long pipe_bufs = PIPE_DEF_BUFFERS;
629 struct user_struct *user = get_current_user();
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700630 unsigned long user_bufs;
Ingo Molnar3a326a22006-04-10 15:18:35 +0200631
Vladimir Davydovd86133b2016-07-26 15:24:33 -0700632 pipe = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL_ACCOUNT);
Michael Kerrisk (man-pages)09b4d192016-10-11 13:53:34 -0700633 if (pipe == NULL)
634 goto out_free_uid;
Willy Tarreau759c0112016-01-18 16:36:09 +0100635
Michael Kerrisk (man-pages)086e7742016-10-11 13:53:43 -0700636 if (pipe_bufs * PAGE_SIZE > pipe_max_size && !capable(CAP_SYS_RESOURCE))
637 pipe_bufs = pipe_max_size >> PAGE_SHIFT;
638
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700639 user_bufs = account_pipe_buffers(user, 0, pipe_bufs);
Michael Kerrisk (man-pages)a005ca02016-10-11 13:53:37 -0700640
Eric Biggersa705c242018-02-06 15:41:53 -0800641 if (too_many_pipe_buffers_soft(user_bufs) && is_unprivileged_user()) {
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700642 user_bufs = account_pipe_buffers(user, pipe_bufs, 1);
Michael Kerrisk (man-pages)a005ca02016-10-11 13:53:37 -0700643 pipe_bufs = 1;
Ingo Molnar3a326a22006-04-10 15:18:35 +0200644 }
645
Eric Biggersa705c242018-02-06 15:41:53 -0800646 if (too_many_pipe_buffers_hard(user_bufs) && is_unprivileged_user())
Michael Kerrisk (man-pages)a005ca02016-10-11 13:53:37 -0700647 goto out_revert_acct;
648
649 pipe->bufs = kcalloc(pipe_bufs, sizeof(struct pipe_buffer),
650 GFP_KERNEL_ACCOUNT);
651
Michael Kerrisk (man-pages)09b4d192016-10-11 13:53:34 -0700652 if (pipe->bufs) {
653 init_waitqueue_head(&pipe->wait);
654 pipe->r_counter = pipe->w_counter = 1;
655 pipe->buffers = pipe_bufs;
656 pipe->user = user;
Michael Kerrisk (man-pages)09b4d192016-10-11 13:53:34 -0700657 mutex_init(&pipe->mutex);
658 return pipe;
659 }
660
Michael Kerrisk (man-pages)a005ca02016-10-11 13:53:37 -0700661out_revert_acct:
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700662 (void) account_pipe_buffers(user, pipe_bufs, 0);
Michael Kerrisk (man-pages)09b4d192016-10-11 13:53:34 -0700663 kfree(pipe);
664out_free_uid:
665 free_uid(user);
Jens Axboe35f3d142010-05-20 10:43:18 +0200666 return NULL;
Ingo Molnar3a326a22006-04-10 15:18:35 +0200667}
668
Al Viro4b8a8f12013-03-21 11:06:46 -0400669void free_pipe_info(struct pipe_inode_info *pipe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670{
671 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700673 (void) account_pipe_buffers(pipe->user, pipe->buffers, 0);
Willy Tarreau759c0112016-01-18 16:36:09 +0100674 free_uid(pipe->user);
Jens Axboe35f3d142010-05-20 10:43:18 +0200675 for (i = 0; i < pipe->buffers; i++) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200676 struct pipe_buffer *buf = pipe->bufs + i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 if (buf->ops)
Miklos Szeredia7796382016-09-27 10:45:12 +0200678 pipe_buf_release(pipe, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200680 if (pipe->tmp_page)
681 __free_page(pipe->tmp_page);
Jens Axboe35f3d142010-05-20 10:43:18 +0200682 kfree(pipe->bufs);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200683 kfree(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684}
685
Eric Dumazetfa3536c2006-03-26 01:37:24 -0800686static struct vfsmount *pipe_mnt __read_mostly;
Ingo Molnar341b4462006-04-11 13:57:45 +0200687
Eric Dumazetc23fbb62007-05-08 00:26:18 -0700688/*
689 * pipefs_dname() is called from d_path().
690 */
691static char *pipefs_dname(struct dentry *dentry, char *buffer, int buflen)
692{
693 return dynamic_dname(dentry, buffer, buflen, "pipe:[%lu]",
David Howells75c3cfa2015-03-17 22:26:12 +0000694 d_inode(dentry)->i_ino);
Eric Dumazetc23fbb62007-05-08 00:26:18 -0700695}
696
Al Viro3ba13d12009-02-20 06:02:22 +0000697static const struct dentry_operations pipefs_dentry_operations = {
Eric Dumazetc23fbb62007-05-08 00:26:18 -0700698 .d_dname = pipefs_dname,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699};
700
701static struct inode * get_pipe_inode(void)
702{
Eric Dumazeta209dfc2011-07-26 11:36:34 +0200703 struct inode *inode = new_inode_pseudo(pipe_mnt->mnt_sb);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200704 struct pipe_inode_info *pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705
706 if (!inode)
707 goto fail_inode;
708
Christoph Hellwig85fe4022010-10-23 11:19:54 -0400709 inode->i_ino = get_next_ino();
710
Al Viro7bee1302013-03-21 11:04:15 -0400711 pipe = alloc_pipe_info();
Ingo Molnar923f4f22006-04-11 13:53:33 +0200712 if (!pipe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 goto fail_iput;
Ingo Molnar3a326a22006-04-10 15:18:35 +0200714
Al Viroba5bb142013-03-21 02:21:19 -0400715 inode->i_pipe = pipe;
716 pipe->files = 2;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200717 pipe->readers = pipe->writers = 1;
Al Viro599a0ac2013-03-12 09:58:10 -0400718 inode->i_fop = &pipefifo_fops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719
720 /*
721 * Mark the inode dirty from the very beginning,
722 * that way it will never be moved to the dirty
723 * list because "mark_inode_dirty()" will think
724 * that it already _is_ on the dirty list.
725 */
726 inode->i_state = I_DIRTY;
727 inode->i_mode = S_IFIFO | S_IRUSR | S_IWUSR;
David Howellsda9592e2008-11-14 10:39:05 +1100728 inode->i_uid = current_fsuid();
729 inode->i_gid = current_fsgid();
Deepa Dinamani078cd822016-09-14 07:48:04 -0700730 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200731
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 return inode;
733
734fail_iput:
735 iput(inode);
Ingo Molnar341b4462006-04-11 13:57:45 +0200736
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737fail_inode:
738 return NULL;
739}
740
Al Viroe4fad8e2012-07-21 15:33:25 +0400741int create_pipe_files(struct file **res, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742{
Andi Kleend6cbd282006-09-30 23:29:26 -0700743 int err;
Al Viroe4fad8e2012-07-21 15:33:25 +0400744 struct inode *inode = get_pipe_inode();
Andi Kleend6cbd282006-09-30 23:29:26 -0700745 struct file *f;
Al Viro2c48b9c2009-08-09 00:52:35 +0400746 struct path path;
Al Viroe4fad8e2012-07-21 15:33:25 +0400747 static struct qstr name = { .name = "" };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 if (!inode)
Al Viroe4fad8e2012-07-21 15:33:25 +0400750 return -ENFILE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751
Andi Kleend6cbd282006-09-30 23:29:26 -0700752 err = -ENOMEM;
Nick Piggin4b936882011-01-07 17:50:07 +1100753 path.dentry = d_alloc_pseudo(pipe_mnt->mnt_sb, &name);
Al Viro2c48b9c2009-08-09 00:52:35 +0400754 if (!path.dentry)
Andi Kleend6cbd282006-09-30 23:29:26 -0700755 goto err_inode;
Al Viro2c48b9c2009-08-09 00:52:35 +0400756 path.mnt = mntget(pipe_mnt);
Ingo Molnar341b4462006-04-11 13:57:45 +0200757
Al Viro2c48b9c2009-08-09 00:52:35 +0400758 d_instantiate(path.dentry, inode);
Dave Hansen430e2852008-02-15 14:37:26 -0800759
Al Viro599a0ac2013-03-12 09:58:10 -0400760 f = alloc_file(&path, FMODE_WRITE, &pipefifo_fops);
Eric Biggerse9bb1f92015-10-17 16:26:08 -0500761 if (IS_ERR(f)) {
762 err = PTR_ERR(f);
Dave Hansen430e2852008-02-15 14:37:26 -0800763 goto err_dentry;
Eric Biggerse9bb1f92015-10-17 16:26:08 -0500764 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
Linus Torvalds98830352012-04-29 13:12:42 -0700766 f->f_flags = O_WRONLY | (flags & (O_NONBLOCK | O_DIRECT));
Al Virode32ec42013-03-21 11:16:56 -0400767 f->private_data = inode->i_pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
Al Viro599a0ac2013-03-12 09:58:10 -0400769 res[0] = alloc_file(&path, FMODE_READ, &pipefifo_fops);
Eric Biggerse9bb1f92015-10-17 16:26:08 -0500770 if (IS_ERR(res[0])) {
771 err = PTR_ERR(res[0]);
Al Viroe4fad8e2012-07-21 15:33:25 +0400772 goto err_file;
Eric Biggerse9bb1f92015-10-17 16:26:08 -0500773 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774
Al Viroe4fad8e2012-07-21 15:33:25 +0400775 path_get(&path);
Al Virode32ec42013-03-21 11:16:56 -0400776 res[0]->private_data = inode->i_pipe;
Al Viroe4fad8e2012-07-21 15:33:25 +0400777 res[0]->f_flags = O_RDONLY | (flags & O_NONBLOCK);
778 res[1] = f;
779 return 0;
780
781err_file:
782 put_filp(f);
783err_dentry:
Al Viro4b8a8f12013-03-21 11:06:46 -0400784 free_pipe_info(inode->i_pipe);
Al Viro2c48b9c2009-08-09 00:52:35 +0400785 path_put(&path);
Al Viroe4fad8e2012-07-21 15:33:25 +0400786 return err;
Al Viroed152432008-04-22 19:51:27 -0400787
Al Viroe4fad8e2012-07-21 15:33:25 +0400788err_inode:
Al Viro4b8a8f12013-03-21 11:06:46 -0400789 free_pipe_info(inode->i_pipe);
Andi Kleend6cbd282006-09-30 23:29:26 -0700790 iput(inode);
Al Viroe4fad8e2012-07-21 15:33:25 +0400791 return err;
Andi Kleend6cbd282006-09-30 23:29:26 -0700792}
793
Al Viro5b249b12012-08-19 12:17:29 -0400794static int __do_pipe_flags(int *fd, struct file **files, int flags)
Andi Kleend6cbd282006-09-30 23:29:26 -0700795{
Andi Kleend6cbd282006-09-30 23:29:26 -0700796 int error;
797 int fdw, fdr;
798
Linus Torvalds98830352012-04-29 13:12:42 -0700799 if (flags & ~(O_CLOEXEC | O_NONBLOCK | O_DIRECT))
Ulrich Dreppered8cae82008-07-23 21:29:30 -0700800 return -EINVAL;
801
Al Viroe4fad8e2012-07-21 15:33:25 +0400802 error = create_pipe_files(files, flags);
803 if (error)
804 return error;
Andi Kleend6cbd282006-09-30 23:29:26 -0700805
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_read_pipe;
809 fdr = error;
810
Ulrich Dreppered8cae82008-07-23 21:29:30 -0700811 error = get_unused_fd_flags(flags);
Andi Kleend6cbd282006-09-30 23:29:26 -0700812 if (error < 0)
813 goto err_fdr;
814 fdw = error;
815
Al Viro157cf642008-12-14 04:57:47 -0500816 audit_fd_pair(fdr, fdw);
Andi Kleend6cbd282006-09-30 23:29:26 -0700817 fd[0] = fdr;
818 fd[1] = fdw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 return 0;
820
Andi Kleend6cbd282006-09-30 23:29:26 -0700821 err_fdr:
822 put_unused_fd(fdr);
823 err_read_pipe:
Al Viroe4fad8e2012-07-21 15:33:25 +0400824 fput(files[0]);
825 fput(files[1]);
Andi Kleend6cbd282006-09-30 23:29:26 -0700826 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827}
828
Al Viro5b249b12012-08-19 12:17:29 -0400829int do_pipe_flags(int *fd, int flags)
830{
831 struct file *files[2];
832 int error = __do_pipe_flags(fd, files, flags);
833 if (!error) {
834 fd_install(fd[0], files[0]);
835 fd_install(fd[1], files[1]);
836 }
837 return error;
838}
839
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840/*
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400841 * sys_pipe() is the normal C calling standard for creating
842 * a pipe. It's not the way Unix traditionally does this, though.
843 */
Heiko Carstensd4e82042009-01-14 14:14:34 +0100844SYSCALL_DEFINE2(pipe2, int __user *, fildes, int, flags)
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400845{
Al Viro5b249b12012-08-19 12:17:29 -0400846 struct file *files[2];
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400847 int fd[2];
848 int error;
849
Al Viro5b249b12012-08-19 12:17:29 -0400850 error = __do_pipe_flags(fd, files, flags);
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400851 if (!error) {
Al Viro5b249b12012-08-19 12:17:29 -0400852 if (unlikely(copy_to_user(fildes, fd, sizeof(fd)))) {
853 fput(files[0]);
854 fput(files[1]);
855 put_unused_fd(fd[0]);
856 put_unused_fd(fd[1]);
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400857 error = -EFAULT;
Al Viro5b249b12012-08-19 12:17:29 -0400858 } else {
859 fd_install(fd[0], files[0]);
860 fd_install(fd[1], files[1]);
Ulrich Drepperba719ba2008-05-06 20:42:38 -0700861 }
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400862 }
863 return error;
864}
865
Heiko Carstens2b664212009-01-14 14:14:35 +0100866SYSCALL_DEFINE1(pipe, int __user *, fildes)
Ulrich Dreppered8cae82008-07-23 21:29:30 -0700867{
868 return sys_pipe2(fildes, 0);
869}
870
Al Virofc7478a2013-03-21 02:07:59 -0400871static int wait_for_partner(struct pipe_inode_info *pipe, unsigned int *cnt)
Al Virof776c732013-03-12 09:46:27 -0400872{
873 int cur = *cnt;
874
875 while (cur == *cnt) {
Al Virofc7478a2013-03-21 02:07:59 -0400876 pipe_wait(pipe);
Al Virof776c732013-03-12 09:46:27 -0400877 if (signal_pending(current))
878 break;
879 }
880 return cur == *cnt ? -ERESTARTSYS : 0;
881}
882
Al Virofc7478a2013-03-21 02:07:59 -0400883static void wake_up_partner(struct pipe_inode_info *pipe)
Al Virof776c732013-03-12 09:46:27 -0400884{
Al Virofc7478a2013-03-21 02:07:59 -0400885 wake_up_interruptible(&pipe->wait);
Al Virof776c732013-03-12 09:46:27 -0400886}
887
888static int fifo_open(struct inode *inode, struct file *filp)
889{
890 struct pipe_inode_info *pipe;
Al Viro599a0ac2013-03-12 09:58:10 -0400891 bool is_pipe = inode->i_sb->s_magic == PIPEFS_MAGIC;
Al Virof776c732013-03-12 09:46:27 -0400892 int ret;
893
Al Viroba5bb142013-03-21 02:21:19 -0400894 filp->f_version = 0;
895
896 spin_lock(&inode->i_lock);
897 if (inode->i_pipe) {
898 pipe = inode->i_pipe;
899 pipe->files++;
900 spin_unlock(&inode->i_lock);
901 } else {
902 spin_unlock(&inode->i_lock);
Al Viro7bee1302013-03-21 11:04:15 -0400903 pipe = alloc_pipe_info();
Al Virof776c732013-03-12 09:46:27 -0400904 if (!pipe)
Al Viroba5bb142013-03-21 02:21:19 -0400905 return -ENOMEM;
906 pipe->files = 1;
907 spin_lock(&inode->i_lock);
908 if (unlikely(inode->i_pipe)) {
909 inode->i_pipe->files++;
910 spin_unlock(&inode->i_lock);
Al Viro4b8a8f12013-03-21 11:06:46 -0400911 free_pipe_info(pipe);
Al Viroba5bb142013-03-21 02:21:19 -0400912 pipe = inode->i_pipe;
913 } else {
914 inode->i_pipe = pipe;
915 spin_unlock(&inode->i_lock);
916 }
Al Virof776c732013-03-12 09:46:27 -0400917 }
Al Virode32ec42013-03-21 11:16:56 -0400918 filp->private_data = pipe;
Al Viroba5bb142013-03-21 02:21:19 -0400919 /* OK, we have a pipe and it's pinned down */
920
Al Viroebec73f2013-03-21 12:24:01 -0400921 __pipe_lock(pipe);
Al Virof776c732013-03-12 09:46:27 -0400922
923 /* We can only do regular read/write on fifos */
924 filp->f_mode &= (FMODE_READ | FMODE_WRITE);
925
926 switch (filp->f_mode) {
927 case FMODE_READ:
928 /*
929 * O_RDONLY
930 * POSIX.1 says that O_NONBLOCK means return with the FIFO
931 * opened, even when there is no process writing the FIFO.
932 */
Al Virof776c732013-03-12 09:46:27 -0400933 pipe->r_counter++;
934 if (pipe->readers++ == 0)
Al Virofc7478a2013-03-21 02:07:59 -0400935 wake_up_partner(pipe);
Al Virof776c732013-03-12 09:46:27 -0400936
Al Viro599a0ac2013-03-12 09:58:10 -0400937 if (!is_pipe && !pipe->writers) {
Al Virof776c732013-03-12 09:46:27 -0400938 if ((filp->f_flags & O_NONBLOCK)) {
939 /* suppress POLLHUP until we have
940 * seen a writer */
941 filp->f_version = pipe->w_counter;
942 } else {
Al Virofc7478a2013-03-21 02:07:59 -0400943 if (wait_for_partner(pipe, &pipe->w_counter))
Al Virof776c732013-03-12 09:46:27 -0400944 goto err_rd;
945 }
946 }
947 break;
948
949 case FMODE_WRITE:
950 /*
951 * O_WRONLY
952 * POSIX.1 says that O_NONBLOCK means return -1 with
953 * errno=ENXIO when there is no process reading the FIFO.
954 */
955 ret = -ENXIO;
Al Viro599a0ac2013-03-12 09:58:10 -0400956 if (!is_pipe && (filp->f_flags & O_NONBLOCK) && !pipe->readers)
Al Virof776c732013-03-12 09:46:27 -0400957 goto err;
958
Al Virof776c732013-03-12 09:46:27 -0400959 pipe->w_counter++;
960 if (!pipe->writers++)
Al Virofc7478a2013-03-21 02:07:59 -0400961 wake_up_partner(pipe);
Al Virof776c732013-03-12 09:46:27 -0400962
Al Viro599a0ac2013-03-12 09:58:10 -0400963 if (!is_pipe && !pipe->readers) {
Al Virofc7478a2013-03-21 02:07:59 -0400964 if (wait_for_partner(pipe, &pipe->r_counter))
Al Virof776c732013-03-12 09:46:27 -0400965 goto err_wr;
966 }
967 break;
968
969 case FMODE_READ | FMODE_WRITE:
970 /*
971 * O_RDWR
972 * POSIX.1 leaves this case "undefined" when O_NONBLOCK is set.
973 * This implementation will NEVER block on a O_RDWR open, since
974 * the process can at least talk to itself.
975 */
Al Virof776c732013-03-12 09:46:27 -0400976
977 pipe->readers++;
978 pipe->writers++;
979 pipe->r_counter++;
980 pipe->w_counter++;
981 if (pipe->readers == 1 || pipe->writers == 1)
Al Virofc7478a2013-03-21 02:07:59 -0400982 wake_up_partner(pipe);
Al Virof776c732013-03-12 09:46:27 -0400983 break;
984
985 default:
986 ret = -EINVAL;
987 goto err;
988 }
989
990 /* Ok! */
Al Viroebec73f2013-03-21 12:24:01 -0400991 __pipe_unlock(pipe);
Al Virof776c732013-03-12 09:46:27 -0400992 return 0;
993
994err_rd:
995 if (!--pipe->readers)
996 wake_up_interruptible(&pipe->wait);
997 ret = -ERESTARTSYS;
998 goto err;
999
1000err_wr:
1001 if (!--pipe->writers)
1002 wake_up_interruptible(&pipe->wait);
1003 ret = -ERESTARTSYS;
1004 goto err;
1005
1006err:
Al Viroebec73f2013-03-21 12:24:01 -04001007 __pipe_unlock(pipe);
Linus Torvaldsb0d8d222013-12-02 09:44:51 -08001008
1009 put_pipe_info(inode, pipe);
Al Virof776c732013-03-12 09:46:27 -04001010 return ret;
1011}
1012
Al Viro599a0ac2013-03-12 09:58:10 -04001013const struct file_operations pipefifo_fops = {
1014 .open = fifo_open,
1015 .llseek = no_llseek,
Al Virofb9096a2014-04-02 19:56:54 -04001016 .read_iter = pipe_read,
Al Virof0d1bec2014-04-03 15:05:18 -04001017 .write_iter = pipe_write,
Al Viro599a0ac2013-03-12 09:58:10 -04001018 .poll = pipe_poll,
1019 .unlocked_ioctl = pipe_ioctl,
1020 .release = pipe_release,
1021 .fasync = pipe_fasync,
Al Virof776c732013-03-12 09:46:27 -04001022};
1023
Ulrich Drepperd35c7b02008-05-03 15:10:37 -04001024/*
Michael Kerrisk (man-pages)f491bd72016-10-11 13:53:22 -07001025 * Currently we rely on the pipe array holding a power-of-2 number
Joe Lawrence5b13f592017-11-17 15:29:21 -08001026 * of pages. Returns 0 on error.
Michael Kerrisk (man-pages)f491bd72016-10-11 13:53:22 -07001027 */
1028static inline unsigned int round_pipe_size(unsigned int size)
1029{
1030 unsigned long nr_pages;
1031
Joe Lawrence5b13f592017-11-17 15:29:21 -08001032 if (size < pipe_min_size)
1033 size = pipe_min_size;
1034
Michael Kerrisk (man-pages)f491bd72016-10-11 13:53:22 -07001035 nr_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
Joe Lawrence5b13f592017-11-17 15:29:21 -08001036 if (nr_pages == 0)
1037 return 0;
1038
Michael Kerrisk (man-pages)f491bd72016-10-11 13:53:22 -07001039 return roundup_pow_of_two(nr_pages) << PAGE_SHIFT;
1040}
1041
1042/*
Jens Axboe35f3d142010-05-20 10:43:18 +02001043 * Allocate a new array of pipe buffers and copy the info over. Returns the
1044 * pipe size if successful, or return -ERROR on error.
1045 */
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001046static long pipe_set_size(struct pipe_inode_info *pipe, unsigned long arg)
Jens Axboe35f3d142010-05-20 10:43:18 +02001047{
1048 struct pipe_buffer *bufs;
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001049 unsigned int size, nr_pages;
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -07001050 unsigned long user_bufs;
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001051 long ret = 0;
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001052
1053 size = round_pipe_size(arg);
Joe Lawrence5b13f592017-11-17 15:29:21 -08001054 if (size == 0)
1055 return -EINVAL;
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001056 nr_pages = size >> PAGE_SHIFT;
1057
1058 if (!nr_pages)
1059 return -EINVAL;
1060
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001061 /*
1062 * If trying to increase the pipe capacity, check that an
1063 * unprivileged user is not trying to exceed various limits
1064 * (soft limit check here, hard limit check just below).
1065 * Decreasing the pipe capacity is always permitted, even
1066 * if the user is currently over a limit.
1067 */
1068 if (nr_pages > pipe->buffers &&
1069 size > pipe_max_size && !capable(CAP_SYS_RESOURCE))
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001070 return -EPERM;
1071
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -07001072 user_bufs = account_pipe_buffers(pipe->user, pipe->buffers, nr_pages);
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001073
1074 if (nr_pages > pipe->buffers &&
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -07001075 (too_many_pipe_buffers_hard(user_bufs) ||
1076 too_many_pipe_buffers_soft(user_bufs)) &&
Eric Biggersa705c242018-02-06 15:41:53 -08001077 is_unprivileged_user()) {
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001078 ret = -EPERM;
1079 goto out_revert_acct;
1080 }
Jens Axboe35f3d142010-05-20 10:43:18 +02001081
1082 /*
Jens Axboe35f3d142010-05-20 10:43:18 +02001083 * We can shrink the pipe, if arg >= pipe->nrbufs. Since we don't
1084 * expect a lot of shrink+grow operations, just free and allocate
1085 * again like we would do for growing. If the pipe currently
1086 * contains more buffers than arg, then return busy.
1087 */
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001088 if (nr_pages < pipe->nrbufs) {
1089 ret = -EBUSY;
1090 goto out_revert_acct;
1091 }
Jens Axboe35f3d142010-05-20 10:43:18 +02001092
Vladimir Davydovd86133b2016-07-26 15:24:33 -07001093 bufs = kcalloc(nr_pages, sizeof(*bufs),
1094 GFP_KERNEL_ACCOUNT | __GFP_NOWARN);
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001095 if (unlikely(!bufs)) {
1096 ret = -ENOMEM;
1097 goto out_revert_acct;
1098 }
Jens Axboe35f3d142010-05-20 10:43:18 +02001099
1100 /*
1101 * The pipe array wraps around, so just start the new one at zero
1102 * and adjust the indexes.
1103 */
1104 if (pipe->nrbufs) {
Miklos Szeredi1d862f42010-06-08 16:28:45 +02001105 unsigned int tail;
1106 unsigned int head;
Jens Axboe35f3d142010-05-20 10:43:18 +02001107
Miklos Szeredi1d862f42010-06-08 16:28:45 +02001108 tail = pipe->curbuf + pipe->nrbufs;
1109 if (tail < pipe->buffers)
1110 tail = 0;
1111 else
1112 tail &= (pipe->buffers - 1);
1113
1114 head = pipe->nrbufs - tail;
Jens Axboe35f3d142010-05-20 10:43:18 +02001115 if (head)
1116 memcpy(bufs, pipe->bufs + pipe->curbuf, head * sizeof(struct pipe_buffer));
1117 if (tail)
Miklos Szeredi1d862f42010-06-08 16:28:45 +02001118 memcpy(bufs + head, pipe->bufs, tail * sizeof(struct pipe_buffer));
Jens Axboe35f3d142010-05-20 10:43:18 +02001119 }
1120
1121 pipe->curbuf = 0;
1122 kfree(pipe->bufs);
1123 pipe->bufs = bufs;
Jens Axboeb9598db2010-05-24 19:34:43 +02001124 pipe->buffers = nr_pages;
1125 return nr_pages * PAGE_SIZE;
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001126
1127out_revert_acct:
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -07001128 (void) account_pipe_buffers(pipe->user, nr_pages, pipe->buffers);
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001129 return ret;
Jens Axboe35f3d142010-05-20 10:43:18 +02001130}
1131
Jens Axboeff9da692010-06-03 14:54:39 +02001132/*
Jens Axboeff9da692010-06-03 14:54:39 +02001133 * This should work even if CONFIG_PROC_FS isn't set, as proc_dointvec_minmax
1134 * will return an error.
1135 */
1136int pipe_proc_fn(struct ctl_table *table, int write, void __user *buf,
1137 size_t *lenp, loff_t *ppos)
1138{
Joe Lawrence5b13f592017-11-17 15:29:21 -08001139 unsigned int rounded_pipe_max_size;
Jens Axboeff9da692010-06-03 14:54:39 +02001140 int ret;
1141
1142 ret = proc_dointvec_minmax(table, write, buf, lenp, ppos);
1143 if (ret < 0 || !write)
1144 return ret;
1145
Joe Lawrence5b13f592017-11-17 15:29:21 -08001146 rounded_pipe_max_size = round_pipe_size(pipe_max_size);
1147 if (rounded_pipe_max_size == 0)
1148 return -EINVAL;
1149
1150 pipe_max_size = rounded_pipe_max_size;
Jens Axboeff9da692010-06-03 14:54:39 +02001151 return ret;
1152}
1153
Linus Torvalds72083642010-11-28 16:27:19 -08001154/*
1155 * After the inode slimming patch, i_pipe/i_bdev/i_cdev share the same
1156 * location, so checking ->i_pipe is not enough to verify that this is a
1157 * pipe.
1158 */
1159struct pipe_inode_info *get_pipe_info(struct file *file)
1160{
Al Virode32ec42013-03-21 11:16:56 -04001161 return file->f_op == &pipefifo_fops ? file->private_data : NULL;
Linus Torvalds72083642010-11-28 16:27:19 -08001162}
1163
Jens Axboe35f3d142010-05-20 10:43:18 +02001164long pipe_fcntl(struct file *file, unsigned int cmd, unsigned long arg)
1165{
1166 struct pipe_inode_info *pipe;
1167 long ret;
1168
Linus Torvaldsc66fb342010-11-28 14:09:57 -08001169 pipe = get_pipe_info(file);
Jens Axboe35f3d142010-05-20 10:43:18 +02001170 if (!pipe)
1171 return -EBADF;
1172
Al Viroebec73f2013-03-21 12:24:01 -04001173 __pipe_lock(pipe);
Jens Axboe35f3d142010-05-20 10:43:18 +02001174
1175 switch (cmd) {
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001176 case F_SETPIPE_SZ:
1177 ret = pipe_set_size(pipe, arg);
Jens Axboe35f3d142010-05-20 10:43:18 +02001178 break;
1179 case F_GETPIPE_SZ:
Jens Axboeb9598db2010-05-24 19:34:43 +02001180 ret = pipe->buffers * PAGE_SIZE;
Jens Axboe35f3d142010-05-20 10:43:18 +02001181 break;
1182 default:
1183 ret = -EINVAL;
1184 break;
1185 }
1186
Al Viroebec73f2013-03-21 12:24:01 -04001187 __pipe_unlock(pipe);
Jens Axboe35f3d142010-05-20 10:43:18 +02001188 return ret;
1189}
1190
Nick Pigginff0c7d12011-01-07 17:49:50 +11001191static const struct super_operations pipefs_ops = {
1192 .destroy_inode = free_inode_nonrcu,
Pavel Emelyanovd70ef972011-10-31 17:10:04 -07001193 .statfs = simple_statfs,
Nick Pigginff0c7d12011-01-07 17:49:50 +11001194};
1195
Jens Axboe35f3d142010-05-20 10:43:18 +02001196/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 * pipefs should _never_ be mounted by userland - too much of security hassle,
1198 * no real gain from having the whole whorehouse mounted. So we don't need
1199 * any operations on the root directory. However, we need a non-trivial
1200 * d_name - pipe: will go nicely and kill the special-casing in procfs.
1201 */
Al Viro51139ad2010-07-25 23:47:46 +04001202static struct dentry *pipefs_mount(struct file_system_type *fs_type,
1203 int flags, const char *dev_name, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204{
Al Viroc74a1cb2011-01-12 16:59:34 -05001205 return mount_pseudo(fs_type, "pipe:", &pipefs_ops,
1206 &pipefs_dentry_operations, PIPEFS_MAGIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207}
1208
1209static struct file_system_type pipe_fs_type = {
1210 .name = "pipefs",
Al Viro51139ad2010-07-25 23:47:46 +04001211 .mount = pipefs_mount,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 .kill_sb = kill_anon_super,
1213};
1214
1215static int __init init_pipe_fs(void)
1216{
1217 int err = register_filesystem(&pipe_fs_type);
Ingo Molnar341b4462006-04-11 13:57:45 +02001218
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 if (!err) {
1220 pipe_mnt = kern_mount(&pipe_fs_type);
1221 if (IS_ERR(pipe_mnt)) {
1222 err = PTR_ERR(pipe_mnt);
1223 unregister_filesystem(&pipe_fs_type);
1224 }
1225 }
1226 return err;
1227}
1228
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229fs_initcall(init_pipe_fs);