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 [ + - ][ # # ]: 63026 : if (pipe->files)
[ # # ][ + - ]
[ + - ][ + + ]
60 : 62986 : 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 [ + - ][ + + ]: 63026 : if (pipe->files)
75 : 62986 : 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 : 2467458 : mutex_lock_nested(&pipe->mutex, I_MUTEX_PARENT);
82 : : }
83 : :
84 : : static inline void __pipe_unlock(struct pipe_inode_info *pipe)
85 : : {
86 : 2421843 : 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 : 88594 : DEFINE_WAIT(wait);
107 : :
108 : : /*
109 : : * Pipes are system-local resources, so sleeping on them
110 : : * is considered a noninteractive wait:
111 : : */
112 : 44297 : prepare_to_wait(&pipe->wait, &wait, TASK_INTERRUPTIBLE);
113 : : pipe_unlock(pipe);
114 : 44297 : schedule();
115 : 44297 : finish_wait(&pipe->wait, &wait);
116 : : pipe_lock(pipe);
117 : 44297 : }
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 [ + + ]: 1840143 : while (len > 0) {
126 [ + + ]: 920087 : while (!iov->iov_len)
127 : 10 : iov++;
128 : 920077 : copy = min_t(unsigned long, len, iov->iov_len);
129 : :
130 [ + - ]: 920077 : if (atomic) {
131 [ + - ]: 920077 : 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 : 920076 : to += copy;
138 : 920076 : len -= copy;
139 : 920076 : iov->iov_base += copy;
140 : 920076 : 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 [ + + ]: 919570 : while (len > 0) {
152 [ - + ]: 459785 : while (!iov->iov_len)
153 : 0 : iov++;
154 : 459785 : copy = min_t(unsigned long, len, iov->iov_len);
155 : :
156 [ + - ]: 459785 : if (atomic) {
157 [ + - ]: 459785 : 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 : 459785 : from += copy;
164 : 459785 : len -= copy;
165 : 459785 : iov->iov_base += copy;
166 : 459785 : 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 [ - + ]: 459782 : while (!iov->iov_len)
178 : 0 : iov++;
179 : :
180 [ + + ]: 919566 : while (len > 0) {
181 : : unsigned long this_len;
182 : :
183 : 459783 : this_len = min_t(unsigned long, len, iov->iov_len);
184 [ + - ]: 459784 : if (fault_in_pages_writeable(iov->iov_base, this_len))
185 : : break;
186 : :
187 : 459784 : len -= this_len;
188 : 459784 : iov++;
189 : : }
190 : :
191 : 459783 : 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 [ - + ]: 920078 : while (!iov->iov_len)
200 : 0 : iov++;
201 : :
202 [ + + ]: 1840136 : while (len > 0) {
203 : : unsigned long this_len;
204 : :
205 : 920073 : this_len = min_t(unsigned long, len, iov->iov_len);
206 : 920073 : fault_in_pages_readable(iov->iov_base, this_len);
207 : 920058 : len -= this_len;
208 : 920058 : iov++;
209 : : }
210 : 920063 : }
211 : :
212 : 0 : static void anon_pipe_buf_release(struct pipe_inode_info *pipe,
213 : : struct pipe_buffer *buf)
214 : : {
215 : 541267 : 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 [ + + ][ + + ]: 541267 : if (page_count(page) == 1 && !pipe->tmp_page)
223 : 511631 : pipe->tmp_page = page;
224 : : else
225 : 29636 : page_cache_release(page);
226 : 541266 : }
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 [ + - ]: 857909 : if (atomic) {
246 : 857909 : buf->flags |= PIPE_BUF_FLAG_ATOMIC;
247 : 857909 : 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 [ + - ]: 857913 : if (buf->flags & PIPE_BUF_FLAG_ATOMIC) {
267 : 857913 : buf->flags &= ~PIPE_BUF_FLAG_ATOMIC;
268 : 857913 : kunmap_atomic(map_data);
269 : : } else
270 : 0 : kunmap(buf->page);
271 : 857913 : }
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 : 857907 : 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 : 594938 : struct file *filp = iocb->ki_filp;
377 : 594938 : 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 [ + + ]: 594938 : if (unlikely(total_len == 0))
386 : : return 0;
387 : :
388 : : do_wakeup = 0;
389 : : ret = 0;
390 : : __pipe_lock(pipe);
391 : : for (;;) {
392 : 641261 : int bufs = pipe->nrbufs;
393 [ + + ]: 641261 : if (bufs) {
394 : 459784 : int curbuf = pipe->curbuf;
395 : 459784 : struct pipe_buffer *buf = pipe->bufs + curbuf;
396 : 459784 : const struct pipe_buf_operations *ops = buf->ops;
397 : : void *addr;
398 : 459784 : size_t chars = buf->len;
399 : : int error, atomic;
400 : :
401 [ + + ]: 459784 : if (chars > total_len)
402 : : chars = total_len;
403 : :
404 : 459784 : error = ops->confirm(pipe, buf);
405 [ - + ]: 459784 : if (error) {
406 [ # # ]: 0 : if (!ret)
407 : : ret = error;
408 : : break;
409 : : }
410 : :
411 : 459784 : atomic = !iov_fault_in_pages_write(iov, chars);
412 : : redo:
413 : 459784 : addr = ops->map(pipe, buf, atomic);
414 : 459785 : error = pipe_iov_copy_to_user(iov, addr + buf->offset, chars, atomic);
415 : 459785 : ops->unmap(pipe, buf, addr);
416 [ - + ]: 459785 : 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 : 459785 : ret += chars;
429 : 459785 : buf->offset += chars;
430 : 459785 : buf->len -= chars;
431 : :
432 : : /* Was it a packet buffer? Clean up and exit */
433 [ - + ]: 459785 : if (buf->flags & PIPE_BUF_FLAG_PACKET) {
434 : : total_len = chars;
435 : 0 : buf->len = 0;
436 : : }
437 : :
438 [ + + ]: 459785 : if (!buf->len) {
439 : 78874 : buf->ops = NULL;
440 : 78874 : ops->release(pipe, buf);
441 : 78873 : curbuf = (curbuf + 1) & (pipe->buffers - 1);
442 : 78873 : pipe->curbuf = curbuf;
443 : 78873 : pipe->nrbufs = --bufs;
444 : : do_wakeup = 1;
445 : : }
446 : 459784 : total_len -= chars;
447 [ + + ]: 459784 : if (!total_len)
448 : : break; /* common path: read succeeded */
449 : : }
450 [ + + ]: 223192 : if (bufs) /* More to do? */
451 : 25430 : continue;
452 [ + + ]: 197762 : if (!pipe->writers)
453 : : break;
454 [ + + ]: 97242 : 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 [ + + ]: 97231 : if (ret)
461 : : break;
462 [ + + ]: 84585 : if (filp->f_flags & O_NONBLOCK) {
463 : : ret = -EAGAIN;
464 : : break;
465 : : }
466 : : }
467 [ + + ]: 20743 : if (signal_pending(current)) {
468 [ + - ]: 2 : if (!ret)
469 : : ret = -ERESTARTSYS;
470 : : break;
471 : : }
472 [ + + ]: 20741 : if (do_wakeup) {
473 : 1 : wake_up_interruptible_sync_poll(&pipe->wait, POLLOUT | POLLWRNORM);
474 : 1 : kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
475 : : }
476 : 20741 : pipe_wait(pipe);
477 : : }
478 : : __pipe_unlock(pipe);
479 : :
480 : : /* Signal writers asynchronously that there is more room. */
481 [ + + ]: 595094 : if (do_wakeup) {
482 : 53716 : wake_up_interruptible_sync_poll(&pipe->wait, POLLOUT | POLLWRNORM);
483 : 53716 : kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
484 : : }
485 [ + + ]: 595093 : if (ret > 0)
486 : : file_accessed(filp);
487 : 595089 : return ret;
488 : : }
489 : :
490 : : static inline int is_packetized(struct file *file)
491 : : {
492 : 541267 : 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 : 1452561 : struct file *filp = iocb->ki_filp;
500 : 911294 : 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 [ + + ]: 911294 : if (unlikely(total_len == 0))
510 : : return 0;
511 : :
512 : : do_wakeup = 0;
513 : : ret = 0;
514 : : __pipe_lock(pipe);
515 : :
516 [ + + ]: 911290 : 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 : 911285 : chars = total_len & (PAGE_SIZE-1); /* size of the last buffer */
524 [ + + ][ + + ]: 911285 : if (pipe->nrbufs && chars != 0) {
525 : 799992 : int lastbuf = (pipe->curbuf + pipe->nrbufs - 1) &
526 : 399996 : (pipe->buffers - 1);
527 : 399996 : struct pipe_buffer *buf = pipe->bufs + lastbuf;
528 : 399996 : const struct pipe_buf_operations *ops = buf->ops;
529 : 399996 : int offset = buf->offset + buf->len;
530 : :
531 [ + - ][ + + ]: 911290 : if (ops->can_merge && offset + chars <= PAGE_SIZE) {
532 : : int error, atomic = 1;
533 : : void *addr;
534 : :
535 : 378800 : error = ops->confirm(pipe, buf);
536 [ + - ]: 378800 : if (error)
537 : : goto out;
538 : :
539 : 378800 : iov_fault_in_pages_read(iov, chars);
540 : : redo1:
541 : 378800 : addr = ops->map(pipe, buf, atomic);
542 : 378800 : error = pipe_iov_copy_from_user(offset + addr, iov,
543 : : chars, atomic);
544 : 378800 : ops->unmap(pipe, buf, addr);
545 : : ret = error;
546 : : do_wakeup = 1;
547 [ - + ]: 378800 : if (error) {
548 [ # # ]: 0 : if (atomic) {
549 : : atomic = 0;
550 : : goto redo1;
551 : : }
552 : : goto out;
553 : : }
554 : 378800 : buf->len += chars;
555 : 378800 : total_len -= chars;
556 : : ret = chars;
557 [ + + ]: 409396 : if (!total_len)
558 : : goto out;
559 : : }
560 : : }
561 : :
562 : : for (;;) {
563 : : int bufs;
564 : :
565 [ - + ]: 563086 : if (!pipe->readers) {
566 : 0 : send_sig(SIGPIPE, current, 0);
567 [ # # ]: 0 : if (!ret)
568 : : ret = -EPIPE;
569 : : break;
570 : : }
571 : 563086 : bufs = pipe->nrbufs;
572 [ + + ]: 563086 : if (bufs < pipe->buffers) {
573 : 541267 : int newbuf = (pipe->curbuf + bufs) & (pipe->buffers-1);
574 : 541267 : struct pipe_buffer *buf = pipe->bufs + newbuf;
575 : 541267 : struct page *page = pipe->tmp_page;
576 : : char *src;
577 : : int error, atomic = 1;
578 : :
579 [ + + ]: 541267 : if (!page) {
580 : : page = alloc_page(GFP_HIGHUSER);
581 [ - + ]: 478764 : if (unlikely(!page)) {
582 [ # # ]: 0 : ret = ret ? : -ENOMEM;
583 : 0 : break;
584 : : }
585 : 478764 : 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 [ + + ]: 541267 : if (chars > total_len)
595 : 336423 : chars = total_len;
596 : :
597 : 541267 : iov_fault_in_pages_read(iov, chars);
598 : : redo2:
599 [ + - ]: 541266 : if (atomic)
600 : 541266 : src = kmap_atomic(page);
601 : : else
602 : 0 : src = kmap(page);
603 : :
604 : 541267 : error = pipe_iov_copy_from_user(src, iov, chars,
605 : : atomic);
606 [ + - ]: 541267 : if (atomic)
607 : 541267 : kunmap_atomic(src);
608 : : else
609 : 0 : kunmap(page);
610 : :
611 [ - + ]: 541267 : 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 : 541267 : ret += chars;
621 : :
622 : : /* Insert it into the buffer array */
623 : 541267 : buf->page = page;
624 : 541267 : buf->ops = &anon_pipe_buf_ops;
625 : 541267 : buf->offset = 0;
626 : 541267 : buf->len = chars;
627 : 541267 : buf->flags = 0;
628 [ - + ]: 541267 : if (is_packetized(filp)) {
629 : 0 : buf->ops = &packet_pipe_buf_ops;
630 : 0 : buf->flags = PIPE_BUF_FLAG_PACKET;
631 : : }
632 : 541267 : pipe->nrbufs = ++bufs;
633 : 541267 : pipe->tmp_page = NULL;
634 : :
635 : 541267 : total_len -= chars;
636 [ + + ]: 541267 : if (!total_len)
637 : : break;
638 : : }
639 [ + + ]: 31695 : if (bufs < pipe->buffers)
640 : 9775 : continue;
641 [ + + ]: 21920 : if (filp->f_flags & O_NONBLOCK) {
642 [ + + ]: 1099 : if (!ret)
643 : : ret = -EAGAIN;
644 : : break;
645 : : }
646 [ - + ]: 20821 : if (signal_pending(current)) {
647 [ # # ]: 0 : if (!ret)
648 : : ret = -ERESTARTSYS;
649 : : break;
650 : : }
651 [ + + ]: 20821 : if (do_wakeup) {
652 : 100 : wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLRDNORM);
653 : 100 : kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
654 : : do_wakeup = 0;
655 : : }
656 : 20821 : pipe->waiting_writers++;
657 : 20821 : pipe_wait(pipe);
658 : 20821 : pipe->waiting_writers--;
659 : : }
660 : : out:
661 : : __pipe_unlock(pipe);
662 [ + + ]: 911295 : if (do_wakeup) {
663 : 910192 : wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLRDNORM);
664 : 910191 : kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
665 : : }
666 [ + + ]: 911294 : if (ret > 0) {
667 : 910192 : int err = file_update_time(filp);
668 [ - + ]: 910191 : if (err)
669 : : ret = err;
670 : : }
671 : 911293 : return ret;
672 : : }
673 : :
674 : 0 : static long pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
675 : : {
676 : 2616 : struct pipe_inode_info *pipe = filp->private_data;
677 : : int count, buf, nrbufs;
678 : :
679 [ - + ]: 2616 : switch (cmd) {
680 : : case FIONREAD:
681 : : __pipe_lock(pipe);
682 : : count = 0;
683 : 0 : buf = pipe->curbuf;
684 : 0 : nrbufs = pipe->nrbufs;
685 [ # # ]: 2616 : while (--nrbufs >= 0) {
686 : 0 : count += pipe->bufs[buf].len;
687 : 0 : buf = (buf+1) & (pipe->buffers - 1);
688 : : }
689 : : __pipe_unlock(pipe);
690 : :
691 : 0 : return put_user(count, (int __user *)arg);
692 : : default:
693 : : return -ENOIOCTLCMD;
694 : : }
695 : : }
696 : :
697 : : /* No kernel lock held - fine */
698 : : static unsigned int
699 : 0 : pipe_poll(struct file *filp, poll_table *wait)
700 : : {
701 : : unsigned int mask;
702 : 334497 : struct pipe_inode_info *pipe = filp->private_data;
703 : : int nrbufs;
704 : :
705 : 334497 : poll_wait(filp, &pipe->wait, wait);
706 : :
707 : : /* Reading only -- no need for acquiring the semaphore. */
708 : 334498 : nrbufs = pipe->nrbufs;
709 : : mask = 0;
710 [ + + ]: 334498 : if (filp->f_mode & FMODE_READ) {
711 [ + + ]: 329093 : mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0;
712 [ + + ][ + + ]: 329093 : if (!pipe->writers && filp->f_version != pipe->w_counter)
713 : 415 : mask |= POLLHUP;
714 : : }
715 : :
716 [ + + ]: 334498 : if (filp->f_mode & FMODE_WRITE) {
717 [ + + ]: 5405 : mask |= (nrbufs < pipe->buffers) ? POLLOUT | POLLWRNORM : 0;
718 : : /*
719 : : * Most Unices do not set POLLERR for FIFOs but on Linux they
720 : : * behave exactly like pipes for poll().
721 : : */
722 [ - + ]: 5405 : if (!pipe->readers)
723 : 0 : mask |= POLLERR;
724 : : }
725 : :
726 : 334498 : return mask;
727 : : }
728 : :
729 : 0 : static void put_pipe_info(struct inode *inode, struct pipe_inode_info *pipe)
730 : : {
731 : : int kill = 0;
732 : :
733 : : spin_lock(&inode->i_lock);
734 [ + + ]: 472296 : if (!--pipe->files) {
735 : 457681 : inode->i_pipe = NULL;
736 : : kill = 1;
737 : : }
738 : : spin_unlock(&inode->i_lock);
739 : :
740 [ + + ]: 472296 : if (kill)
741 : 457681 : free_pipe_info(pipe);
742 : 472296 : }
743 : :
744 : : static int
745 : 0 : pipe_release(struct inode *inode, struct file *file)
746 : : {
747 : 472293 : struct pipe_inode_info *pipe = file->private_data;
748 : :
749 : : __pipe_lock(pipe);
750 [ + + ]: 472293 : if (file->f_mode & FMODE_READ)
751 : 457710 : pipe->readers--;
752 [ + + ]: 472293 : if (file->f_mode & FMODE_WRITE)
753 : 457687 : pipe->writers--;
754 : :
755 [ # # ][ + + ]: 472293 : if (pipe->readers || pipe->writers) {
756 : 0 : wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM | POLLERR | POLLHUP);
757 : 14614 : kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
758 : 14614 : kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
759 : : }
760 : : __pipe_unlock(pipe);
761 : :
762 : 472293 : put_pipe_info(inode, pipe);
763 : 472293 : return 0;
764 : : }
765 : :
766 : : static int
767 : 0 : pipe_fasync(int fd, struct file *filp, int on)
768 : : {
769 : 0 : struct pipe_inode_info *pipe = filp->private_data;
770 : : int retval = 0;
771 : :
772 : : __pipe_lock(pipe);
773 [ # # ]: 0 : if (filp->f_mode & FMODE_READ)
774 : 0 : retval = fasync_helper(fd, filp, on, &pipe->fasync_readers);
775 [ # # ][ # # ]: 0 : if ((filp->f_mode & FMODE_WRITE) && retval >= 0) {
776 : 0 : retval = fasync_helper(fd, filp, on, &pipe->fasync_writers);
777 [ # # ][ # # ]: 0 : if (retval < 0 && (filp->f_mode & FMODE_READ))
778 : : /* this can happen only if on == T */
779 : 0 : fasync_helper(-1, filp, 0, &pipe->fasync_readers);
780 : : }
781 : : __pipe_unlock(pipe);
782 : 0 : return retval;
783 : : }
784 : :
785 : 0 : struct pipe_inode_info *alloc_pipe_info(void)
786 : : {
787 : : struct pipe_inode_info *pipe;
788 : :
789 : : pipe = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
790 [ + - ]: 457691 : if (pipe) {
791 : 457691 : pipe->bufs = kzalloc(sizeof(struct pipe_buffer) * PIPE_DEF_BUFFERS, GFP_KERNEL);
792 [ + - ]: 457691 : if (pipe->bufs) {
793 : 457691 : init_waitqueue_head(&pipe->wait);
794 : 457691 : pipe->r_counter = pipe->w_counter = 1;
795 : 457691 : pipe->buffers = PIPE_DEF_BUFFERS;
796 : 457691 : mutex_init(&pipe->mutex);
797 : 457691 : return pipe;
798 : : }
799 : 0 : kfree(pipe);
800 : : }
801 : :
802 : : return NULL;
803 : : }
804 : :
805 : 0 : void free_pipe_info(struct pipe_inode_info *pipe)
806 : : {
807 : : int i;
808 : :
809 [ + + ]: 7780747 : for (i = 0; i < pipe->buffers; i++) {
810 : 7323056 : struct pipe_buffer *buf = pipe->bufs + i;
811 [ + + ]: 7323056 : if (buf->ops)
812 : 443134 : buf->ops->release(pipe, buf);
813 : : }
814 [ + + ]: 457691 : if (pipe->tmp_page)
815 : 449129 : __free_page(pipe->tmp_page);
816 : 457691 : kfree(pipe->bufs);
817 : 457691 : kfree(pipe);
818 : 457691 : }
819 : :
820 : : static struct vfsmount *pipe_mnt __read_mostly;
821 : :
822 : : /*
823 : : * pipefs_dname() is called from d_path().
824 : : */
825 : 0 : static char *pipefs_dname(struct dentry *dentry, char *buffer, int buflen)
826 : : {
827 : 0 : return dynamic_dname(dentry, buffer, buflen, "pipe:[%lu]",
828 : 0 : dentry->d_inode->i_ino);
829 : : }
830 : :
831 : : static const struct dentry_operations pipefs_dentry_operations = {
832 : : .d_dname = pipefs_dname,
833 : : };
834 : :
835 : 0 : static struct inode * get_pipe_inode(void)
836 : : {
837 : 14562 : struct inode *inode = new_inode_pseudo(pipe_mnt->mnt_sb);
838 : : struct pipe_inode_info *pipe;
839 : :
840 [ + - ]: 14562 : if (!inode)
841 : : goto fail_inode;
842 : :
843 : 14562 : inode->i_ino = get_next_ino();
844 : :
845 : 14562 : pipe = alloc_pipe_info();
846 [ + - ]: 14562 : if (!pipe)
847 : : goto fail_iput;
848 : :
849 : 14562 : inode->i_pipe = pipe;
850 : 14562 : pipe->files = 2;
851 : 14562 : pipe->readers = pipe->writers = 1;
852 : 14562 : inode->i_fop = &pipefifo_fops;
853 : :
854 : : /*
855 : : * Mark the inode dirty from the very beginning,
856 : : * that way it will never be moved to the dirty
857 : : * list because "mark_inode_dirty()" will think
858 : : * that it already _is_ on the dirty list.
859 : : */
860 : 14562 : inode->i_state = I_DIRTY;
861 : 14562 : inode->i_mode = S_IFIFO | S_IRUSR | S_IWUSR;
862 : 14562 : inode->i_uid = current_fsuid();
863 : 14562 : inode->i_gid = current_fsgid();
864 : 14562 : inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
865 : :
866 : 14562 : return inode;
867 : :
868 : : fail_iput:
869 : 0 : iput(inode);
870 : :
871 : : fail_inode:
872 : : return NULL;
873 : : }
874 : :
875 : 0 : int create_pipe_files(struct file **res, int flags)
876 : : {
877 : : int err;
878 : 14562 : struct inode *inode = get_pipe_inode();
879 : : struct file *f;
880 : : struct path path;
881 : : static struct qstr name = { .name = "" };
882 : :
883 [ + - ]: 14562 : if (!inode)
884 : : return -ENFILE;
885 : :
886 : : err = -ENOMEM;
887 : 14562 : path.dentry = d_alloc_pseudo(pipe_mnt->mnt_sb, &name);
888 [ + - ]: 14562 : if (!path.dentry)
889 : : goto err_inode;
890 : 14562 : path.mnt = mntget(pipe_mnt);
891 : :
892 : 14562 : d_instantiate(path.dentry, inode);
893 : :
894 : : err = -ENFILE;
895 : 14562 : f = alloc_file(&path, FMODE_WRITE, &pipefifo_fops);
896 [ + - ]: 14562 : if (IS_ERR(f))
897 : : goto err_dentry;
898 : :
899 : 14562 : f->f_flags = O_WRONLY | (flags & (O_NONBLOCK | O_DIRECT));
900 : 14562 : f->private_data = inode->i_pipe;
901 : :
902 : 14562 : res[0] = alloc_file(&path, FMODE_READ, &pipefifo_fops);
903 [ + - ]: 14562 : if (IS_ERR(res[0]))
904 : : goto err_file;
905 : :
906 : 14562 : path_get(&path);
907 : 14562 : res[0]->private_data = inode->i_pipe;
908 : 14562 : res[0]->f_flags = O_RDONLY | (flags & O_NONBLOCK);
909 : 14562 : res[1] = f;
910 : 14562 : return 0;
911 : :
912 : : err_file:
913 : 0 : put_filp(f);
914 : : err_dentry:
915 : 0 : free_pipe_info(inode->i_pipe);
916 : 0 : path_put(&path);
917 : 0 : return err;
918 : :
919 : : err_inode:
920 : 0 : free_pipe_info(inode->i_pipe);
921 : 0 : iput(inode);
922 : 0 : return err;
923 : : }
924 : :
925 : 0 : static int __do_pipe_flags(int *fd, struct file **files, int flags)
926 : : {
927 : : int error;
928 : : int fdw, fdr;
929 : :
930 [ + - ]: 14562 : if (flags & ~(O_CLOEXEC | O_NONBLOCK | O_DIRECT))
931 : : return -EINVAL;
932 : :
933 : 14562 : error = create_pipe_files(files, flags);
934 [ + - ]: 14562 : if (error)
935 : : return error;
936 : :
937 : 14562 : error = get_unused_fd_flags(flags);
938 [ + - ]: 14562 : if (error < 0)
939 : : goto err_read_pipe;
940 : : fdr = error;
941 : :
942 : 14562 : error = get_unused_fd_flags(flags);
943 [ + + ]: 14562 : if (error < 0)
944 : : goto err_fdr;
945 : : fdw = error;
946 : :
947 : : audit_fd_pair(fdr, fdw);
948 : 14559 : fd[0] = fdr;
949 : 14559 : fd[1] = fdw;
950 : 14559 : return 0;
951 : :
952 : : err_fdr:
953 : 3 : put_unused_fd(fdr);
954 : : err_read_pipe:
955 : 3 : fput(files[0]);
956 : 3 : fput(files[1]);
957 : 3 : return error;
958 : : }
959 : :
960 : 0 : int do_pipe_flags(int *fd, int flags)
961 : : {
962 : : struct file *files[2];
963 : 0 : int error = __do_pipe_flags(fd, files, flags);
964 [ # # ]: 0 : if (!error) {
965 : 0 : fd_install(fd[0], files[0]);
966 : 0 : fd_install(fd[1], files[1]);
967 : : }
968 : 0 : return error;
969 : : }
970 : :
971 : : /*
972 : : * sys_pipe() is the normal C calling standard for creating
973 : : * a pipe. It's not the way Unix traditionally does this, though.
974 : : */
975 : 0 : SYSCALL_DEFINE2(pipe2, int __user *, fildes, int, flags)
976 : : {
977 : : struct file *files[2];
978 : : int fd[2];
979 : : int error;
980 : :
981 : 14562 : error = __do_pipe_flags(fd, files, flags);
982 [ + + ]: 14562 : if (!error) {
983 [ + + ]: 14559 : if (unlikely(copy_to_user(fildes, fd, sizeof(fd)))) {
984 : 1 : fput(files[0]);
985 : 1 : fput(files[1]);
986 : 1 : put_unused_fd(fd[0]);
987 : 1 : put_unused_fd(fd[1]);
988 : : error = -EFAULT;
989 : : } else {
990 : 14558 : fd_install(fd[0], files[0]);
991 : 14558 : fd_install(fd[1], files[1]);
992 : : }
993 : : }
994 : : return error;
995 : : }
996 : :
997 : 0 : SYSCALL_DEFINE1(pipe, int __user *, fildes)
998 : : {
999 : 14535 : return sys_pipe2(fildes, 0);
1000 : : }
1001 : :
1002 : 0 : static int wait_for_partner(struct pipe_inode_info *pipe, unsigned int *cnt)
1003 : : {
1004 : 12 : int cur = *cnt;
1005 : :
1006 [ + + ]: 24 : while (cur == *cnt) {
1007 : 12 : pipe_wait(pipe);
1008 [ + - ]: 12 : if (signal_pending(current))
1009 : : break;
1010 : : }
1011 [ + ]: 12 : return cur == *cnt ? -ERESTARTSYS : 0;
1012 : : }
1013 : :
1014 : : static void wake_up_partner(struct pipe_inode_info *pipe)
1015 : : {
1016 : 443130 : wake_up_interruptible(&pipe->wait);
1017 : : }
1018 : :
1019 : 0 : static int fifo_open(struct inode *inode, struct file *filp)
1020 : : {
1021 : : struct pipe_inode_info *pipe;
1022 : 443172 : bool is_pipe = inode->i_sb->s_magic == PIPEFS_MAGIC;
1023 : : int ret;
1024 : :
1025 : 443172 : filp->f_version = 0;
1026 : :
1027 : : spin_lock(&inode->i_lock);
1028 [ + + ]: 443172 : if (inode->i_pipe) {
1029 : : pipe = inode->i_pipe;
1030 : 53 : pipe->files++;
1031 : : spin_unlock(&inode->i_lock);
1032 : : } else {
1033 : : spin_unlock(&inode->i_lock);
1034 : 443119 : pipe = alloc_pipe_info();
1035 [ + - ]: 443119 : if (!pipe)
1036 : : return -ENOMEM;
1037 : 443119 : pipe->files = 1;
1038 : : spin_lock(&inode->i_lock);
1039 [ - + ]: 443119 : if (unlikely(inode->i_pipe)) {
1040 : 0 : inode->i_pipe->files++;
1041 : : spin_unlock(&inode->i_lock);
1042 : 0 : free_pipe_info(pipe);
1043 : 0 : pipe = inode->i_pipe;
1044 : : } else {
1045 : 443119 : inode->i_pipe = pipe;
1046 : : spin_unlock(&inode->i_lock);
1047 : : }
1048 : : }
1049 : 443172 : filp->private_data = pipe;
1050 : : /* OK, we have a pipe and it's pinned down */
1051 : :
1052 : : __pipe_lock(pipe);
1053 : :
1054 : : /* We can only do regular read/write on fifos */
1055 : 443172 : filp->f_mode &= (FMODE_READ | FMODE_WRITE);
1056 : :
1057 [ + + + - ]: 443172 : switch (filp->f_mode) {
1058 : : case FMODE_READ:
1059 : : /*
1060 : : * O_RDONLY
1061 : : * POSIX.1 says that O_NONBLOCK means return with the FIFO
1062 : : * opened, even when there is no process writing the FIFO.
1063 : : */
1064 : 44 : pipe->r_counter++;
1065 [ + + ]: 44 : if (pipe->readers++ == 0)
1066 : : wake_up_partner(pipe);
1067 : :
1068 [ + + ][ + + ]: 44 : if (!is_pipe && !pipe->writers) {
1069 [ + + ]: 11 : if ((filp->f_flags & O_NONBLOCK)) {
1070 : : /* suppress POLLHUP until we have
1071 : : * seen a writer */
1072 : 5 : filp->f_version = pipe->w_counter;
1073 : : } else {
1074 [ + - ]: 6 : if (wait_for_partner(pipe, &pipe->w_counter))
1075 : : goto err_rd;
1076 : : }
1077 : : }
1078 : : break;
1079 : :
1080 : : case FMODE_WRITE:
1081 : : /*
1082 : : * O_WRONLY
1083 : : * POSIX.1 says that O_NONBLOCK means return -1 with
1084 : : * errno=ENXIO when there is no process reading the FIFO.
1085 : : */
1086 : : ret = -ENXIO;
1087 [ + - ][ + + ]: 24 : if (!is_pipe && (filp->f_flags & O_NONBLOCK) && !pipe->readers)
[ + + ]
1088 : : goto err;
1089 : :
1090 : 21 : pipe->w_counter++;
1091 [ + + ]: 21 : if (!pipe->writers++)
1092 : : wake_up_partner(pipe);
1093 : :
1094 [ + - ][ + + ]: 21 : if (!is_pipe && !pipe->readers) {
1095 [ + - ]: 6 : if (wait_for_partner(pipe, &pipe->r_counter))
1096 : : goto err_wr;
1097 : : }
1098 : : break;
1099 : :
1100 : : case FMODE_READ | FMODE_WRITE:
1101 : : /*
1102 : : * O_RDWR
1103 : : * POSIX.1 leaves this case "undefined" when O_NONBLOCK is set.
1104 : : * This implementation will NEVER block on a O_RDWR open, since
1105 : : * the process can at least talk to itself.
1106 : : */
1107 : :
1108 : 443104 : pipe->readers++;
1109 : 443104 : pipe->writers++;
1110 : 443104 : pipe->r_counter++;
1111 : 443104 : pipe->w_counter++;
1112 [ - + ][ # # ]: 443104 : if (pipe->readers == 1 || pipe->writers == 1)
1113 : : wake_up_partner(pipe);
1114 : : break;
1115 : :
1116 : : default:
1117 : : ret = -EINVAL;
1118 : : goto err;
1119 : : }
1120 : :
1121 : : /* Ok! */
1122 : : __pipe_unlock(pipe);
1123 : 443169 : return 0;
1124 : :
1125 : : err_rd:
1126 [ # # ]: 0 : if (!--pipe->readers)
1127 : 0 : wake_up_interruptible(&pipe->wait);
1128 : : ret = -ERESTARTSYS;
1129 : : goto err;
1130 : :
1131 : : err_wr:
1132 [ # # ]: 0 : if (!--pipe->writers)
1133 : 0 : wake_up_interruptible(&pipe->wait);
1134 : : ret = -ERESTARTSYS;
1135 : : goto err;
1136 : :
1137 : : err:
1138 : : __pipe_unlock(pipe);
1139 : :
1140 : 3 : put_pipe_info(inode, pipe);
1141 : 3 : return ret;
1142 : : }
1143 : :
1144 : : const struct file_operations pipefifo_fops = {
1145 : : .open = fifo_open,
1146 : : .llseek = no_llseek,
1147 : : .read = do_sync_read,
1148 : : .aio_read = pipe_read,
1149 : : .write = do_sync_write,
1150 : : .aio_write = pipe_write,
1151 : : .poll = pipe_poll,
1152 : : .unlocked_ioctl = pipe_ioctl,
1153 : : .release = pipe_release,
1154 : : .fasync = pipe_fasync,
1155 : : };
1156 : :
1157 : : /*
1158 : : * Allocate a new array of pipe buffers and copy the info over. Returns the
1159 : : * pipe size if successful, or return -ERROR on error.
1160 : : */
1161 : 0 : static long pipe_set_size(struct pipe_inode_info *pipe, unsigned long nr_pages)
1162 : : {
1163 : : struct pipe_buffer *bufs;
1164 : :
1165 : : /*
1166 : : * We can shrink the pipe, if arg >= pipe->nrbufs. Since we don't
1167 : : * expect a lot of shrink+grow operations, just free and allocate
1168 : : * again like we would do for growing. If the pipe currently
1169 : : * contains more buffers than arg, then return busy.
1170 : : */
1171 [ # # ]: 0 : if (nr_pages < pipe->nrbufs)
1172 : : return -EBUSY;
1173 : :
1174 : : bufs = kcalloc(nr_pages, sizeof(*bufs), GFP_KERNEL | __GFP_NOWARN);
1175 [ # # ]: 0 : if (unlikely(!bufs))
1176 : : return -ENOMEM;
1177 : :
1178 : : /*
1179 : : * The pipe array wraps around, so just start the new one at zero
1180 : : * and adjust the indexes.
1181 : : */
1182 [ # # ]: 0 : if (pipe->nrbufs) {
1183 : : unsigned int tail;
1184 : : unsigned int head;
1185 : :
1186 : 0 : tail = pipe->curbuf + pipe->nrbufs;
1187 [ # # ]: 0 : if (tail < pipe->buffers)
1188 : : tail = 0;
1189 : : else
1190 : 0 : tail &= (pipe->buffers - 1);
1191 : :
1192 : 0 : head = pipe->nrbufs - tail;
1193 [ # # ]: 0 : if (head)
1194 : 0 : memcpy(bufs, pipe->bufs + pipe->curbuf, head * sizeof(struct pipe_buffer));
1195 [ # # ]: 0 : if (tail)
1196 : 0 : memcpy(bufs + head, pipe->bufs, tail * sizeof(struct pipe_buffer));
1197 : : }
1198 : :
1199 : 0 : pipe->curbuf = 0;
1200 : 0 : kfree(pipe->bufs);
1201 : 0 : pipe->bufs = bufs;
1202 : 0 : pipe->buffers = nr_pages;
1203 : 0 : return nr_pages * PAGE_SIZE;
1204 : : }
1205 : :
1206 : : /*
1207 : : * Currently we rely on the pipe array holding a power-of-2 number
1208 : : * of pages.
1209 : : */
1210 : : static inline unsigned int round_pipe_size(unsigned int size)
1211 : : {
1212 : : unsigned long nr_pages;
1213 : :
1214 : 2 : nr_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
1215 [ # # ][ # # ]: 2 : return roundup_pow_of_two(nr_pages) << PAGE_SHIFT;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ - - ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
1216 : : }
1217 : :
1218 : : /*
1219 : : * This should work even if CONFIG_PROC_FS isn't set, as proc_dointvec_minmax
1220 : : * will return an error.
1221 : : */
1222 : 0 : int pipe_proc_fn(struct ctl_table *table, int write, void __user *buf,
1223 : : size_t *lenp, loff_t *ppos)
1224 : : {
1225 : : int ret;
1226 : :
1227 : 2 : ret = proc_dointvec_minmax(table, write, buf, lenp, ppos);
1228 [ + - ]: 2 : if (ret < 0 || !write)
1229 : : return ret;
1230 : :
1231 : 2 : pipe_max_size = round_pipe_size(pipe_max_size);
1232 : 0 : return ret;
1233 : : }
1234 : :
1235 : : /*
1236 : : * After the inode slimming patch, i_pipe/i_bdev/i_cdev share the same
1237 : : * location, so checking ->i_pipe is not enough to verify that this is a
1238 : : * pipe.
1239 : : */
1240 : 0 : struct pipe_inode_info *get_pipe_info(struct file *file)
1241 : : {
1242 [ - + ][ + + ]: 37375 : return file->f_op == &pipefifo_fops ? file->private_data : NULL;
1243 : : }
1244 : :
1245 : 0 : long pipe_fcntl(struct file *file, unsigned int cmd, unsigned long arg)
1246 : : {
1247 : : struct pipe_inode_info *pipe;
1248 : : long ret;
1249 : :
1250 : : pipe = get_pipe_info(file);
1251 [ - + ]: 2 : if (!pipe)
1252 : : return -EBADF;
1253 : :
1254 : : __pipe_lock(pipe);
1255 : :
1256 [ # # # ]: 0 : switch (cmd) {
1257 : : case F_SETPIPE_SZ: {
1258 : : unsigned int size, nr_pages;
1259 : :
1260 : : size = round_pipe_size(arg);
1261 : 0 : nr_pages = size >> PAGE_SHIFT;
1262 : :
1263 : : ret = -EINVAL;
1264 [ - ]: 0 : if (!nr_pages)
1265 : : goto out;
1266 : :
1267 [ # # ][ # # ]: 0 : if (!capable(CAP_SYS_RESOURCE) && size > pipe_max_size) {
1268 : : ret = -EPERM;
1269 : : goto out;
1270 : : }
1271 : 0 : ret = pipe_set_size(pipe, nr_pages);
1272 : 0 : break;
1273 : : }
1274 : : case F_GETPIPE_SZ:
1275 : 0 : ret = pipe->buffers * PAGE_SIZE;
1276 : 0 : break;
1277 : : default:
1278 : : ret = -EINVAL;
1279 : : break;
1280 : : }
1281 : :
1282 : : out:
1283 : : __pipe_unlock(pipe);
1284 : 0 : return ret;
1285 : : }
1286 : :
1287 : : static const struct super_operations pipefs_ops = {
1288 : : .destroy_inode = free_inode_nonrcu,
1289 : : .statfs = simple_statfs,
1290 : : };
1291 : :
1292 : : /*
1293 : : * pipefs should _never_ be mounted by userland - too much of security hassle,
1294 : : * no real gain from having the whole whorehouse mounted. So we don't need
1295 : : * any operations on the root directory. However, we need a non-trivial
1296 : : * d_name - pipe: will go nicely and kill the special-casing in procfs.
1297 : : */
1298 : 0 : static struct dentry *pipefs_mount(struct file_system_type *fs_type,
1299 : : int flags, const char *dev_name, void *data)
1300 : : {
1301 : 0 : return mount_pseudo(fs_type, "pipe:", &pipefs_ops,
1302 : : &pipefs_dentry_operations, PIPEFS_MAGIC);
1303 : : }
1304 : :
1305 : : static struct file_system_type pipe_fs_type = {
1306 : : .name = "pipefs",
1307 : : .mount = pipefs_mount,
1308 : : .kill_sb = kill_anon_super,
1309 : : };
1310 : :
1311 : 0 : static int __init init_pipe_fs(void)
1312 : : {
1313 : 0 : int err = register_filesystem(&pipe_fs_type);
1314 : :
1315 [ # # ]: 0 : if (!err) {
1316 : 0 : pipe_mnt = kern_mount(&pipe_fs_type);
1317 [ # # ]: 0 : if (IS_ERR(pipe_mnt)) {
1318 : : err = PTR_ERR(pipe_mnt);
1319 : 0 : unregister_filesystem(&pipe_fs_type);
1320 : : }
1321 : : }
1322 : 0 : return err;
1323 : : }
1324 : :
1325 : : fs_initcall(init_pipe_fs);
|
