Branch data Line data Source code
1 : : /*
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>
14 : : #include <linux/log2.h>
15 : : #include <linux/mount.h>
16 : : #include <linux/magic.h>
17 : : #include <linux/pipe_fs_i.h>
18 : : #include <linux/uio.h>
19 : : #include <linux/highmem.h>
20 : : #include <linux/pagemap.h>
21 : : #include <linux/audit.h>
22 : : #include <linux/syscalls.h>
23 : : #include <linux/fcntl.h>
24 : : #include <linux/aio.h>
25 : :
26 : : #include <asm/uaccess.h>
27 : : #include <asm/ioctls.h>
28 : :
29 : : #include "internal.h"
30 : :
31 : : /*
32 : : * The max size that a non-root user is allowed to grow the pipe. Can
33 : : * be set by root in /proc/sys/fs/pipe-max-size
34 : : */
35 : : unsigned int pipe_max_size = 1048576;
36 : :
37 : : /*
38 : : * Minimum pipe size, as required by POSIX
39 : : */
40 : : unsigned int pipe_min_size = PAGE_SIZE;
41 : :
42 : : /*
43 : : * We use a start+len construction, which provides full use of the
44 : : * allocated memory.
45 : : * -- Florian Coosmann (FGC)
46 : : *
47 : : * Reads with count = 0 should always return 0.
48 : : * -- Julian Bradfield 1999-06-07.
49 : : *
50 : : * FIFOs and Pipes now generate SIGIO for both readers and writers.
51 : : * -- Jeremy Elson <jelson@circlemud.org> 2001-08-16
52 : : *
53 : : * pipe_read & write cleanup
54 : : * -- Manfred Spraul <manfred@colorfullife.com> 2002-05-09
55 : : */
56 : :
57 : : static void pipe_lock_nested(struct pipe_inode_info *pipe, int subclass)
58 : : {
59 [ + ][ + - ]: 44697 : if (pipe->files)
[ + - ][ # # ]
[ # # ][ + + ]
60 : 42321 : mutex_lock_nested(&pipe->mutex, subclass);
61 : : }
62 : :
63 : 0 : void pipe_lock(struct pipe_inode_info *pipe)
64 : : {
65 : : /*
66 : : * pipe_lock() nests non-pipe inode locks (for writing to a file)
67 : : */
68 : : pipe_lock_nested(pipe, I_MUTEX_PARENT);
69 : 0 : }
70 : : EXPORT_SYMBOL(pipe_lock);
71 : :
72 : 0 : void pipe_unlock(struct pipe_inode_info *pipe)
73 : : {
74 [ + - ][ + + ]: 44700 : if (pipe->files)
75 : 42322 : mutex_unlock(&pipe->mutex);
76 : 0 : }
77 : : EXPORT_SYMBOL(pipe_unlock);
78 : :
79 : : static inline void __pipe_lock(struct pipe_inode_info *pipe)
80 : : {
81 : 1759485 : mutex_lock_nested(&pipe->mutex, I_MUTEX_PARENT);
82 : : }
83 : :
84 : : static inline void __pipe_unlock(struct pipe_inode_info *pipe)
85 : : {
86 : 1752423 : mutex_unlock(&pipe->mutex);
87 : : }
88 : :
89 : 0 : void pipe_double_lock(struct pipe_inode_info *pipe1,
90 : : struct pipe_inode_info *pipe2)
91 : : {
92 [ - + ]: 1 : BUG_ON(pipe1 == pipe2);
93 : :
94 [ + - ]: 1 : if (pipe1 < pipe2) {
95 : : pipe_lock_nested(pipe1, I_MUTEX_PARENT);
96 : : pipe_lock_nested(pipe2, I_MUTEX_CHILD);
97 : : } else {
98 : : pipe_lock_nested(pipe2, I_MUTEX_PARENT);
99 : : pipe_lock_nested(pipe1, I_MUTEX_CHILD);
100 : : }
101 : 1 : }
102 : :
103 : : /* Drop the inode semaphore and wait for a pipe event, atomically */
104 : 0 : void pipe_wait(struct pipe_inode_info *pipe)
105 : : {
106 : 47296 : DEFINE_WAIT(wait);
107 : :
108 : : /*
109 : : * Pipes are system-local resources, so sleeping on them
110 : : * is considered a noninteractive wait:
111 : : */
112 : 23648 : prepare_to_wait(&pipe->wait, &wait, TASK_INTERRUPTIBLE);
113 : : pipe_unlock(pipe);
114 : 23648 : schedule();
115 : 23646 : finish_wait(&pipe->wait, &wait);
116 : : pipe_lock(pipe);
117 : 23646 : }
118 : :
119 : : static int
120 : 0 : pipe_iov_copy_from_user(void *to, struct iovec *iov, unsigned long len,
121 : : int atomic)
122 : : {
123 : : unsigned long copy;
124 : :
125 [ + + ]: 1329753 : while (len > 0) {
126 [ + + ]: 664892 : while (!iov->iov_len)
127 : 10 : iov++;
128 : 664882 : copy = min_t(unsigned long, len, iov->iov_len);
129 : :
130 [ + - ]: 664882 : if (atomic) {
131 [ + - ]: 664882 : if (__copy_from_user_inatomic(to, iov->iov_base, copy))
132 : : return -EFAULT;
133 : : } else {
134 [ # # ]: 0 : if (copy_from_user(to, iov->iov_base, copy))
135 : : return -EFAULT;
136 : : }
137 : 664881 : to += copy;
138 : 664881 : len -= copy;
139 : 664881 : iov->iov_base += copy;
140 : 664881 : iov->iov_len -= copy;
141 : : }
142 : : return 0;
143 : : }
144 : :
145 : : static int
146 : 0 : pipe_iov_copy_to_user(struct iovec *iov, const void *from, unsigned long len,
147 : : int atomic)
148 : : {
149 : : unsigned long copy;
150 : :
151 [ + + ]: 613109 : while (len > 0) {
152 [ - + ]: 306555 : while (!iov->iov_len)
153 : 0 : iov++;
154 : 306555 : copy = min_t(unsigned long, len, iov->iov_len);
155 : :
156 [ + - ]: 306555 : if (atomic) {
157 [ + - ]: 306555 : if (__copy_to_user_inatomic(iov->iov_base, from, copy))
158 : : return -EFAULT;
159 : : } else {
160 [ # # ]: 0 : if (copy_to_user(iov->iov_base, from, copy))
161 : : return -EFAULT;
162 : : }
163 : 306555 : from += copy;
164 : 306555 : len -= copy;
165 : 306555 : iov->iov_base += copy;
166 : 306555 : iov->iov_len -= copy;
167 : : }
168 : : return 0;
169 : : }
170 : :
171 : : /*
172 : : * Attempt to pre-fault in the user memory, so we can use atomic copies.
173 : : * Returns the number of bytes not faulted in.
174 : : */
175 : 0 : static int iov_fault_in_pages_write(struct iovec *iov, unsigned long len)
176 : : {
177 [ - + ]: 306549 : while (!iov->iov_len)
178 : 0 : iov++;
179 : :
180 [ + + ]: 613093 : while (len > 0) {
181 : : unsigned long this_len;
182 : :
183 : 306548 : this_len = min_t(unsigned long, len, iov->iov_len);
184 [ + - ]: 306544 : if (fault_in_pages_writeable(iov->iov_base, this_len))
185 : : break;
186 : :
187 : 306544 : len -= this_len;
188 : 306544 : iov++;
189 : : }
190 : :
191 : 306545 : return len;
192 : : }
193 : :
194 : : /*
195 : : * Pre-fault in the user memory, so we can use atomic copies.
196 : : */
197 : 0 : static void iov_fault_in_pages_read(struct iovec *iov, unsigned long len)
198 : : {
199 [ - + ]: 664882 : while (!iov->iov_len)
200 : 0 : iov++;
201 : :
202 [ + + ]: 1329732 : while (len > 0) {
203 : : unsigned long this_len;
204 : :
205 : 664870 : this_len = min_t(unsigned long, len, iov->iov_len);
206 : 664870 : fault_in_pages_readable(iov->iov_base, this_len);
207 : 664850 : len -= this_len;
208 : 664850 : iov++;
209 : : }
210 : 664862 : }
211 : :
212 : 0 : static void anon_pipe_buf_release(struct pipe_inode_info *pipe,
213 : : struct pipe_buffer *buf)
214 : : {
215 : 385353 : struct page *page = buf->page;
216 : :
217 : : /*
218 : : * If nobody else uses this page, and we don't already have a
219 : : * temporary page, let's keep track of it as a one-deep
220 : : * allocation cache. (Otherwise just release our reference to it)
221 : : */
222 [ + - ][ + + ]: 385353 : if (page_count(page) == 1 && !pipe->tmp_page)
223 : 384126 : pipe->tmp_page = page;
224 : : else
225 : 1227 : page_cache_release(page);
226 : 385353 : }
227 : :
228 : : /**
229 : : * generic_pipe_buf_map - virtually map a pipe buffer
230 : : * @pipe: the pipe that the buffer belongs to
231 : : * @buf: the buffer that should be mapped
232 : : * @atomic: whether to use an atomic map
233 : : *
234 : : * Description:
235 : : * This function returns a kernel virtual address mapping for the
236 : : * pipe_buffer passed in @buf. If @atomic is set, an atomic map is provided
237 : : * and the caller has to be careful not to fault before calling
238 : : * the unmap function.
239 : : *
240 : : * Note that this function calls kmap_atomic() if @atomic != 0.
241 : : */
242 : 0 : void *generic_pipe_buf_map(struct pipe_inode_info *pipe,
243 : : struct pipe_buffer *buf, int atomic)
244 : : {
245 [ + - ]: 605391 : if (atomic) {
246 : 605391 : buf->flags |= PIPE_BUF_FLAG_ATOMIC;
247 : 605391 : return kmap_atomic(buf->page);
248 : : }
249 : :
250 : 0 : return kmap(buf->page);
251 : : }
252 : : EXPORT_SYMBOL(generic_pipe_buf_map);
253 : :
254 : : /**
255 : : * generic_pipe_buf_unmap - unmap a previously mapped pipe buffer
256 : : * @pipe: the pipe that the buffer belongs to
257 : : * @buf: the buffer that should be unmapped
258 : : * @map_data: the data that the mapping function returned
259 : : *
260 : : * Description:
261 : : * This function undoes the mapping that ->map() provided.
262 : : */
263 : 0 : void generic_pipe_buf_unmap(struct pipe_inode_info *pipe,
264 : : struct pipe_buffer *buf, void *map_data)
265 : : {
266 [ + - ]: 605398 : if (buf->flags & PIPE_BUF_FLAG_ATOMIC) {
267 : 605398 : buf->flags &= ~PIPE_BUF_FLAG_ATOMIC;
268 : 605398 : kunmap_atomic(map_data);
269 : : } else
270 : 0 : kunmap(buf->page);
271 : 605399 : }
272 : : EXPORT_SYMBOL(generic_pipe_buf_unmap);
273 : :
274 : : /**
275 : : * generic_pipe_buf_steal - attempt to take ownership of a &pipe_buffer
276 : : * @pipe: the pipe that the buffer belongs to
277 : : * @buf: the buffer to attempt to steal
278 : : *
279 : : * Description:
280 : : * This function attempts to steal the &struct page attached to
281 : : * @buf. If successful, this function returns 0 and returns with
282 : : * the page locked. The caller may then reuse the page for whatever
283 : : * he wishes; the typical use is insertion into a different file
284 : : * page cache.
285 : : */
286 : 0 : int generic_pipe_buf_steal(struct pipe_inode_info *pipe,
287 : : struct pipe_buffer *buf)
288 : : {
289 : 0 : struct page *page = buf->page;
290 : :
291 : : /*
292 : : * A reference of one is golden, that means that the owner of this
293 : : * page is the only one holding a reference to it. lock the page
294 : : * and return OK.
295 : : */
296 [ # # ]: 0 : if (page_count(page) == 1) {
297 : : lock_page(page);
298 : : return 0;
299 : : }
300 : :
301 : : return 1;
302 : : }
303 : : EXPORT_SYMBOL(generic_pipe_buf_steal);
304 : :
305 : : /**
306 : : * generic_pipe_buf_get - get a reference to a &struct pipe_buffer
307 : : * @pipe: the pipe that the buffer belongs to
308 : : * @buf: the buffer to get a reference to
309 : : *
310 : : * Description:
311 : : * This function grabs an extra reference to @buf. It's used in
312 : : * in the tee() system call, when we duplicate the buffers in one
313 : : * pipe into another.
314 : : */
315 : 0 : void generic_pipe_buf_get(struct pipe_inode_info *pipe, struct pipe_buffer *buf)
316 : : {
317 : 1 : page_cache_get(buf->page);
318 : 1 : }
319 : : EXPORT_SYMBOL(generic_pipe_buf_get);
320 : :
321 : : /**
322 : : * generic_pipe_buf_confirm - verify contents of the pipe buffer
323 : : * @info: the pipe that the buffer belongs to
324 : : * @buf: the buffer to confirm
325 : : *
326 : : * Description:
327 : : * This function does nothing, because the generic pipe code uses
328 : : * pages that are always good when inserted into the pipe.
329 : : */
330 : 0 : int generic_pipe_buf_confirm(struct pipe_inode_info *info,
331 : : struct pipe_buffer *buf)
332 : : {
333 : 605385 : return 0;
334 : : }
335 : : EXPORT_SYMBOL(generic_pipe_buf_confirm);
336 : :
337 : : /**
338 : : * generic_pipe_buf_release - put a reference to a &struct pipe_buffer
339 : : * @pipe: the pipe that the buffer belongs to
340 : : * @buf: the buffer to put a reference to
341 : : *
342 : : * Description:
343 : : * This function releases a reference to @buf.
344 : : */
345 : 0 : void generic_pipe_buf_release(struct pipe_inode_info *pipe,
346 : : struct pipe_buffer *buf)
347 : : {
348 : 0 : page_cache_release(buf->page);
349 : 0 : }
350 : : EXPORT_SYMBOL(generic_pipe_buf_release);
351 : :
352 : : static const struct pipe_buf_operations anon_pipe_buf_ops = {
353 : : .can_merge = 1,
354 : : .map = generic_pipe_buf_map,
355 : : .unmap = generic_pipe_buf_unmap,
356 : : .confirm = generic_pipe_buf_confirm,
357 : : .release = anon_pipe_buf_release,
358 : : .steal = generic_pipe_buf_steal,
359 : : .get = generic_pipe_buf_get,
360 : : };
361 : :
362 : : static const struct pipe_buf_operations packet_pipe_buf_ops = {
363 : : .can_merge = 0,
364 : : .map = generic_pipe_buf_map,
365 : : .unmap = generic_pipe_buf_unmap,
366 : : .confirm = generic_pipe_buf_confirm,
367 : : .release = anon_pipe_buf_release,
368 : : .steal = generic_pipe_buf_steal,
369 : : .get = generic_pipe_buf_get,
370 : : };
371 : :
372 : : static ssize_t
373 : 0 : pipe_read(struct kiocb *iocb, const struct iovec *_iov,
374 : : unsigned long nr_segs, loff_t pos)
375 : : {
376 : 390928 : struct file *filp = iocb->ki_filp;
377 : 390928 : struct pipe_inode_info *pipe = filp->private_data;
378 : : int do_wakeup;
379 : : ssize_t ret;
380 : : struct iovec *iov = (struct iovec *)_iov;
381 : : size_t total_len;
382 : :
383 : : total_len = iov_length(iov, nr_segs);
384 : : /* Null read succeeds. */
385 [ + + ]: 390928 : if (unlikely(total_len == 0))
386 : : return 0;
387 : :
388 : : do_wakeup = 0;
389 : : ret = 0;
390 : : __pipe_lock(pipe);
391 : : for (;;) {
392 : 397969 : int bufs = pipe->nrbufs;
393 [ + + ]: 397969 : if (bufs) {
394 : 306530 : int curbuf = pipe->curbuf;
395 : 306530 : struct pipe_buffer *buf = pipe->bufs + curbuf;
396 : 306530 : const struct pipe_buf_operations *ops = buf->ops;
397 : : void *addr;
398 : 306530 : size_t chars = buf->len;
399 : : int error, atomic;
400 : :
401 [ + + ]: 306530 : if (chars > total_len)
402 : : chars = total_len;
403 : :
404 : 306530 : error = ops->confirm(pipe, buf);
405 [ - + ]: 306536 : if (error) {
406 [ # # ]: 0 : if (!ret)
407 : : ret = error;
408 : : break;
409 : : }
410 : :
411 : 306536 : atomic = !iov_fault_in_pages_write(iov, chars);
412 : : redo:
413 : 306525 : addr = ops->map(pipe, buf, atomic);
414 : 306555 : error = pipe_iov_copy_to_user(iov, addr + buf->offset, chars, atomic);
415 : 306554 : ops->unmap(pipe, buf, addr);
416 [ - + ]: 306553 : if (unlikely(error)) {
417 : : /*
418 : : * Just retry with the slow path if we failed.
419 : : */
420 [ # # ]: 0 : if (atomic) {
421 : : atomic = 0;
422 : : goto redo;
423 : : }
424 [ # # ]: 0 : if (!ret)
425 : : ret = error;
426 : : break;
427 : : }
428 : 306553 : ret += chars;
429 : 306553 : buf->offset += chars;
430 : 306553 : buf->len -= chars;
431 : :
432 : : /* Was it a packet buffer? Clean up and exit */
433 [ - + ]: 306553 : if (buf->flags & PIPE_BUF_FLAG_PACKET) {
434 : : total_len = chars;
435 : 0 : buf->len = 0;
436 : : }
437 : :
438 [ + + ]: 306553 : if (!buf->len) {
439 : 25669 : buf->ops = NULL;
440 : 25669 : ops->release(pipe, buf);
441 : 25671 : curbuf = (curbuf + 1) & (pipe->buffers - 1);
442 : 25671 : pipe->curbuf = curbuf;
443 : 25671 : pipe->nrbufs = --bufs;
444 : : do_wakeup = 1;
445 : : }
446 : 306555 : total_len -= chars;
447 [ + + ]: 306555 : if (!total_len)
448 : : break; /* common path: read succeeded */
449 : : }
450 [ + + ]: 93415 : if (bufs) /* More to do? */
451 : 6 : continue;
452 [ + + ]: 93409 : if (!pipe->writers)
453 : : break;
454 [ + + ]: 39581 : if (!pipe->waiting_writers) {
455 : : /* syscall merging: Usually we must not sleep
456 : : * if O_NONBLOCK is set, or if we got some data.
457 : : * But if a writer sleeps in kernel space, then
458 : : * we can wait for that data without violating POSIX.
459 : : */
460 [ + + ]: 39577 : if (ret)
461 : : break;
462 [ + + ]: 38809 : if (filp->f_flags & O_NONBLOCK) {
463 : : ret = -EAGAIN;
464 : : break;
465 : : }
466 : : }
467 [ - + ]: 7059 : if (signal_pending(current)) {
468 [ # # ]: 0 : if (!ret)
469 : : ret = -ERESTARTSYS;
470 : : break;
471 : : }
472 [ - + ]: 7059 : if (do_wakeup) {
473 : 0 : wake_up_interruptible_sync_poll(&pipe->wait, POLLOUT | POLLWRNORM);
474 : 0 : kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
475 : : }
476 : 7059 : pipe_wait(pipe);
477 : : }
478 : : __pipe_unlock(pipe);
479 : :
480 : : /* Signal writers asynchronously that there is more room. */
481 [ + + ]: 390926 : if (do_wakeup) {
482 : 25658 : wake_up_interruptible_sync_poll(&pipe->wait, POLLOUT | POLLWRNORM);
483 : 25664 : kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
484 : : }
485 [ + + ]: 390923 : if (ret > 0)
486 : : file_accessed(filp);
487 : 390922 : return ret;
488 : : }
489 : :
490 : : static inline int is_packetized(struct file *file)
491 : : {
492 : 385352 : return (file->f_flags & O_DIRECT) != 0;
493 : : }
494 : :
495 : : static ssize_t
496 : 0 : pipe_write(struct kiocb *iocb, const struct iovec *_iov,
497 : : unsigned long nr_segs, loff_t ppos)
498 : : {
499 : 2379895 : struct file *filp = iocb->ki_filp;
500 : 664852 : struct pipe_inode_info *pipe = filp->private_data;
501 : : ssize_t ret;
502 : : int do_wakeup;
503 : : struct iovec *iov = (struct iovec *)_iov;
504 : : size_t total_len;
505 : : ssize_t chars;
506 : :
507 : : total_len = iov_length(iov, nr_segs);
508 : : /* Null write succeeds. */
509 [ + ]: 664852 : if (unlikely(total_len == 0))
510 : : return 0;
511 : :
512 : : do_wakeup = 0;
513 : : ret = 0;
514 : : __pipe_lock(pipe);
515 : :
516 [ + + ]: 664839 : if (!pipe->readers) {
517 : 5 : send_sig(SIGPIPE, current, 0);
518 : : ret = -EPIPE;
519 : 5 : goto out;
520 : : }
521 : :
522 : : /* We try to merge small writes */
523 : 664834 : chars = total_len & (PAGE_SIZE-1); /* size of the last buffer */
524 [ + + ][ + + ]: 664834 : if (pipe->nrbufs && chars != 0) {
525 : 588652 : int lastbuf = (pipe->curbuf + pipe->nrbufs - 1) &
526 : 294326 : (pipe->buffers - 1);
527 : 294326 : struct pipe_buffer *buf = pipe->bufs + lastbuf;
528 : 294326 : const struct pipe_buf_operations *ops = buf->ops;
529 : 294326 : int offset = buf->offset + buf->len;
530 : :
531 [ + + ][ + + ]: 664844 : if (ops->can_merge && offset + chars <= PAGE_SIZE) {
532 : : int error, atomic = 1;
533 : : void *addr;
534 : :
535 : 279514 : error = ops->confirm(pipe, buf);
536 [ + - ]: 279514 : if (error)
537 : : goto out;
538 : :
539 : 279514 : iov_fault_in_pages_read(iov, chars);
540 : : redo1:
541 : 279519 : addr = ops->map(pipe, buf, atomic);
542 : 279519 : error = pipe_iov_copy_from_user(offset + addr, iov,
543 : : chars, atomic);
544 : 279519 : ops->unmap(pipe, buf, addr);
545 : : ret = error;
546 : : do_wakeup = 1;
547 [ - + ]: 279519 : if (error) {
548 [ # # ]: 0 : if (atomic) {
549 : : atomic = 0;
550 : : goto redo1;
551 : : }
552 : : goto out;
553 : : }
554 : 279519 : buf->len += chars;
555 : 279519 : total_len -= chars;
556 : : ret = chars;
557 [ + + ]: 295846 : if (!total_len)
558 : : goto out;
559 : : }
560 : : }
561 : :
562 : : for (;;) {
563 : : int bufs;
564 : :
565 [ - + ]: 401657 : if (!pipe->readers) {
566 : 0 : send_sig(SIGPIPE, current, 0);
567 [ # # ]: 0 : if (!ret)
568 : : ret = -EPIPE;
569 : : break;
570 : : }
571 : 401657 : bufs = pipe->nrbufs;
572 [ + + ]: 401657 : if (bufs < pipe->buffers) {
573 : 385348 : int newbuf = (pipe->curbuf + bufs) & (pipe->buffers-1);
574 : 385348 : struct pipe_buffer *buf = pipe->bufs + newbuf;
575 : 385348 : struct page *page = pipe->tmp_page;
576 : : char *src;
577 : : int error, atomic = 1;
578 : :
579 [ + + ]: 385348 : if (!page) {
580 : : page = alloc_page(GFP_HIGHUSER);
581 [ - + ]: 344162 : if (unlikely(!page)) {
582 [ # # ]: 0 : ret = ret ? : -ENOMEM;
583 : 0 : break;
584 : : }
585 : 344162 : pipe->tmp_page = page;
586 : : }
587 : : /* Always wake up, even if the copy fails. Otherwise
588 : : * we lock up (O_NONBLOCK-)readers that sleep due to
589 : : * syscall merging.
590 : : * FIXME! Is this really true?
591 : : */
592 : : do_wakeup = 1;
593 : : chars = PAGE_SIZE;
594 [ + + ]: 385348 : if (chars > total_len)
595 : 185914 : chars = total_len;
596 : :
597 : 385348 : iov_fault_in_pages_read(iov, chars);
598 : : redo2:
599 [ + - ]: 385342 : if (atomic)
600 : 385342 : src = kmap_atomic(page);
601 : : else
602 : 0 : src = kmap(page);
603 : :
604 : 385353 : error = pipe_iov_copy_from_user(src, iov, chars,
605 : : atomic);
606 [ + - ]: 385353 : if (atomic)
607 : 385353 : kunmap_atomic(src);
608 : : else
609 : 0 : kunmap(page);
610 : :
611 [ - + ]: 385352 : if (unlikely(error)) {
612 [ # # ]: 0 : if (atomic) {
613 : : atomic = 0;
614 : : goto redo2;
615 : : }
616 [ # # ]: 0 : if (!ret)
617 : : ret = error;
618 : : break;
619 : : }
620 : 385352 : ret += chars;
621 : :
622 : : /* Insert it into the buffer array */
623 : 385352 : buf->page = page;
624 : 385352 : buf->ops = &anon_pipe_buf_ops;
625 : 385352 : buf->offset = 0;
626 : 385352 : buf->len = chars;
627 : 385352 : buf->flags = 0;
628 [ - + ]: 385352 : if (is_packetized(filp)) {
629 : 0 : buf->ops = &packet_pipe_buf_ops;
630 : 0 : buf->flags = PIPE_BUF_FLAG_PACKET;
631 : : }
632 : 385352 : pipe->nrbufs = ++bufs;
633 : 385352 : pipe->tmp_page = NULL;
634 : :
635 : 385352 : total_len -= chars;
636 [ + + ]: 385352 : if (!total_len)
637 : : break;
638 : : }
639 [ + + ]: 16329 : if (bufs < pipe->buffers)
640 : 21 : continue;
641 [ + + ]: 16308 : if (filp->f_flags & O_NONBLOCK) {
642 [ + + ]: 2 : if (!ret)
643 : : ret = -EAGAIN;
644 : : break;
645 : : }
646 [ - + ]: 16306 : if (signal_pending(current)) {
647 [ # # ]: 0 : if (!ret)
648 : : ret = -ERESTARTSYS;
649 : : break;
650 : : }
651 [ - + ]: 16306 : if (do_wakeup) {
652 : 0 : wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLRDNORM);
653 : 0 : kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
654 : : do_wakeup = 0;
655 : : }
656 : 16306 : pipe->waiting_writers++;
657 : 16306 : pipe_wait(pipe);
658 : 16306 : pipe->waiting_writers--;
659 : : }
660 : : out:
661 : : __pipe_unlock(pipe);
662 [ + + ]: 664857 : if (do_wakeup) {
663 : 664851 : wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLRDNORM);
664 : 664851 : kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
665 : : }
666 [ + + + + ]: 1329699 : if (ret > 0 && sb_start_write_trylock(file_inode(filp)->i_sb)) {
667 : 664846 : int err = file_update_time(filp);
668 [ - + ]: 664843 : if (err)
669 : : ret = err;
670 : 664843 : sb_end_write(file_inode(filp)->i_sb);
671 : : }
672 : 664854 : return ret;
673 : : }
674 : :
675 : 0 : static long pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
676 : : {
677 : 1522 : struct pipe_inode_info *pipe = filp->private_data;
678 : : int count, buf, nrbufs;
679 : :
680 [ - + ]: 1522 : switch (cmd) {
681 : : case FIONREAD:
682 : : __pipe_lock(pipe);
683 : : count = 0;
684 : 0 : buf = pipe->curbuf;
685 : 0 : nrbufs = pipe->nrbufs;
686 [ # # ]: 1522 : while (--nrbufs >= 0) {
687 : 0 : count += pipe->bufs[buf].len;
688 : 0 : buf = (buf+1) & (pipe->buffers - 1);
689 : : }
690 : : __pipe_unlock(pipe);
691 : :
692 : 0 : return put_user(count, (int __user *)arg);
693 : : default:
694 : : return -ENOIOCTLCMD;
695 : : }
696 : : }
697 : :
698 : : /* No kernel lock held - fine */
699 : : static unsigned int
700 : 0 : pipe_poll(struct file *filp, poll_table *wait)
701 : : {
702 : : unsigned int mask;
703 : 97488 : struct pipe_inode_info *pipe = filp->private_data;
704 : : int nrbufs;
705 : :
706 : 97488 : poll_wait(filp, &pipe->wait, wait);
707 : :
708 : : /* Reading only -- no need for acquiring the semaphore. */
709 : 97492 : nrbufs = pipe->nrbufs;
710 : : mask = 0;
711 [ + + ]: 97492 : if (filp->f_mode & FMODE_READ) {
712 [ + + ]: 97454 : mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0;
713 [ + + ][ + + ]: 97454 : if (!pipe->writers && filp->f_version != pipe->w_counter)
714 : 43 : mask |= POLLHUP;
715 : : }
716 : :
717 [ + + ]: 97492 : if (filp->f_mode & FMODE_WRITE) {
718 [ - + ]: 35 : mask |= (nrbufs < pipe->buffers) ? POLLOUT | POLLWRNORM : 0;
719 : : /*
720 : : * Most Unices do not set POLLERR for FIFOs but on Linux they
721 : : * behave exactly like pipes for poll().
722 : : */
723 [ - + ]: 35 : if (!pipe->readers)
724 : 0 : mask |= POLLERR;
725 : : }
726 : :
727 : 97492 : return mask;
728 : : }
729 : :
730 : 0 : static void put_pipe_info(struct inode *inode, struct pipe_inode_info *pipe)
731 : : {
732 : : int kill = 0;
733 : :
734 : : spin_lock(&inode->i_lock);
735 [ + + ]: 356176 : if (!--pipe->files) {
736 : 348273 : inode->i_pipe = NULL;
737 : : kill = 1;
738 : : }
739 : : spin_unlock(&inode->i_lock);
740 : :
741 [ + + ]: 356176 : if (kill)
742 : 348273 : free_pipe_info(pipe);
743 : 356176 : }
744 : :
745 : : static int
746 : 0 : pipe_release(struct inode *inode, struct file *file)
747 : : {
748 : 356170 : struct pipe_inode_info *pipe = file->private_data;
749 : :
750 : : __pipe_lock(pipe);
751 [ + + ]: 356170 : if (file->f_mode & FMODE_READ)
752 : 348300 : pipe->readers--;
753 [ + + ]: 356170 : if (file->f_mode & FMODE_WRITE)
754 : 348277 : pipe->writers--;
755 : :
756 [ # # ][ + + ]: 356170 : if (pipe->readers || pipe->writers) {
757 : 0 : wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM | POLLERR | POLLHUP);
758 : 7903 : kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
759 : 7903 : kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
760 : : }
761 : : __pipe_unlock(pipe);
762 : :
763 : 356170 : put_pipe_info(inode, pipe);
764 : 356170 : return 0;
765 : : }
766 : :
767 : : static int
768 : 0 : pipe_fasync(int fd, struct file *filp, int on)
769 : : {
770 : 0 : struct pipe_inode_info *pipe = filp->private_data;
771 : : int retval = 0;
772 : :
773 : : __pipe_lock(pipe);
774 [ # # ]: 0 : if (filp->f_mode & FMODE_READ)
775 : 0 : retval = fasync_helper(fd, filp, on, &pipe->fasync_readers);
776 [ # # ][ # # ]: 0 : if ((filp->f_mode & FMODE_WRITE) && retval >= 0) {
777 : 0 : retval = fasync_helper(fd, filp, on, &pipe->fasync_writers);
778 [ # # ][ # # ]: 0 : if (retval < 0 && (filp->f_mode & FMODE_READ))
779 : : /* this can happen only if on == T */
780 : 0 : fasync_helper(-1, filp, 0, &pipe->fasync_readers);
781 : : }
782 : : __pipe_unlock(pipe);
783 : 0 : return retval;
784 : : }
785 : :
786 : 0 : struct pipe_inode_info *alloc_pipe_info(void)
787 : : {
788 : : struct pipe_inode_info *pipe;
789 : :
790 : : pipe = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
791 [ + - ]: 348286 : if (pipe) {
792 : 348286 : pipe->bufs = kzalloc(sizeof(struct pipe_buffer) * PIPE_DEF_BUFFERS, GFP_KERNEL);
793 [ + - ]: 348286 : if (pipe->bufs) {
794 : 348286 : init_waitqueue_head(&pipe->wait);
795 : 348286 : pipe->r_counter = pipe->w_counter = 1;
796 : 348286 : pipe->buffers = PIPE_DEF_BUFFERS;
797 : 348286 : mutex_init(&pipe->mutex);
798 : 348286 : return pipe;
799 : : }
800 : 0 : kfree(pipe);
801 : : }
802 : :
803 : : return NULL;
804 : : }
805 : :
806 : 0 : void free_pipe_info(struct pipe_inode_info *pipe)
807 : : {
808 : : int i;
809 : :
810 [ + + ]: 5920862 : for (i = 0; i < pipe->buffers; i++) {
811 : 5572576 : struct pipe_buffer *buf = pipe->bufs + i;
812 [ + + ]: 5572576 : if (buf->ops)
813 : 340423 : buf->ops->release(pipe, buf);
814 : : }
815 [ + + ]: 348286 : if (pipe->tmp_page)
816 : 342935 : __free_page(pipe->tmp_page);
817 : 348286 : kfree(pipe->bufs);
818 : 348286 : kfree(pipe);
819 : 348286 : }
820 : :
821 : : static struct vfsmount *pipe_mnt __read_mostly;
822 : :
823 : : /*
824 : : * pipefs_dname() is called from d_path().
825 : : */
826 : 0 : static char *pipefs_dname(struct dentry *dentry, char *buffer, int buflen)
827 : : {
828 : 80 : return dynamic_dname(dentry, buffer, buflen, "pipe:[%lu]",
829 : 80 : dentry->d_inode->i_ino);
830 : : }
831 : :
832 : : static const struct dentry_operations pipefs_dentry_operations = {
833 : : .d_dname = pipefs_dname,
834 : : };
835 : :
836 : 0 : static struct inode * get_pipe_inode(void)
837 : : {
838 : 7849 : struct inode *inode = new_inode_pseudo(pipe_mnt->mnt_sb);
839 : : struct pipe_inode_info *pipe;
840 : :
841 [ + - ]: 7849 : if (!inode)
842 : : goto fail_inode;
843 : :
844 : 7849 : inode->i_ino = get_next_ino();
845 : :
846 : 7849 : pipe = alloc_pipe_info();
847 [ + - ]: 7849 : if (!pipe)
848 : : goto fail_iput;
849 : :
850 : 7849 : inode->i_pipe = pipe;
851 : 7849 : pipe->files = 2;
852 : 7849 : pipe->readers = pipe->writers = 1;
853 : 7849 : inode->i_fop = &pipefifo_fops;
854 : :
855 : : /*
856 : : * Mark the inode dirty from the very beginning,
857 : : * that way it will never be moved to the dirty
858 : : * list because "mark_inode_dirty()" will think
859 : : * that it already _is_ on the dirty list.
860 : : */
861 : 7849 : inode->i_state = I_DIRTY;
862 : 7849 : inode->i_mode = S_IFIFO | S_IRUSR | S_IWUSR;
863 : 7849 : inode->i_uid = current_fsuid();
864 : 7849 : inode->i_gid = current_fsgid();
865 : 7849 : inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
866 : :
867 : 7849 : return inode;
868 : :
869 : : fail_iput:
870 : 0 : iput(inode);
871 : :
872 : : fail_inode:
873 : : return NULL;
874 : : }
875 : :
876 : 0 : int create_pipe_files(struct file **res, int flags)
877 : : {
878 : : int err;
879 : 7849 : struct inode *inode = get_pipe_inode();
880 : : struct file *f;
881 : : struct path path;
882 : : static struct qstr name = { .name = "" };
883 : :
884 [ + - ]: 7849 : if (!inode)
885 : : return -ENFILE;
886 : :
887 : : err = -ENOMEM;
888 : 7849 : path.dentry = d_alloc_pseudo(pipe_mnt->mnt_sb, &name);
889 [ + - ]: 7849 : if (!path.dentry)
890 : : goto err_inode;
891 : 7849 : path.mnt = mntget(pipe_mnt);
892 : :
893 : 7849 : d_instantiate(path.dentry, inode);
894 : :
895 : : err = -ENFILE;
896 : 7849 : f = alloc_file(&path, FMODE_WRITE, &pipefifo_fops);
897 [ + - ]: 7849 : if (IS_ERR(f))
898 : : goto err_dentry;
899 : :
900 : 7849 : f->f_flags = O_WRONLY | (flags & (O_NONBLOCK | O_DIRECT));
901 : 7849 : f->private_data = inode->i_pipe;
902 : :
903 : 7849 : res[0] = alloc_file(&path, FMODE_READ, &pipefifo_fops);
904 [ + - ]: 7849 : if (IS_ERR(res[0]))
905 : : goto err_file;
906 : :
907 : 7849 : path_get(&path);
908 : 7849 : res[0]->private_data = inode->i_pipe;
909 : 7849 : res[0]->f_flags = O_RDONLY | (flags & O_NONBLOCK);
910 : 7849 : res[1] = f;
911 : 7849 : return 0;
912 : :
913 : : err_file:
914 : 0 : put_filp(f);
915 : : err_dentry:
916 : 0 : free_pipe_info(inode->i_pipe);
917 : 0 : path_put(&path);
918 : 0 : return err;
919 : :
920 : : err_inode:
921 : 0 : free_pipe_info(inode->i_pipe);
922 : 0 : iput(inode);
923 : 0 : return err;
924 : : }
925 : :
926 : 0 : static int __do_pipe_flags(int *fd, struct file **files, int flags)
927 : : {
928 : : int error;
929 : : int fdw, fdr;
930 : :
931 [ + - ]: 7849 : if (flags & ~(O_CLOEXEC | O_NONBLOCK | O_DIRECT))
932 : : return -EINVAL;
933 : :
934 : 7849 : error = create_pipe_files(files, flags);
935 [ + - ]: 7849 : if (error)
936 : : return error;
937 : :
938 : 7849 : error = get_unused_fd_flags(flags);
939 [ + - ]: 7849 : if (error < 0)
940 : : goto err_read_pipe;
941 : : fdr = error;
942 : :
943 : 7849 : error = get_unused_fd_flags(flags);
944 [ + + ]: 7849 : if (error < 0)
945 : : goto err_fdr;
946 : : fdw = error;
947 : :
948 : : audit_fd_pair(fdr, fdw);
949 : 7846 : fd[0] = fdr;
950 : 7846 : fd[1] = fdw;
951 : 7846 : return 0;
952 : :
953 : : err_fdr:
954 : 3 : put_unused_fd(fdr);
955 : : err_read_pipe:
956 : 3 : fput(files[0]);
957 : 3 : fput(files[1]);
958 : 3 : return error;
959 : : }
960 : :
961 : 0 : int do_pipe_flags(int *fd, int flags)
962 : : {
963 : : struct file *files[2];
964 : 0 : int error = __do_pipe_flags(fd, files, flags);
965 [ # # ]: 0 : if (!error) {
966 : 0 : fd_install(fd[0], files[0]);
967 : 0 : fd_install(fd[1], files[1]);
968 : : }
969 : 0 : return error;
970 : : }
971 : :
972 : : /*
973 : : * sys_pipe() is the normal C calling standard for creating
974 : : * a pipe. It's not the way Unix traditionally does this, though.
975 : : */
976 : 0 : SYSCALL_DEFINE2(pipe2, int __user *, fildes, int, flags)
977 : : {
978 : : struct file *files[2];
979 : : int fd[2];
980 : : int error;
981 : :
982 : 7849 : error = __do_pipe_flags(fd, files, flags);
983 [ + + ]: 7849 : if (!error) {
984 [ + + ]: 7846 : if (unlikely(copy_to_user(fildes, fd, sizeof(fd)))) {
985 : 1 : fput(files[0]);
986 : 1 : fput(files[1]);
987 : 1 : put_unused_fd(fd[0]);
988 : 1 : put_unused_fd(fd[1]);
989 : : error = -EFAULT;
990 : : } else {
991 : 7845 : fd_install(fd[0], files[0]);
992 : 7845 : fd_install(fd[1], files[1]);
993 : : }
994 : : }
995 : : return error;
996 : : }
997 : :
998 : 0 : SYSCALL_DEFINE1(pipe, int __user *, fildes)
999 : : {
1000 : 7802 : return sys_pipe2(fildes, 0);
1001 : : }
1002 : :
1003 : 0 : static int wait_for_partner(struct pipe_inode_info *pipe, unsigned int *cnt)
1004 : : {
1005 : 11 : int cur = *cnt;
1006 : :
1007 [ + + ]: 23 : while (cur == *cnt) {
1008 : 12 : pipe_wait(pipe);
1009 [ + - ]: 12 : if (signal_pending(current))
1010 : : break;
1011 : : }
1012 [ + ]: 11 : return cur == *cnt ? -ERESTARTSYS : 0;
1013 : : }
1014 : :
1015 : : static void wake_up_partner(struct pipe_inode_info *pipe)
1016 : : {
1017 : 340431 : wake_up_interruptible(&pipe->wait);
1018 : : }
1019 : :
1020 : 0 : static int fifo_open(struct inode *inode, struct file *filp)
1021 : : {
1022 : : struct pipe_inode_info *pipe;
1023 : 340478 : bool is_pipe = inode->i_sb->s_magic == PIPEFS_MAGIC;
1024 : : int ret;
1025 : :
1026 : 340478 : filp->f_version = 0;
1027 : :
1028 : : spin_lock(&inode->i_lock);
1029 [ + + ]: 340478 : if (inode->i_pipe) {
1030 : : pipe = inode->i_pipe;
1031 : 54 : pipe->files++;
1032 : : spin_unlock(&inode->i_lock);
1033 : : } else {
1034 : : spin_unlock(&inode->i_lock);
1035 : 340424 : pipe = alloc_pipe_info();
1036 [ + - ]: 340424 : if (!pipe)
1037 : : return -ENOMEM;
1038 : 340424 : pipe->files = 1;
1039 : : spin_lock(&inode->i_lock);
1040 [ - + ]: 340424 : if (unlikely(inode->i_pipe)) {
1041 : 0 : inode->i_pipe->files++;
1042 : : spin_unlock(&inode->i_lock);
1043 : 0 : free_pipe_info(pipe);
1044 : 0 : pipe = inode->i_pipe;
1045 : : } else {
1046 : 340424 : inode->i_pipe = pipe;
1047 : : spin_unlock(&inode->i_lock);
1048 : : }
1049 : : }
1050 : 340478 : filp->private_data = pipe;
1051 : : /* OK, we have a pipe and it's pinned down */
1052 : :
1053 : : __pipe_lock(pipe);
1054 : :
1055 : : /* We can only do regular read/write on fifos */
1056 : 340478 : filp->f_mode &= (FMODE_READ | FMODE_WRITE);
1057 : :
1058 [ + + + - ]: 340478 : switch (filp->f_mode) {
1059 : : case FMODE_READ:
1060 : : /*
1061 : : * O_RDONLY
1062 : : * POSIX.1 says that O_NONBLOCK means return with the FIFO
1063 : : * opened, even when there is no process writing the FIFO.
1064 : : */
1065 : 44 : pipe->r_counter++;
1066 [ + + ]: 44 : if (pipe->readers++ == 0)
1067 : : wake_up_partner(pipe);
1068 : :
1069 [ + + ][ + + ]: 44 : if (!is_pipe && !pipe->writers) {
1070 [ + + ]: 11 : if ((filp->f_flags & O_NONBLOCK)) {
1071 : : /* suppress POLLHUP until we have
1072 : : * seen a writer */
1073 : 5 : filp->f_version = pipe->w_counter;
1074 : : } else {
1075 [ + - ]: 6 : if (wait_for_partner(pipe, &pipe->w_counter))
1076 : : goto err_rd;
1077 : : }
1078 : : }
1079 : : break;
1080 : :
1081 : : case FMODE_WRITE:
1082 : : /*
1083 : : * O_WRONLY
1084 : : * POSIX.1 says that O_NONBLOCK means return -1 with
1085 : : * errno=ENXIO when there is no process reading the FIFO.
1086 : : */
1087 : : ret = -ENXIO;
1088 [ + - ][ + + ]: 27 : if (!is_pipe && (filp->f_flags & O_NONBLOCK) && !pipe->readers)
[ + + ]
1089 : : goto err;
1090 : :
1091 : 21 : pipe->w_counter++;
1092 [ + + ]: 21 : if (!pipe->writers++)
1093 : : wake_up_partner(pipe);
1094 : :
1095 [ + - ][ + + ]: 21 : if (!is_pipe && !pipe->readers) {
1096 [ + - ]: 5 : if (wait_for_partner(pipe, &pipe->r_counter))
1097 : : goto err_wr;
1098 : : }
1099 : : break;
1100 : :
1101 : : case FMODE_READ | FMODE_WRITE:
1102 : : /*
1103 : : * O_RDWR
1104 : : * POSIX.1 leaves this case "undefined" when O_NONBLOCK is set.
1105 : : * This implementation will NEVER block on a O_RDWR open, since
1106 : : * the process can at least talk to itself.
1107 : : */
1108 : :
1109 : 340407 : pipe->readers++;
1110 : 340407 : pipe->writers++;
1111 : 340407 : pipe->r_counter++;
1112 : 340407 : pipe->w_counter++;
1113 [ - + ][ # # ]: 340407 : if (pipe->readers == 1 || pipe->writers == 1)
1114 : : wake_up_partner(pipe);
1115 : : break;
1116 : :
1117 : : default:
1118 : : ret = -EINVAL;
1119 : : goto err;
1120 : : }
1121 : :
1122 : : /* Ok! */
1123 : : __pipe_unlock(pipe);
1124 : 340472 : return 0;
1125 : :
1126 : : err_rd:
1127 [ # # ]: 0 : if (!--pipe->readers)
1128 : 0 : wake_up_interruptible(&pipe->wait);
1129 : : ret = -ERESTARTSYS;
1130 : : goto err;
1131 : :
1132 : : err_wr:
1133 [ # # ]: 0 : if (!--pipe->writers)
1134 : 0 : wake_up_interruptible(&pipe->wait);
1135 : : ret = -ERESTARTSYS;
1136 : : goto err;
1137 : :
1138 : : err:
1139 : : __pipe_unlock(pipe);
1140 : :
1141 : 6 : put_pipe_info(inode, pipe);
1142 : 6 : return ret;
1143 : : }
1144 : :
1145 : : const struct file_operations pipefifo_fops = {
1146 : : .open = fifo_open,
1147 : : .llseek = no_llseek,
1148 : : .read = do_sync_read,
1149 : : .aio_read = pipe_read,
1150 : : .write = do_sync_write,
1151 : : .aio_write = pipe_write,
1152 : : .poll = pipe_poll,
1153 : : .unlocked_ioctl = pipe_ioctl,
1154 : : .release = pipe_release,
1155 : : .fasync = pipe_fasync,
1156 : : };
1157 : :
1158 : : /*
1159 : : * Allocate a new array of pipe buffers and copy the info over. Returns the
1160 : : * pipe size if successful, or return -ERROR on error.
1161 : : */
1162 : 0 : static long pipe_set_size(struct pipe_inode_info *pipe, unsigned long nr_pages)
1163 : : {
1164 : : struct pipe_buffer *bufs;
1165 : :
1166 : : /*
1167 : : * We can shrink the pipe, if arg >= pipe->nrbufs. Since we don't
1168 : : * expect a lot of shrink+grow operations, just free and allocate
1169 : : * again like we would do for growing. If the pipe currently
1170 : : * contains more buffers than arg, then return busy.
1171 : : */
1172 [ # # ]: 0 : if (nr_pages < pipe->nrbufs)
1173 : : return -EBUSY;
1174 : :
1175 : : bufs = kcalloc(nr_pages, sizeof(*bufs), GFP_KERNEL | __GFP_NOWARN);
1176 [ # # ]: 0 : if (unlikely(!bufs))
1177 : : return -ENOMEM;
1178 : :
1179 : : /*
1180 : : * The pipe array wraps around, so just start the new one at zero
1181 : : * and adjust the indexes.
1182 : : */
1183 [ # # ]: 0 : if (pipe->nrbufs) {
1184 : : unsigned int tail;
1185 : : unsigned int head;
1186 : :
1187 : 0 : tail = pipe->curbuf + pipe->nrbufs;
1188 [ # # ]: 0 : if (tail < pipe->buffers)
1189 : : tail = 0;
1190 : : else
1191 : 0 : tail &= (pipe->buffers - 1);
1192 : :
1193 : 0 : head = pipe->nrbufs - tail;
1194 [ # # ]: 0 : if (head)
1195 : 0 : memcpy(bufs, pipe->bufs + pipe->curbuf, head * sizeof(struct pipe_buffer));
1196 [ # # ]: 0 : if (tail)
1197 : 0 : memcpy(bufs + head, pipe->bufs, tail * sizeof(struct pipe_buffer));
1198 : : }
1199 : :
1200 : 0 : pipe->curbuf = 0;
1201 : 0 : kfree(pipe->bufs);
1202 : 0 : pipe->bufs = bufs;
1203 : 0 : pipe->buffers = nr_pages;
1204 : 0 : return nr_pages * PAGE_SIZE;
1205 : : }
1206 : :
1207 : : /*
1208 : : * Currently we rely on the pipe array holding a power-of-2 number
1209 : : * of pages.
1210 : : */
1211 : : static inline unsigned int round_pipe_size(unsigned int size)
1212 : : {
1213 : : unsigned long nr_pages;
1214 : :
1215 : 2 : nr_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
1216 [ # # ][ # # ]: 2 : return roundup_pow_of_two(nr_pages) << PAGE_SHIFT;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ - - ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
1217 : : }
1218 : :
1219 : : /*
1220 : : * This should work even if CONFIG_PROC_FS isn't set, as proc_dointvec_minmax
1221 : : * will return an error.
1222 : : */
1223 : 0 : int pipe_proc_fn(struct ctl_table *table, int write, void __user *buf,
1224 : : size_t *lenp, loff_t *ppos)
1225 : : {
1226 : : int ret;
1227 : :
1228 : 2 : ret = proc_dointvec_minmax(table, write, buf, lenp, ppos);
1229 [ + - ]: 2 : if (ret < 0 || !write)
1230 : : return ret;
1231 : :
1232 : 2 : pipe_max_size = round_pipe_size(pipe_max_size);
1233 : 0 : return ret;
1234 : : }
1235 : :
1236 : : /*
1237 : : * After the inode slimming patch, i_pipe/i_bdev/i_cdev share the same
1238 : : * location, so checking ->i_pipe is not enough to verify that this is a
1239 : : * pipe.
1240 : : */
1241 : 0 : struct pipe_inode_info *get_pipe_info(struct file *file)
1242 : : {
1243 [ - + ][ + + ]: 37345 : return file->f_op == &pipefifo_fops ? file->private_data : NULL;
1244 : : }
1245 : :
1246 : 0 : long pipe_fcntl(struct file *file, unsigned int cmd, unsigned long arg)
1247 : : {
1248 : : struct pipe_inode_info *pipe;
1249 : : long ret;
1250 : :
1251 : : pipe = get_pipe_info(file);
1252 [ - + ]: 2 : if (!pipe)
1253 : : return -EBADF;
1254 : :
1255 : : __pipe_lock(pipe);
1256 : :
1257 [ # # # ]: 0 : switch (cmd) {
1258 : : case F_SETPIPE_SZ: {
1259 : : unsigned int size, nr_pages;
1260 : :
1261 : : size = round_pipe_size(arg);
1262 : 0 : nr_pages = size >> PAGE_SHIFT;
1263 : :
1264 : : ret = -EINVAL;
1265 [ - ]: 0 : if (!nr_pages)
1266 : : goto out;
1267 : :
1268 [ # # ][ # # ]: 0 : if (!capable(CAP_SYS_RESOURCE) && size > pipe_max_size) {
1269 : : ret = -EPERM;
1270 : : goto out;
1271 : : }
1272 : 0 : ret = pipe_set_size(pipe, nr_pages);
1273 : 0 : break;
1274 : : }
1275 : : case F_GETPIPE_SZ:
1276 : 0 : ret = pipe->buffers * PAGE_SIZE;
1277 : 0 : break;
1278 : : default:
1279 : : ret = -EINVAL;
1280 : : break;
1281 : : }
1282 : :
1283 : : out:
1284 : : __pipe_unlock(pipe);
1285 : 0 : return ret;
1286 : : }
1287 : :
1288 : : static const struct super_operations pipefs_ops = {
1289 : : .destroy_inode = free_inode_nonrcu,
1290 : : .statfs = simple_statfs,
1291 : : };
1292 : :
1293 : : /*
1294 : : * pipefs should _never_ be mounted by userland - too much of security hassle,
1295 : : * no real gain from having the whole whorehouse mounted. So we don't need
1296 : : * any operations on the root directory. However, we need a non-trivial
1297 : : * d_name - pipe: will go nicely and kill the special-casing in procfs.
1298 : : */
1299 : 0 : static struct dentry *pipefs_mount(struct file_system_type *fs_type,
1300 : : int flags, const char *dev_name, void *data)
1301 : : {
1302 : 0 : return mount_pseudo(fs_type, "pipe:", &pipefs_ops,
1303 : : &pipefs_dentry_operations, PIPEFS_MAGIC);
1304 : : }
1305 : :
1306 : : static struct file_system_type pipe_fs_type = {
1307 : : .name = "pipefs",
1308 : : .mount = pipefs_mount,
1309 : : .kill_sb = kill_anon_super,
1310 : : };
1311 : :
1312 : 0 : static int __init init_pipe_fs(void)
1313 : : {
1314 : 0 : int err = register_filesystem(&pipe_fs_type);
1315 : :
1316 [ # # ]: 0 : if (!err) {
1317 : 0 : pipe_mnt = kern_mount(&pipe_fs_type);
1318 [ # # ]: 0 : if (IS_ERR(pipe_mnt)) {
1319 : : err = PTR_ERR(pipe_mnt);
1320 : 0 : unregister_filesystem(&pipe_fs_type);
1321 : : }
1322 : : }
1323 : 0 : return err;
1324 : : }
1325 : :
1326 : : fs_initcall(init_pipe_fs);
|
