blob: 347c6dc888c8f6c4743e157651881f7e4ad141d2 [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 */
Matthew Wilcox95570902019-04-05 14:02:10 -0700196bool generic_pipe_buf_get(struct pipe_inode_info *pipe, struct pipe_buffer *buf)
Jens Axboe70524492006-04-11 15:51:17 +0200197{
Matthew Wilcox95570902019-04-05 14:02:10 -0700198 return try_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
Jann Horn943ebf42019-01-23 15:19:17 +0100241static const struct pipe_buf_operations anon_pipe_buf_nomerge_ops = {
242 .can_merge = 0,
243 .confirm = generic_pipe_buf_confirm,
244 .release = anon_pipe_buf_release,
245 .steal = anon_pipe_buf_steal,
246 .get = generic_pipe_buf_get,
247};
248
Linus Torvalds98830352012-04-29 13:12:42 -0700249static const struct pipe_buf_operations packet_pipe_buf_ops = {
250 .can_merge = 0,
Linus Torvalds98830352012-04-29 13:12:42 -0700251 .confirm = generic_pipe_buf_confirm,
252 .release = anon_pipe_buf_release,
Vladimir Davydovd86133b2016-07-26 15:24:33 -0700253 .steal = anon_pipe_buf_steal,
Linus Torvalds98830352012-04-29 13:12:42 -0700254 .get = generic_pipe_buf_get,
255};
256
Jann Horn943ebf42019-01-23 15:19:17 +0100257void pipe_buf_mark_unmergeable(struct pipe_buffer *buf)
258{
259 if (buf->ops == &anon_pipe_buf_ops)
260 buf->ops = &anon_pipe_buf_nomerge_ops;
261}
262
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263static ssize_t
Al Virofb9096a2014-04-02 19:56:54 -0400264pipe_read(struct kiocb *iocb, struct iov_iter *to)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265{
Al Virofb9096a2014-04-02 19:56:54 -0400266 size_t total_len = iov_iter_count(to);
Badari Pulavartyee0b3e62006-09-30 23:28:47 -0700267 struct file *filp = iocb->ki_filp;
Al Virode32ec42013-03-21 11:16:56 -0400268 struct pipe_inode_info *pipe = filp->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 int do_wakeup;
270 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 /* Null read succeeds. */
273 if (unlikely(total_len == 0))
274 return 0;
275
276 do_wakeup = 0;
277 ret = 0;
Al Viroebec73f2013-03-21 12:24:01 -0400278 __pipe_lock(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 for (;;) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200280 int bufs = pipe->nrbufs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 if (bufs) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200282 int curbuf = pipe->curbuf;
283 struct pipe_buffer *buf = pipe->bufs + curbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 size_t chars = buf->len;
Al Viro637b58c2014-02-03 19:11:42 -0500285 size_t written;
286 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 if (chars > total_len)
289 chars = total_len;
290
Miklos Szeredifba597d2016-09-27 10:45:12 +0200291 error = pipe_buf_confirm(pipe, buf);
Jens Axboef84d7512006-05-01 19:59:03 +0200292 if (error) {
Jens Axboe5274f052006-03-30 15:15:30 +0200293 if (!ret)
Nicolas Kaisere5953cb2010-10-21 14:56:00 +0200294 ret = error;
Jens Axboe5274f052006-03-30 15:15:30 +0200295 break;
296 }
Jens Axboef84d7512006-05-01 19:59:03 +0200297
Al Virofb9096a2014-04-02 19:56:54 -0400298 written = copy_page_to_iter(buf->page, buf->offset, chars, to);
Al Viro637b58c2014-02-03 19:11:42 -0500299 if (unlikely(written < chars)) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200300 if (!ret)
Al Viro637b58c2014-02-03 19:11:42 -0500301 ret = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 break;
303 }
304 ret += chars;
305 buf->offset += chars;
306 buf->len -= chars;
Linus Torvalds98830352012-04-29 13:12:42 -0700307
308 /* Was it a packet buffer? Clean up and exit */
309 if (buf->flags & PIPE_BUF_FLAG_PACKET) {
310 total_len = chars;
311 buf->len = 0;
312 }
313
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 if (!buf->len) {
Miklos Szeredia7796382016-09-27 10:45:12 +0200315 pipe_buf_release(pipe, buf);
Jens Axboe35f3d142010-05-20 10:43:18 +0200316 curbuf = (curbuf + 1) & (pipe->buffers - 1);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200317 pipe->curbuf = curbuf;
318 pipe->nrbufs = --bufs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 do_wakeup = 1;
320 }
321 total_len -= chars;
322 if (!total_len)
323 break; /* common path: read succeeded */
324 }
325 if (bufs) /* More to do? */
326 continue;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200327 if (!pipe->writers)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 break;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200329 if (!pipe->waiting_writers) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 /* syscall merging: Usually we must not sleep
331 * if O_NONBLOCK is set, or if we got some data.
332 * But if a writer sleeps in kernel space, then
333 * we can wait for that data without violating POSIX.
334 */
335 if (ret)
336 break;
337 if (filp->f_flags & O_NONBLOCK) {
338 ret = -EAGAIN;
339 break;
340 }
341 }
342 if (signal_pending(current)) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200343 if (!ret)
344 ret = -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 break;
346 }
347 if (do_wakeup) {
Linus Torvalds28e58ee2011-01-20 16:21:59 -0800348 wake_up_interruptible_sync_poll(&pipe->wait, POLLOUT | POLLWRNORM);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200349 kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200351 pipe_wait(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 }
Al Viroebec73f2013-03-21 12:24:01 -0400353 __pipe_unlock(pipe);
Ingo Molnar341b4462006-04-11 13:57:45 +0200354
355 /* Signal writers asynchronously that there is more room. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 if (do_wakeup) {
Linus Torvalds28e58ee2011-01-20 16:21:59 -0800357 wake_up_interruptible_sync_poll(&pipe->wait, POLLOUT | POLLWRNORM);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200358 kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 }
360 if (ret > 0)
361 file_accessed(filp);
362 return ret;
363}
364
Linus Torvalds98830352012-04-29 13:12:42 -0700365static inline int is_packetized(struct file *file)
366{
367 return (file->f_flags & O_DIRECT) != 0;
368}
369
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370static ssize_t
Al Virof0d1bec2014-04-03 15:05:18 -0400371pipe_write(struct kiocb *iocb, struct iov_iter *from)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372{
Badari Pulavartyee0b3e62006-09-30 23:28:47 -0700373 struct file *filp = iocb->ki_filp;
Al Virode32ec42013-03-21 11:16:56 -0400374 struct pipe_inode_info *pipe = filp->private_data;
Al Virof0d1bec2014-04-03 15:05:18 -0400375 ssize_t ret = 0;
376 int do_wakeup = 0;
377 size_t total_len = iov_iter_count(from);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 ssize_t chars;
379
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 /* Null write succeeds. */
381 if (unlikely(total_len == 0))
382 return 0;
383
Al Viroebec73f2013-03-21 12:24:01 -0400384 __pipe_lock(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
Ingo Molnar923f4f22006-04-11 13:53:33 +0200386 if (!pipe->readers) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 send_sig(SIGPIPE, current, 0);
388 ret = -EPIPE;
389 goto out;
390 }
391
392 /* We try to merge small writes */
393 chars = total_len & (PAGE_SIZE-1); /* size of the last buffer */
Ingo Molnar923f4f22006-04-11 13:53:33 +0200394 if (pipe->nrbufs && chars != 0) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200395 int lastbuf = (pipe->curbuf + pipe->nrbufs - 1) &
Jens Axboe35f3d142010-05-20 10:43:18 +0200396 (pipe->buffers - 1);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200397 struct pipe_buffer *buf = pipe->bufs + lastbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 int offset = buf->offset + buf->len;
Ingo Molnar341b4462006-04-11 13:57:45 +0200399
Miklos Szeredifba597d2016-09-27 10:45:12 +0200400 if (buf->ops->can_merge && offset + chars <= PAGE_SIZE) {
401 ret = pipe_buf_confirm(pipe, buf);
Eric Biggers6ae08062015-10-17 16:26:09 -0500402 if (ret)
Jens Axboe5274f052006-03-30 15:15:30 +0200403 goto out;
Jens Axboef84d7512006-05-01 19:59:03 +0200404
Al Virof0d1bec2014-04-03 15:05:18 -0400405 ret = copy_page_from_iter(buf->page, offset, chars, from);
406 if (unlikely(ret < chars)) {
Eric Biggers6ae08062015-10-17 16:26:09 -0500407 ret = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 goto out;
Jens Axboef6762b72006-05-01 20:02:05 +0200409 }
Al Virof0d1bec2014-04-03 15:05:18 -0400410 do_wakeup = 1;
Eric Biggers6ae08062015-10-17 16:26:09 -0500411 buf->len += ret;
Al Virof0d1bec2014-04-03 15:05:18 -0400412 if (!iov_iter_count(from))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 goto out;
414 }
415 }
416
417 for (;;) {
418 int bufs;
Ingo Molnar341b4462006-04-11 13:57:45 +0200419
Ingo Molnar923f4f22006-04-11 13:53:33 +0200420 if (!pipe->readers) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 send_sig(SIGPIPE, current, 0);
Ingo Molnar341b4462006-04-11 13:57:45 +0200422 if (!ret)
423 ret = -EPIPE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 break;
425 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200426 bufs = pipe->nrbufs;
Jens Axboe35f3d142010-05-20 10:43:18 +0200427 if (bufs < pipe->buffers) {
428 int newbuf = (pipe->curbuf + bufs) & (pipe->buffers-1);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200429 struct pipe_buffer *buf = pipe->bufs + newbuf;
430 struct page *page = pipe->tmp_page;
Al Virof0d1bec2014-04-03 15:05:18 -0400431 int copied;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
433 if (!page) {
Vladimir Davydovd86133b2016-07-26 15:24:33 -0700434 page = alloc_page(GFP_HIGHUSER | __GFP_ACCOUNT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 if (unlikely(!page)) {
436 ret = ret ? : -ENOMEM;
437 break;
438 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200439 pipe->tmp_page = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 }
Ingo Molnar341b4462006-04-11 13:57:45 +0200441 /* Always wake up, even if the copy fails. Otherwise
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 * we lock up (O_NONBLOCK-)readers that sleep due to
443 * syscall merging.
444 * FIXME! Is this really true?
445 */
446 do_wakeup = 1;
Al Virof0d1bec2014-04-03 15:05:18 -0400447 copied = copy_page_from_iter(page, 0, PAGE_SIZE, from);
448 if (unlikely(copied < PAGE_SIZE && iov_iter_count(from))) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200449 if (!ret)
Al Virof0d1bec2014-04-03 15:05:18 -0400450 ret = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 break;
452 }
Al Virof0d1bec2014-04-03 15:05:18 -0400453 ret += copied;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
455 /* Insert it into the buffer array */
456 buf->page = page;
457 buf->ops = &anon_pipe_buf_ops;
458 buf->offset = 0;
Al Virof0d1bec2014-04-03 15:05:18 -0400459 buf->len = copied;
Linus Torvalds98830352012-04-29 13:12:42 -0700460 buf->flags = 0;
461 if (is_packetized(filp)) {
462 buf->ops = &packet_pipe_buf_ops;
463 buf->flags = PIPE_BUF_FLAG_PACKET;
464 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200465 pipe->nrbufs = ++bufs;
466 pipe->tmp_page = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
Al Virof0d1bec2014-04-03 15:05:18 -0400468 if (!iov_iter_count(from))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 break;
470 }
Jens Axboe35f3d142010-05-20 10:43:18 +0200471 if (bufs < pipe->buffers)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 continue;
473 if (filp->f_flags & O_NONBLOCK) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200474 if (!ret)
475 ret = -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 break;
477 }
478 if (signal_pending(current)) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200479 if (!ret)
480 ret = -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 break;
482 }
483 if (do_wakeup) {
Linus Torvalds28e58ee2011-01-20 16:21:59 -0800484 wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLRDNORM);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200485 kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 do_wakeup = 0;
487 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200488 pipe->waiting_writers++;
489 pipe_wait(pipe);
490 pipe->waiting_writers--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 }
492out:
Al Viroebec73f2013-03-21 12:24:01 -0400493 __pipe_unlock(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 if (do_wakeup) {
Linus Torvalds28e58ee2011-01-20 16:21:59 -0800495 wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLRDNORM);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200496 kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 }
Dmitry Monakhov7e775f42014-01-23 15:55:21 -0800498 if (ret > 0 && sb_start_write_trylock(file_inode(filp)->i_sb)) {
Josef Bacikc3b2da32012-03-26 09:59:21 -0400499 int err = file_update_time(filp);
500 if (err)
501 ret = err;
Dmitry Monakhov7e775f42014-01-23 15:55:21 -0800502 sb_end_write(file_inode(filp)->i_sb);
Josef Bacikc3b2da32012-03-26 09:59:21 -0400503 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 return ret;
505}
506
Andi Kleend59d0b12008-02-08 04:21:23 -0800507static long pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508{
Al Virode32ec42013-03-21 11:16:56 -0400509 struct pipe_inode_info *pipe = filp->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 int count, buf, nrbufs;
511
512 switch (cmd) {
513 case FIONREAD:
Al Viroebec73f2013-03-21 12:24:01 -0400514 __pipe_lock(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 count = 0;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200516 buf = pipe->curbuf;
517 nrbufs = pipe->nrbufs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 while (--nrbufs >= 0) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200519 count += pipe->bufs[buf].len;
Jens Axboe35f3d142010-05-20 10:43:18 +0200520 buf = (buf+1) & (pipe->buffers - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 }
Al Viroebec73f2013-03-21 12:24:01 -0400522 __pipe_unlock(pipe);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200523
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 return put_user(count, (int __user *)arg);
525 default:
Will Deacon46ce3412012-05-25 11:39:13 +0100526 return -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 }
528}
529
530/* No kernel lock held - fine */
531static unsigned int
532pipe_poll(struct file *filp, poll_table *wait)
533{
534 unsigned int mask;
Al Virode32ec42013-03-21 11:16:56 -0400535 struct pipe_inode_info *pipe = filp->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 int nrbufs;
537
Ingo Molnar923f4f22006-04-11 13:53:33 +0200538 poll_wait(filp, &pipe->wait, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
540 /* Reading only -- no need for acquiring the semaphore. */
Ingo Molnar923f4f22006-04-11 13:53:33 +0200541 nrbufs = pipe->nrbufs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 mask = 0;
543 if (filp->f_mode & FMODE_READ) {
544 mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200545 if (!pipe->writers && filp->f_version != pipe->w_counter)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 mask |= POLLHUP;
547 }
548
549 if (filp->f_mode & FMODE_WRITE) {
Jens Axboe35f3d142010-05-20 10:43:18 +0200550 mask |= (nrbufs < pipe->buffers) ? POLLOUT | POLLWRNORM : 0;
Pekka Enberg5e5d7a22005-09-06 15:17:48 -0700551 /*
552 * Most Unices do not set POLLERR for FIFOs but on Linux they
553 * behave exactly like pipes for poll().
554 */
Ingo Molnar923f4f22006-04-11 13:53:33 +0200555 if (!pipe->readers)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 mask |= POLLERR;
557 }
558
559 return mask;
560}
561
Linus Torvaldsb0d8d222013-12-02 09:44:51 -0800562static void put_pipe_info(struct inode *inode, struct pipe_inode_info *pipe)
563{
564 int kill = 0;
565
566 spin_lock(&inode->i_lock);
567 if (!--pipe->files) {
568 inode->i_pipe = NULL;
569 kill = 1;
570 }
571 spin_unlock(&inode->i_lock);
572
573 if (kill)
574 free_pipe_info(pipe);
575}
576
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577static int
Al Viro599a0ac2013-03-12 09:58:10 -0400578pipe_release(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579{
Linus Torvaldsb0d8d222013-12-02 09:44:51 -0800580 struct pipe_inode_info *pipe = file->private_data;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200581
Al Viroebec73f2013-03-21 12:24:01 -0400582 __pipe_lock(pipe);
Al Viro599a0ac2013-03-12 09:58:10 -0400583 if (file->f_mode & FMODE_READ)
584 pipe->readers--;
585 if (file->f_mode & FMODE_WRITE)
586 pipe->writers--;
Ingo Molnar341b4462006-04-11 13:57:45 +0200587
Al Viroba5bb142013-03-21 02:21:19 -0400588 if (pipe->readers || pipe->writers) {
Linus Torvalds28e58ee2011-01-20 16:21:59 -0800589 wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM | POLLERR | POLLHUP);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200590 kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
591 kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 }
Al Viroebec73f2013-03-21 12:24:01 -0400593 __pipe_unlock(pipe);
Al Viroba5bb142013-03-21 02:21:19 -0400594
Linus Torvaldsb0d8d222013-12-02 09:44:51 -0800595 put_pipe_info(inode, pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 return 0;
597}
598
599static int
Al Viro599a0ac2013-03-12 09:58:10 -0400600pipe_fasync(int fd, struct file *filp, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601{
Al Virode32ec42013-03-21 11:16:56 -0400602 struct pipe_inode_info *pipe = filp->private_data;
Al Viro599a0ac2013-03-12 09:58:10 -0400603 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
Al Viroebec73f2013-03-21 12:24:01 -0400605 __pipe_lock(pipe);
Al Viro599a0ac2013-03-12 09:58:10 -0400606 if (filp->f_mode & FMODE_READ)
607 retval = fasync_helper(fd, filp, on, &pipe->fasync_readers);
608 if ((filp->f_mode & FMODE_WRITE) && retval >= 0) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200609 retval = fasync_helper(fd, filp, on, &pipe->fasync_writers);
Al Viro599a0ac2013-03-12 09:58:10 -0400610 if (retval < 0 && (filp->f_mode & FMODE_READ))
611 /* this can happen only if on == T */
Oleg Nesterove5bc49b2009-03-12 14:31:28 -0700612 fasync_helper(-1, filp, 0, &pipe->fasync_readers);
613 }
Al Viroebec73f2013-03-21 12:24:01 -0400614 __pipe_unlock(pipe);
Jonathan Corbet60aa4922009-02-01 14:52:56 -0700615 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616}
617
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700618static unsigned long account_pipe_buffers(struct user_struct *user,
Willy Tarreau759c0112016-01-18 16:36:09 +0100619 unsigned long old, unsigned long new)
620{
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700621 return atomic_long_add_return(new - old, &user->pipe_bufs);
Willy Tarreau759c0112016-01-18 16:36:09 +0100622}
623
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700624static bool too_many_pipe_buffers_soft(unsigned long user_bufs)
Willy Tarreau759c0112016-01-18 16:36:09 +0100625{
Eric Biggers71baf272018-02-06 15:41:56 -0800626 return pipe_user_pages_soft && user_bufs > pipe_user_pages_soft;
Willy Tarreau759c0112016-01-18 16:36:09 +0100627}
628
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700629static bool too_many_pipe_buffers_hard(unsigned long user_bufs)
Willy Tarreau759c0112016-01-18 16:36:09 +0100630{
Eric Biggers71baf272018-02-06 15:41:56 -0800631 return pipe_user_pages_hard && user_bufs > pipe_user_pages_hard;
Willy Tarreau759c0112016-01-18 16:36:09 +0100632}
633
Eric Biggersa705c242018-02-06 15:41:53 -0800634static bool is_unprivileged_user(void)
635{
636 return !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN);
637}
638
Al Viro7bee1302013-03-21 11:04:15 -0400639struct pipe_inode_info *alloc_pipe_info(void)
Ingo Molnar3a326a22006-04-10 15:18:35 +0200640{
Ingo Molnar923f4f22006-04-11 13:53:33 +0200641 struct pipe_inode_info *pipe;
Michael Kerrisk (man-pages)09b4d192016-10-11 13:53:34 -0700642 unsigned long pipe_bufs = PIPE_DEF_BUFFERS;
643 struct user_struct *user = get_current_user();
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700644 unsigned long user_bufs;
Ingo Molnar3a326a22006-04-10 15:18:35 +0200645
Vladimir Davydovd86133b2016-07-26 15:24:33 -0700646 pipe = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL_ACCOUNT);
Michael Kerrisk (man-pages)09b4d192016-10-11 13:53:34 -0700647 if (pipe == NULL)
648 goto out_free_uid;
Willy Tarreau759c0112016-01-18 16:36:09 +0100649
Michael Kerrisk (man-pages)086e7742016-10-11 13:53:43 -0700650 if (pipe_bufs * PAGE_SIZE > pipe_max_size && !capable(CAP_SYS_RESOURCE))
651 pipe_bufs = pipe_max_size >> PAGE_SHIFT;
652
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700653 user_bufs = account_pipe_buffers(user, 0, pipe_bufs);
Michael Kerrisk (man-pages)a005ca02016-10-11 13:53:37 -0700654
Eric Biggersa705c242018-02-06 15:41:53 -0800655 if (too_many_pipe_buffers_soft(user_bufs) && is_unprivileged_user()) {
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700656 user_bufs = account_pipe_buffers(user, pipe_bufs, 1);
Michael Kerrisk (man-pages)a005ca02016-10-11 13:53:37 -0700657 pipe_bufs = 1;
Ingo Molnar3a326a22006-04-10 15:18:35 +0200658 }
659
Eric Biggersa705c242018-02-06 15:41:53 -0800660 if (too_many_pipe_buffers_hard(user_bufs) && is_unprivileged_user())
Michael Kerrisk (man-pages)a005ca02016-10-11 13:53:37 -0700661 goto out_revert_acct;
662
663 pipe->bufs = kcalloc(pipe_bufs, sizeof(struct pipe_buffer),
664 GFP_KERNEL_ACCOUNT);
665
Michael Kerrisk (man-pages)09b4d192016-10-11 13:53:34 -0700666 if (pipe->bufs) {
667 init_waitqueue_head(&pipe->wait);
668 pipe->r_counter = pipe->w_counter = 1;
669 pipe->buffers = pipe_bufs;
670 pipe->user = user;
Michael Kerrisk (man-pages)09b4d192016-10-11 13:53:34 -0700671 mutex_init(&pipe->mutex);
672 return pipe;
673 }
674
Michael Kerrisk (man-pages)a005ca02016-10-11 13:53:37 -0700675out_revert_acct:
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700676 (void) account_pipe_buffers(user, pipe_bufs, 0);
Michael Kerrisk (man-pages)09b4d192016-10-11 13:53:34 -0700677 kfree(pipe);
678out_free_uid:
679 free_uid(user);
Jens Axboe35f3d142010-05-20 10:43:18 +0200680 return NULL;
Ingo Molnar3a326a22006-04-10 15:18:35 +0200681}
682
Al Viro4b8a8f12013-03-21 11:06:46 -0400683void free_pipe_info(struct pipe_inode_info *pipe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684{
685 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -0700687 (void) account_pipe_buffers(pipe->user, pipe->buffers, 0);
Willy Tarreau759c0112016-01-18 16:36:09 +0100688 free_uid(pipe->user);
Jens Axboe35f3d142010-05-20 10:43:18 +0200689 for (i = 0; i < pipe->buffers; i++) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200690 struct pipe_buffer *buf = pipe->bufs + i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 if (buf->ops)
Miklos Szeredia7796382016-09-27 10:45:12 +0200692 pipe_buf_release(pipe, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200694 if (pipe->tmp_page)
695 __free_page(pipe->tmp_page);
Jens Axboe35f3d142010-05-20 10:43:18 +0200696 kfree(pipe->bufs);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200697 kfree(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698}
699
Eric Dumazetfa3536c2006-03-26 01:37:24 -0800700static struct vfsmount *pipe_mnt __read_mostly;
Ingo Molnar341b4462006-04-11 13:57:45 +0200701
Eric Dumazetc23fbb62007-05-08 00:26:18 -0700702/*
703 * pipefs_dname() is called from d_path().
704 */
705static char *pipefs_dname(struct dentry *dentry, char *buffer, int buflen)
706{
707 return dynamic_dname(dentry, buffer, buflen, "pipe:[%lu]",
David Howells75c3cfa2015-03-17 22:26:12 +0000708 d_inode(dentry)->i_ino);
Eric Dumazetc23fbb62007-05-08 00:26:18 -0700709}
710
Al Viro3ba13d12009-02-20 06:02:22 +0000711static const struct dentry_operations pipefs_dentry_operations = {
Eric Dumazetc23fbb62007-05-08 00:26:18 -0700712 .d_dname = pipefs_dname,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713};
714
715static struct inode * get_pipe_inode(void)
716{
Eric Dumazeta209dfc2011-07-26 11:36:34 +0200717 struct inode *inode = new_inode_pseudo(pipe_mnt->mnt_sb);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200718 struct pipe_inode_info *pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719
720 if (!inode)
721 goto fail_inode;
722
Christoph Hellwig85fe4022010-10-23 11:19:54 -0400723 inode->i_ino = get_next_ino();
724
Al Viro7bee1302013-03-21 11:04:15 -0400725 pipe = alloc_pipe_info();
Ingo Molnar923f4f22006-04-11 13:53:33 +0200726 if (!pipe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 goto fail_iput;
Ingo Molnar3a326a22006-04-10 15:18:35 +0200728
Al Viroba5bb142013-03-21 02:21:19 -0400729 inode->i_pipe = pipe;
730 pipe->files = 2;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200731 pipe->readers = pipe->writers = 1;
Al Viro599a0ac2013-03-12 09:58:10 -0400732 inode->i_fop = &pipefifo_fops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733
734 /*
735 * Mark the inode dirty from the very beginning,
736 * that way it will never be moved to the dirty
737 * list because "mark_inode_dirty()" will think
738 * that it already _is_ on the dirty list.
739 */
740 inode->i_state = I_DIRTY;
741 inode->i_mode = S_IFIFO | S_IRUSR | S_IWUSR;
David Howellsda9592e2008-11-14 10:39:05 +1100742 inode->i_uid = current_fsuid();
743 inode->i_gid = current_fsgid();
Deepa Dinamani078cd822016-09-14 07:48:04 -0700744 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200745
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 return inode;
747
748fail_iput:
749 iput(inode);
Ingo Molnar341b4462006-04-11 13:57:45 +0200750
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751fail_inode:
752 return NULL;
753}
754
Al Viroe4fad8e2012-07-21 15:33:25 +0400755int create_pipe_files(struct file **res, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756{
Andi Kleend6cbd282006-09-30 23:29:26 -0700757 int err;
Al Viroe4fad8e2012-07-21 15:33:25 +0400758 struct inode *inode = get_pipe_inode();
Andi Kleend6cbd282006-09-30 23:29:26 -0700759 struct file *f;
Al Viro2c48b9c2009-08-09 00:52:35 +0400760 struct path path;
Al Viroe4fad8e2012-07-21 15:33:25 +0400761 static struct qstr name = { .name = "" };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 if (!inode)
Al Viroe4fad8e2012-07-21 15:33:25 +0400764 return -ENFILE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
Andi Kleend6cbd282006-09-30 23:29:26 -0700766 err = -ENOMEM;
Nick Piggin4b936882011-01-07 17:50:07 +1100767 path.dentry = d_alloc_pseudo(pipe_mnt->mnt_sb, &name);
Al Viro2c48b9c2009-08-09 00:52:35 +0400768 if (!path.dentry)
Andi Kleend6cbd282006-09-30 23:29:26 -0700769 goto err_inode;
Al Viro2c48b9c2009-08-09 00:52:35 +0400770 path.mnt = mntget(pipe_mnt);
Ingo Molnar341b4462006-04-11 13:57:45 +0200771
Al Viro2c48b9c2009-08-09 00:52:35 +0400772 d_instantiate(path.dentry, inode);
Dave Hansen430e2852008-02-15 14:37:26 -0800773
Al Viro599a0ac2013-03-12 09:58:10 -0400774 f = alloc_file(&path, FMODE_WRITE, &pipefifo_fops);
Eric Biggerse9bb1f92015-10-17 16:26:08 -0500775 if (IS_ERR(f)) {
776 err = PTR_ERR(f);
Dave Hansen430e2852008-02-15 14:37:26 -0800777 goto err_dentry;
Eric Biggerse9bb1f92015-10-17 16:26:08 -0500778 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
Linus Torvalds98830352012-04-29 13:12:42 -0700780 f->f_flags = O_WRONLY | (flags & (O_NONBLOCK | O_DIRECT));
Al Virode32ec42013-03-21 11:16:56 -0400781 f->private_data = inode->i_pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782
Al Viro599a0ac2013-03-12 09:58:10 -0400783 res[0] = alloc_file(&path, FMODE_READ, &pipefifo_fops);
Eric Biggerse9bb1f92015-10-17 16:26:08 -0500784 if (IS_ERR(res[0])) {
785 err = PTR_ERR(res[0]);
Al Viroe4fad8e2012-07-21 15:33:25 +0400786 goto err_file;
Eric Biggerse9bb1f92015-10-17 16:26:08 -0500787 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
Al Viroe4fad8e2012-07-21 15:33:25 +0400789 path_get(&path);
Al Virode32ec42013-03-21 11:16:56 -0400790 res[0]->private_data = inode->i_pipe;
Al Viroe4fad8e2012-07-21 15:33:25 +0400791 res[0]->f_flags = O_RDONLY | (flags & O_NONBLOCK);
792 res[1] = f;
793 return 0;
794
795err_file:
796 put_filp(f);
797err_dentry:
Al Viro4b8a8f12013-03-21 11:06:46 -0400798 free_pipe_info(inode->i_pipe);
Al Viro2c48b9c2009-08-09 00:52:35 +0400799 path_put(&path);
Al Viroe4fad8e2012-07-21 15:33:25 +0400800 return err;
Al Viroed152432008-04-22 19:51:27 -0400801
Al Viroe4fad8e2012-07-21 15:33:25 +0400802err_inode:
Al Viro4b8a8f12013-03-21 11:06:46 -0400803 free_pipe_info(inode->i_pipe);
Andi Kleend6cbd282006-09-30 23:29:26 -0700804 iput(inode);
Al Viroe4fad8e2012-07-21 15:33:25 +0400805 return err;
Andi Kleend6cbd282006-09-30 23:29:26 -0700806}
807
Al Viro5b249b12012-08-19 12:17:29 -0400808static int __do_pipe_flags(int *fd, struct file **files, int flags)
Andi Kleend6cbd282006-09-30 23:29:26 -0700809{
Andi Kleend6cbd282006-09-30 23:29:26 -0700810 int error;
811 int fdw, fdr;
812
Linus Torvalds98830352012-04-29 13:12:42 -0700813 if (flags & ~(O_CLOEXEC | O_NONBLOCK | O_DIRECT))
Ulrich Dreppered8cae82008-07-23 21:29:30 -0700814 return -EINVAL;
815
Al Viroe4fad8e2012-07-21 15:33:25 +0400816 error = create_pipe_files(files, flags);
817 if (error)
818 return error;
Andi Kleend6cbd282006-09-30 23:29:26 -0700819
Ulrich Dreppered8cae82008-07-23 21:29:30 -0700820 error = get_unused_fd_flags(flags);
Andi Kleend6cbd282006-09-30 23:29:26 -0700821 if (error < 0)
822 goto err_read_pipe;
823 fdr = error;
824
Ulrich Dreppered8cae82008-07-23 21:29:30 -0700825 error = get_unused_fd_flags(flags);
Andi Kleend6cbd282006-09-30 23:29:26 -0700826 if (error < 0)
827 goto err_fdr;
828 fdw = error;
829
Al Viro157cf642008-12-14 04:57:47 -0500830 audit_fd_pair(fdr, fdw);
Andi Kleend6cbd282006-09-30 23:29:26 -0700831 fd[0] = fdr;
832 fd[1] = fdw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 return 0;
834
Andi Kleend6cbd282006-09-30 23:29:26 -0700835 err_fdr:
836 put_unused_fd(fdr);
837 err_read_pipe:
Al Viroe4fad8e2012-07-21 15:33:25 +0400838 fput(files[0]);
839 fput(files[1]);
Andi Kleend6cbd282006-09-30 23:29:26 -0700840 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841}
842
Al Viro5b249b12012-08-19 12:17:29 -0400843int do_pipe_flags(int *fd, int flags)
844{
845 struct file *files[2];
846 int error = __do_pipe_flags(fd, files, flags);
847 if (!error) {
848 fd_install(fd[0], files[0]);
849 fd_install(fd[1], files[1]);
850 }
851 return error;
852}
853
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854/*
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400855 * sys_pipe() is the normal C calling standard for creating
856 * a pipe. It's not the way Unix traditionally does this, though.
857 */
Heiko Carstensd4e82042009-01-14 14:14:34 +0100858SYSCALL_DEFINE2(pipe2, int __user *, fildes, int, flags)
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400859{
Al Viro5b249b12012-08-19 12:17:29 -0400860 struct file *files[2];
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400861 int fd[2];
862 int error;
863
Al Viro5b249b12012-08-19 12:17:29 -0400864 error = __do_pipe_flags(fd, files, flags);
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400865 if (!error) {
Al Viro5b249b12012-08-19 12:17:29 -0400866 if (unlikely(copy_to_user(fildes, fd, sizeof(fd)))) {
867 fput(files[0]);
868 fput(files[1]);
869 put_unused_fd(fd[0]);
870 put_unused_fd(fd[1]);
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400871 error = -EFAULT;
Al Viro5b249b12012-08-19 12:17:29 -0400872 } else {
873 fd_install(fd[0], files[0]);
874 fd_install(fd[1], files[1]);
Ulrich Drepperba719ba2008-05-06 20:42:38 -0700875 }
Ulrich Drepperd35c7b02008-05-03 15:10:37 -0400876 }
877 return error;
878}
879
Heiko Carstens2b664212009-01-14 14:14:35 +0100880SYSCALL_DEFINE1(pipe, int __user *, fildes)
Ulrich Dreppered8cae82008-07-23 21:29:30 -0700881{
882 return sys_pipe2(fildes, 0);
883}
884
Al Virofc7478a2013-03-21 02:07:59 -0400885static int wait_for_partner(struct pipe_inode_info *pipe, unsigned int *cnt)
Al Virof776c732013-03-12 09:46:27 -0400886{
887 int cur = *cnt;
888
889 while (cur == *cnt) {
Al Virofc7478a2013-03-21 02:07:59 -0400890 pipe_wait(pipe);
Al Virof776c732013-03-12 09:46:27 -0400891 if (signal_pending(current))
892 break;
893 }
894 return cur == *cnt ? -ERESTARTSYS : 0;
895}
896
Al Virofc7478a2013-03-21 02:07:59 -0400897static void wake_up_partner(struct pipe_inode_info *pipe)
Al Virof776c732013-03-12 09:46:27 -0400898{
Al Virofc7478a2013-03-21 02:07:59 -0400899 wake_up_interruptible(&pipe->wait);
Al Virof776c732013-03-12 09:46:27 -0400900}
901
902static int fifo_open(struct inode *inode, struct file *filp)
903{
904 struct pipe_inode_info *pipe;
Al Viro599a0ac2013-03-12 09:58:10 -0400905 bool is_pipe = inode->i_sb->s_magic == PIPEFS_MAGIC;
Al Virof776c732013-03-12 09:46:27 -0400906 int ret;
907
Al Viroba5bb142013-03-21 02:21:19 -0400908 filp->f_version = 0;
909
910 spin_lock(&inode->i_lock);
911 if (inode->i_pipe) {
912 pipe = inode->i_pipe;
913 pipe->files++;
914 spin_unlock(&inode->i_lock);
915 } else {
916 spin_unlock(&inode->i_lock);
Al Viro7bee1302013-03-21 11:04:15 -0400917 pipe = alloc_pipe_info();
Al Virof776c732013-03-12 09:46:27 -0400918 if (!pipe)
Al Viroba5bb142013-03-21 02:21:19 -0400919 return -ENOMEM;
920 pipe->files = 1;
921 spin_lock(&inode->i_lock);
922 if (unlikely(inode->i_pipe)) {
923 inode->i_pipe->files++;
924 spin_unlock(&inode->i_lock);
Al Viro4b8a8f12013-03-21 11:06:46 -0400925 free_pipe_info(pipe);
Al Viroba5bb142013-03-21 02:21:19 -0400926 pipe = inode->i_pipe;
927 } else {
928 inode->i_pipe = pipe;
929 spin_unlock(&inode->i_lock);
930 }
Al Virof776c732013-03-12 09:46:27 -0400931 }
Al Virode32ec42013-03-21 11:16:56 -0400932 filp->private_data = pipe;
Al Viroba5bb142013-03-21 02:21:19 -0400933 /* OK, we have a pipe and it's pinned down */
934
Al Viroebec73f2013-03-21 12:24:01 -0400935 __pipe_lock(pipe);
Al Virof776c732013-03-12 09:46:27 -0400936
937 /* We can only do regular read/write on fifos */
938 filp->f_mode &= (FMODE_READ | FMODE_WRITE);
939
940 switch (filp->f_mode) {
941 case FMODE_READ:
942 /*
943 * O_RDONLY
944 * POSIX.1 says that O_NONBLOCK means return with the FIFO
945 * opened, even when there is no process writing the FIFO.
946 */
Al Virof776c732013-03-12 09:46:27 -0400947 pipe->r_counter++;
948 if (pipe->readers++ == 0)
Al Virofc7478a2013-03-21 02:07:59 -0400949 wake_up_partner(pipe);
Al Virof776c732013-03-12 09:46:27 -0400950
Al Viro599a0ac2013-03-12 09:58:10 -0400951 if (!is_pipe && !pipe->writers) {
Al Virof776c732013-03-12 09:46:27 -0400952 if ((filp->f_flags & O_NONBLOCK)) {
953 /* suppress POLLHUP until we have
954 * seen a writer */
955 filp->f_version = pipe->w_counter;
956 } else {
Al Virofc7478a2013-03-21 02:07:59 -0400957 if (wait_for_partner(pipe, &pipe->w_counter))
Al Virof776c732013-03-12 09:46:27 -0400958 goto err_rd;
959 }
960 }
961 break;
962
963 case FMODE_WRITE:
964 /*
965 * O_WRONLY
966 * POSIX.1 says that O_NONBLOCK means return -1 with
967 * errno=ENXIO when there is no process reading the FIFO.
968 */
969 ret = -ENXIO;
Al Viro599a0ac2013-03-12 09:58:10 -0400970 if (!is_pipe && (filp->f_flags & O_NONBLOCK) && !pipe->readers)
Al Virof776c732013-03-12 09:46:27 -0400971 goto err;
972
Al Virof776c732013-03-12 09:46:27 -0400973 pipe->w_counter++;
974 if (!pipe->writers++)
Al Virofc7478a2013-03-21 02:07:59 -0400975 wake_up_partner(pipe);
Al Virof776c732013-03-12 09:46:27 -0400976
Al Viro599a0ac2013-03-12 09:58:10 -0400977 if (!is_pipe && !pipe->readers) {
Al Virofc7478a2013-03-21 02:07:59 -0400978 if (wait_for_partner(pipe, &pipe->r_counter))
Al Virof776c732013-03-12 09:46:27 -0400979 goto err_wr;
980 }
981 break;
982
983 case FMODE_READ | FMODE_WRITE:
984 /*
985 * O_RDWR
986 * POSIX.1 leaves this case "undefined" when O_NONBLOCK is set.
987 * This implementation will NEVER block on a O_RDWR open, since
988 * the process can at least talk to itself.
989 */
Al Virof776c732013-03-12 09:46:27 -0400990
991 pipe->readers++;
992 pipe->writers++;
993 pipe->r_counter++;
994 pipe->w_counter++;
995 if (pipe->readers == 1 || pipe->writers == 1)
Al Virofc7478a2013-03-21 02:07:59 -0400996 wake_up_partner(pipe);
Al Virof776c732013-03-12 09:46:27 -0400997 break;
998
999 default:
1000 ret = -EINVAL;
1001 goto err;
1002 }
1003
1004 /* Ok! */
Al Viroebec73f2013-03-21 12:24:01 -04001005 __pipe_unlock(pipe);
Al Virof776c732013-03-12 09:46:27 -04001006 return 0;
1007
1008err_rd:
1009 if (!--pipe->readers)
1010 wake_up_interruptible(&pipe->wait);
1011 ret = -ERESTARTSYS;
1012 goto err;
1013
1014err_wr:
1015 if (!--pipe->writers)
1016 wake_up_interruptible(&pipe->wait);
1017 ret = -ERESTARTSYS;
1018 goto err;
1019
1020err:
Al Viroebec73f2013-03-21 12:24:01 -04001021 __pipe_unlock(pipe);
Linus Torvaldsb0d8d222013-12-02 09:44:51 -08001022
1023 put_pipe_info(inode, pipe);
Al Virof776c732013-03-12 09:46:27 -04001024 return ret;
1025}
1026
Al Viro599a0ac2013-03-12 09:58:10 -04001027const struct file_operations pipefifo_fops = {
1028 .open = fifo_open,
1029 .llseek = no_llseek,
Al Virofb9096a2014-04-02 19:56:54 -04001030 .read_iter = pipe_read,
Al Virof0d1bec2014-04-03 15:05:18 -04001031 .write_iter = pipe_write,
Al Viro599a0ac2013-03-12 09:58:10 -04001032 .poll = pipe_poll,
1033 .unlocked_ioctl = pipe_ioctl,
1034 .release = pipe_release,
1035 .fasync = pipe_fasync,
Al Virof776c732013-03-12 09:46:27 -04001036};
1037
Ulrich Drepperd35c7b02008-05-03 15:10:37 -04001038/*
Michael Kerrisk (man-pages)f491bd72016-10-11 13:53:22 -07001039 * Currently we rely on the pipe array holding a power-of-2 number
Joe Lawrence5b13f592017-11-17 15:29:21 -08001040 * of pages. Returns 0 on error.
Michael Kerrisk (man-pages)f491bd72016-10-11 13:53:22 -07001041 */
1042static inline unsigned int round_pipe_size(unsigned int size)
1043{
1044 unsigned long nr_pages;
1045
Joe Lawrence5b13f592017-11-17 15:29:21 -08001046 if (size < pipe_min_size)
1047 size = pipe_min_size;
1048
Michael Kerrisk (man-pages)f491bd72016-10-11 13:53:22 -07001049 nr_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
Joe Lawrence5b13f592017-11-17 15:29:21 -08001050 if (nr_pages == 0)
1051 return 0;
1052
Michael Kerrisk (man-pages)f491bd72016-10-11 13:53:22 -07001053 return roundup_pow_of_two(nr_pages) << PAGE_SHIFT;
1054}
1055
1056/*
Jens Axboe35f3d142010-05-20 10:43:18 +02001057 * Allocate a new array of pipe buffers and copy the info over. Returns the
1058 * pipe size if successful, or return -ERROR on error.
1059 */
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001060static long pipe_set_size(struct pipe_inode_info *pipe, unsigned long arg)
Jens Axboe35f3d142010-05-20 10:43:18 +02001061{
1062 struct pipe_buffer *bufs;
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001063 unsigned int size, nr_pages;
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -07001064 unsigned long user_bufs;
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001065 long ret = 0;
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001066
1067 size = round_pipe_size(arg);
Joe Lawrence5b13f592017-11-17 15:29:21 -08001068 if (size == 0)
1069 return -EINVAL;
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001070 nr_pages = size >> PAGE_SHIFT;
1071
1072 if (!nr_pages)
1073 return -EINVAL;
1074
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001075 /*
1076 * If trying to increase the pipe capacity, check that an
1077 * unprivileged user is not trying to exceed various limits
1078 * (soft limit check here, hard limit check just below).
1079 * Decreasing the pipe capacity is always permitted, even
1080 * if the user is currently over a limit.
1081 */
1082 if (nr_pages > pipe->buffers &&
1083 size > pipe_max_size && !capable(CAP_SYS_RESOURCE))
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001084 return -EPERM;
1085
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -07001086 user_bufs = account_pipe_buffers(pipe->user, pipe->buffers, nr_pages);
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001087
1088 if (nr_pages > pipe->buffers &&
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -07001089 (too_many_pipe_buffers_hard(user_bufs) ||
1090 too_many_pipe_buffers_soft(user_bufs)) &&
Eric Biggersa705c242018-02-06 15:41:53 -08001091 is_unprivileged_user()) {
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001092 ret = -EPERM;
1093 goto out_revert_acct;
1094 }
Jens Axboe35f3d142010-05-20 10:43:18 +02001095
1096 /*
Jens Axboe35f3d142010-05-20 10:43:18 +02001097 * We can shrink the pipe, if arg >= pipe->nrbufs. Since we don't
1098 * expect a lot of shrink+grow operations, just free and allocate
1099 * again like we would do for growing. If the pipe currently
1100 * contains more buffers than arg, then return busy.
1101 */
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001102 if (nr_pages < pipe->nrbufs) {
1103 ret = -EBUSY;
1104 goto out_revert_acct;
1105 }
Jens Axboe35f3d142010-05-20 10:43:18 +02001106
Vladimir Davydovd86133b2016-07-26 15:24:33 -07001107 bufs = kcalloc(nr_pages, sizeof(*bufs),
1108 GFP_KERNEL_ACCOUNT | __GFP_NOWARN);
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001109 if (unlikely(!bufs)) {
1110 ret = -ENOMEM;
1111 goto out_revert_acct;
1112 }
Jens Axboe35f3d142010-05-20 10:43:18 +02001113
1114 /*
1115 * The pipe array wraps around, so just start the new one at zero
1116 * and adjust the indexes.
1117 */
1118 if (pipe->nrbufs) {
Miklos Szeredi1d862f42010-06-08 16:28:45 +02001119 unsigned int tail;
1120 unsigned int head;
Jens Axboe35f3d142010-05-20 10:43:18 +02001121
Miklos Szeredi1d862f42010-06-08 16:28:45 +02001122 tail = pipe->curbuf + pipe->nrbufs;
1123 if (tail < pipe->buffers)
1124 tail = 0;
1125 else
1126 tail &= (pipe->buffers - 1);
1127
1128 head = pipe->nrbufs - tail;
Jens Axboe35f3d142010-05-20 10:43:18 +02001129 if (head)
1130 memcpy(bufs, pipe->bufs + pipe->curbuf, head * sizeof(struct pipe_buffer));
1131 if (tail)
Miklos Szeredi1d862f42010-06-08 16:28:45 +02001132 memcpy(bufs + head, pipe->bufs, tail * sizeof(struct pipe_buffer));
Jens Axboe35f3d142010-05-20 10:43:18 +02001133 }
1134
1135 pipe->curbuf = 0;
1136 kfree(pipe->bufs);
1137 pipe->bufs = bufs;
Jens Axboeb9598db2010-05-24 19:34:43 +02001138 pipe->buffers = nr_pages;
1139 return nr_pages * PAGE_SIZE;
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001140
1141out_revert_acct:
Michael Kerrisk (man-pages)9c87bcf2016-10-11 13:53:40 -07001142 (void) account_pipe_buffers(pipe->user, nr_pages, pipe->buffers);
Michael Kerrisk (man-pages)b0b91d12016-10-11 13:53:31 -07001143 return ret;
Jens Axboe35f3d142010-05-20 10:43:18 +02001144}
1145
Jens Axboeff9da692010-06-03 14:54:39 +02001146/*
Jens Axboeff9da692010-06-03 14:54:39 +02001147 * This should work even if CONFIG_PROC_FS isn't set, as proc_dointvec_minmax
1148 * will return an error.
1149 */
1150int pipe_proc_fn(struct ctl_table *table, int write, void __user *buf,
1151 size_t *lenp, loff_t *ppos)
1152{
Joe Lawrence5b13f592017-11-17 15:29:21 -08001153 unsigned int rounded_pipe_max_size;
Jens Axboeff9da692010-06-03 14:54:39 +02001154 int ret;
1155
1156 ret = proc_dointvec_minmax(table, write, buf, lenp, ppos);
1157 if (ret < 0 || !write)
1158 return ret;
1159
Joe Lawrence5b13f592017-11-17 15:29:21 -08001160 rounded_pipe_max_size = round_pipe_size(pipe_max_size);
1161 if (rounded_pipe_max_size == 0)
1162 return -EINVAL;
1163
1164 pipe_max_size = rounded_pipe_max_size;
Jens Axboeff9da692010-06-03 14:54:39 +02001165 return ret;
1166}
1167
Linus Torvalds72083642010-11-28 16:27:19 -08001168/*
1169 * After the inode slimming patch, i_pipe/i_bdev/i_cdev share the same
1170 * location, so checking ->i_pipe is not enough to verify that this is a
1171 * pipe.
1172 */
1173struct pipe_inode_info *get_pipe_info(struct file *file)
1174{
Al Virode32ec42013-03-21 11:16:56 -04001175 return file->f_op == &pipefifo_fops ? file->private_data : NULL;
Linus Torvalds72083642010-11-28 16:27:19 -08001176}
1177
Jens Axboe35f3d142010-05-20 10:43:18 +02001178long pipe_fcntl(struct file *file, unsigned int cmd, unsigned long arg)
1179{
1180 struct pipe_inode_info *pipe;
1181 long ret;
1182
Linus Torvaldsc66fb342010-11-28 14:09:57 -08001183 pipe = get_pipe_info(file);
Jens Axboe35f3d142010-05-20 10:43:18 +02001184 if (!pipe)
1185 return -EBADF;
1186
Al Viroebec73f2013-03-21 12:24:01 -04001187 __pipe_lock(pipe);
Jens Axboe35f3d142010-05-20 10:43:18 +02001188
1189 switch (cmd) {
Michael Kerrisk (man-pages)d37d4162016-10-11 13:53:25 -07001190 case F_SETPIPE_SZ:
1191 ret = pipe_set_size(pipe, arg);
Jens Axboe35f3d142010-05-20 10:43:18 +02001192 break;
1193 case F_GETPIPE_SZ:
Jens Axboeb9598db2010-05-24 19:34:43 +02001194 ret = pipe->buffers * PAGE_SIZE;
Jens Axboe35f3d142010-05-20 10:43:18 +02001195 break;
1196 default:
1197 ret = -EINVAL;
1198 break;
1199 }
1200
Al Viroebec73f2013-03-21 12:24:01 -04001201 __pipe_unlock(pipe);
Jens Axboe35f3d142010-05-20 10:43:18 +02001202 return ret;
1203}
1204
Nick Pigginff0c7d12011-01-07 17:49:50 +11001205static const struct super_operations pipefs_ops = {
1206 .destroy_inode = free_inode_nonrcu,
Pavel Emelyanovd70ef972011-10-31 17:10:04 -07001207 .statfs = simple_statfs,
Nick Pigginff0c7d12011-01-07 17:49:50 +11001208};
1209
Jens Axboe35f3d142010-05-20 10:43:18 +02001210/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 * pipefs should _never_ be mounted by userland - too much of security hassle,
1212 * no real gain from having the whole whorehouse mounted. So we don't need
1213 * any operations on the root directory. However, we need a non-trivial
1214 * d_name - pipe: will go nicely and kill the special-casing in procfs.
1215 */
Al Viro51139ad2010-07-25 23:47:46 +04001216static struct dentry *pipefs_mount(struct file_system_type *fs_type,
1217 int flags, const char *dev_name, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218{
Al Viroc74a1cb2011-01-12 16:59:34 -05001219 return mount_pseudo(fs_type, "pipe:", &pipefs_ops,
1220 &pipefs_dentry_operations, PIPEFS_MAGIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221}
1222
1223static struct file_system_type pipe_fs_type = {
1224 .name = "pipefs",
Al Viro51139ad2010-07-25 23:47:46 +04001225 .mount = pipefs_mount,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 .kill_sb = kill_anon_super,
1227};
1228
1229static int __init init_pipe_fs(void)
1230{
1231 int err = register_filesystem(&pipe_fs_type);
Ingo Molnar341b4462006-04-11 13:57:45 +02001232
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 if (!err) {
1234 pipe_mnt = kern_mount(&pipe_fs_type);
1235 if (IS_ERR(pipe_mnt)) {
1236 err = PTR_ERR(pipe_mnt);
1237 unregister_filesystem(&pipe_fs_type);
1238 }
1239 }
1240 return err;
1241}
1242
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243fs_initcall(init_pipe_fs);