4 * Copyright (C) 1991, 1992, 1999 Linus Torvalds
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>
14 #include <linux/mount.h>
15 #include <linux/pipe_fs_i.h>
16 #include <linux/uio.h>
17 #include <linux/highmem.h>
18 #include <linux/pagemap.h>
19 #include <linux/audit.h>
20 #include <linux/syscalls.h>
22 #include <asm/uaccess.h>
23 #include <asm/ioctls.h>
26 * We use a start+len construction, which provides full use of the
28 * -- Florian Coosmann (FGC)
30 * Reads with count = 0 should always return 0.
31 * -- Julian Bradfield 1999-06-07.
33 * FIFOs and Pipes now generate SIGIO for both readers and writers.
34 * -- Jeremy Elson <jelson@circlemud.org> 2001-08-16
36 * pipe_read & write cleanup
37 * -- Manfred Spraul <manfred@colorfullife.com> 2002-05-09
40 static void pipe_lock_nested(struct pipe_inode_info
*pipe
, int subclass
)
43 mutex_lock_nested(&pipe
->inode
->i_mutex
, subclass
);
46 void pipe_lock(struct pipe_inode_info
*pipe
)
49 * pipe_lock() nests non-pipe inode locks (for writing to a file)
51 pipe_lock_nested(pipe
, I_MUTEX_PARENT
);
53 EXPORT_SYMBOL(pipe_lock
);
55 void pipe_unlock(struct pipe_inode_info
*pipe
)
58 mutex_unlock(&pipe
->inode
->i_mutex
);
60 EXPORT_SYMBOL(pipe_unlock
);
62 void pipe_double_lock(struct pipe_inode_info
*pipe1
,
63 struct pipe_inode_info
*pipe2
)
65 BUG_ON(pipe1
== pipe2
);
68 pipe_lock_nested(pipe1
, I_MUTEX_PARENT
);
69 pipe_lock_nested(pipe2
, I_MUTEX_CHILD
);
71 pipe_lock_nested(pipe2
, I_MUTEX_PARENT
);
72 pipe_lock_nested(pipe1
, I_MUTEX_CHILD
);
76 /* Drop the inode semaphore and wait for a pipe event, atomically */
77 void pipe_wait(struct pipe_inode_info
*pipe
)
82 * Pipes are system-local resources, so sleeping on them
83 * is considered a noninteractive wait:
85 prepare_to_wait(&pipe
->wait
, &wait
, TASK_INTERRUPTIBLE
);
88 finish_wait(&pipe
->wait
, &wait
);
93 pipe_iov_copy_from_user(void *to
, struct iovec
*iov
, unsigned long len
,
101 copy
= min_t(unsigned long, len
, iov
->iov_len
);
104 if (__copy_from_user_inatomic(to
, iov
->iov_base
, copy
))
107 if (copy_from_user(to
, iov
->iov_base
, copy
))
112 iov
->iov_base
+= copy
;
113 iov
->iov_len
-= copy
;
119 pipe_iov_copy_to_user(struct iovec
*iov
, const void *from
, unsigned long len
,
125 while (!iov
->iov_len
)
127 copy
= min_t(unsigned long, len
, iov
->iov_len
);
130 if (__copy_to_user_inatomic(iov
->iov_base
, from
, copy
))
133 if (copy_to_user(iov
->iov_base
, from
, copy
))
138 iov
->iov_base
+= copy
;
139 iov
->iov_len
-= copy
;
145 * Attempt to pre-fault in the user memory, so we can use atomic copies.
146 * Returns the number of bytes not faulted in.
148 static int iov_fault_in_pages_write(struct iovec
*iov
, unsigned long len
)
150 while (!iov
->iov_len
)
154 unsigned long this_len
;
156 this_len
= min_t(unsigned long, len
, iov
->iov_len
);
157 if (fault_in_pages_writeable(iov
->iov_base
, this_len
))
168 * Pre-fault in the user memory, so we can use atomic copies.
170 static void iov_fault_in_pages_read(struct iovec
*iov
, unsigned long len
)
172 while (!iov
->iov_len
)
176 unsigned long this_len
;
178 this_len
= min_t(unsigned long, len
, iov
->iov_len
);
179 fault_in_pages_readable(iov
->iov_base
, this_len
);
185 static void anon_pipe_buf_release(struct pipe_inode_info
*pipe
,
186 struct pipe_buffer
*buf
)
188 struct page
*page
= buf
->page
;
191 * If nobody else uses this page, and we don't already have a
192 * temporary page, let's keep track of it as a one-deep
193 * allocation cache. (Otherwise just release our reference to it)
195 if (page_count(page
) == 1 && !pipe
->tmp_page
)
196 pipe
->tmp_page
= page
;
198 page_cache_release(page
);
202 * generic_pipe_buf_map - virtually map a pipe buffer
203 * @pipe: the pipe that the buffer belongs to
204 * @buf: the buffer that should be mapped
205 * @atomic: whether to use an atomic map
208 * This function returns a kernel virtual address mapping for the
209 * pipe_buffer passed in @buf. If @atomic is set, an atomic map is provided
210 * and the caller has to be careful not to fault before calling
211 * the unmap function.
213 * Note that this function occupies KM_USER0 if @atomic != 0.
215 void *generic_pipe_buf_map(struct pipe_inode_info
*pipe
,
216 struct pipe_buffer
*buf
, int atomic
)
219 buf
->flags
|= PIPE_BUF_FLAG_ATOMIC
;
220 return kmap_atomic(buf
->page
, KM_USER0
);
223 return kmap(buf
->page
);
227 * generic_pipe_buf_unmap - unmap a previously mapped pipe buffer
228 * @pipe: the pipe that the buffer belongs to
229 * @buf: the buffer that should be unmapped
230 * @map_data: the data that the mapping function returned
233 * This function undoes the mapping that ->map() provided.
235 void generic_pipe_buf_unmap(struct pipe_inode_info
*pipe
,
236 struct pipe_buffer
*buf
, void *map_data
)
238 if (buf
->flags
& PIPE_BUF_FLAG_ATOMIC
) {
239 buf
->flags
&= ~PIPE_BUF_FLAG_ATOMIC
;
240 kunmap_atomic(map_data
, KM_USER0
);
246 * generic_pipe_buf_steal - attempt to take ownership of a &pipe_buffer
247 * @pipe: the pipe that the buffer belongs to
248 * @buf: the buffer to attempt to steal
251 * This function attempts to steal the &struct page attached to
252 * @buf. If successful, this function returns 0 and returns with
253 * the page locked. The caller may then reuse the page for whatever
254 * he wishes; the typical use is insertion into a different file
257 int generic_pipe_buf_steal(struct pipe_inode_info
*pipe
,
258 struct pipe_buffer
*buf
)
260 struct page
*page
= buf
->page
;
263 * A reference of one is golden, that means that the owner of this
264 * page is the only one holding a reference to it. lock the page
267 if (page_count(page
) == 1) {
276 * generic_pipe_buf_get - get a reference to a &struct pipe_buffer
277 * @pipe: the pipe that the buffer belongs to
278 * @buf: the buffer to get a reference to
281 * This function grabs an extra reference to @buf. It's used in
282 * in the tee() system call, when we duplicate the buffers in one
285 void generic_pipe_buf_get(struct pipe_inode_info
*pipe
, struct pipe_buffer
*buf
)
287 page_cache_get(buf
->page
);
291 * generic_pipe_buf_confirm - verify contents of the pipe buffer
292 * @info: the pipe that the buffer belongs to
293 * @buf: the buffer to confirm
296 * This function does nothing, because the generic pipe code uses
297 * pages that are always good when inserted into the pipe.
299 int generic_pipe_buf_confirm(struct pipe_inode_info
*info
,
300 struct pipe_buffer
*buf
)
306 * generic_pipe_buf_release - put a reference to a &struct pipe_buffer
307 * @pipe: the pipe that the buffer belongs to
308 * @buf: the buffer to put a reference to
311 * This function releases a reference to @buf.
313 void generic_pipe_buf_release(struct pipe_inode_info
*pipe
,
314 struct pipe_buffer
*buf
)
316 page_cache_release(buf
->page
);
319 static const struct pipe_buf_operations anon_pipe_buf_ops
= {
321 .map
= generic_pipe_buf_map
,
322 .unmap
= generic_pipe_buf_unmap
,
323 .confirm
= generic_pipe_buf_confirm
,
324 .release
= anon_pipe_buf_release
,
325 .steal
= generic_pipe_buf_steal
,
326 .get
= generic_pipe_buf_get
,
330 pipe_read(struct kiocb
*iocb
, const struct iovec
*_iov
,
331 unsigned long nr_segs
, loff_t pos
)
333 struct file
*filp
= iocb
->ki_filp
;
334 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
335 struct pipe_inode_info
*pipe
;
338 struct iovec
*iov
= (struct iovec
*)_iov
;
341 total_len
= iov_length(iov
, nr_segs
);
342 /* Null read succeeds. */
343 if (unlikely(total_len
== 0))
348 mutex_lock(&inode
->i_mutex
);
349 pipe
= inode
->i_pipe
;
351 int bufs
= pipe
->nrbufs
;
353 int curbuf
= pipe
->curbuf
;
354 struct pipe_buffer
*buf
= pipe
->bufs
+ curbuf
;
355 const struct pipe_buf_operations
*ops
= buf
->ops
;
357 size_t chars
= buf
->len
;
360 if (chars
> total_len
)
363 error
= ops
->confirm(pipe
, buf
);
370 atomic
= !iov_fault_in_pages_write(iov
, chars
);
372 addr
= ops
->map(pipe
, buf
, atomic
);
373 error
= pipe_iov_copy_to_user(iov
, addr
+ buf
->offset
, chars
, atomic
);
374 ops
->unmap(pipe
, buf
, addr
);
375 if (unlikely(error
)) {
377 * Just retry with the slow path if we failed.
388 buf
->offset
+= chars
;
392 ops
->release(pipe
, buf
);
393 curbuf
= (curbuf
+ 1) & (PIPE_BUFFERS
-1);
394 pipe
->curbuf
= curbuf
;
395 pipe
->nrbufs
= --bufs
;
400 break; /* common path: read succeeded */
402 if (bufs
) /* More to do? */
406 if (!pipe
->waiting_writers
) {
407 /* syscall merging: Usually we must not sleep
408 * if O_NONBLOCK is set, or if we got some data.
409 * But if a writer sleeps in kernel space, then
410 * we can wait for that data without violating POSIX.
414 if (filp
->f_flags
& O_NONBLOCK
) {
419 if (signal_pending(current
)) {
425 wake_up_interruptible_sync(&pipe
->wait
);
426 kill_fasync(&pipe
->fasync_writers
, SIGIO
, POLL_OUT
);
430 mutex_unlock(&inode
->i_mutex
);
432 /* Signal writers asynchronously that there is more room. */
434 wake_up_interruptible_sync(&pipe
->wait
);
435 kill_fasync(&pipe
->fasync_writers
, SIGIO
, POLL_OUT
);
443 pipe_write(struct kiocb
*iocb
, const struct iovec
*_iov
,
444 unsigned long nr_segs
, loff_t ppos
)
446 struct file
*filp
= iocb
->ki_filp
;
447 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
448 struct pipe_inode_info
*pipe
;
451 struct iovec
*iov
= (struct iovec
*)_iov
;
455 total_len
= iov_length(iov
, nr_segs
);
456 /* Null write succeeds. */
457 if (unlikely(total_len
== 0))
462 mutex_lock(&inode
->i_mutex
);
463 pipe
= inode
->i_pipe
;
465 if (!pipe
->readers
) {
466 send_sig(SIGPIPE
, current
, 0);
471 /* We try to merge small writes */
472 chars
= total_len
& (PAGE_SIZE
-1); /* size of the last buffer */
473 if (pipe
->nrbufs
&& chars
!= 0) {
474 int lastbuf
= (pipe
->curbuf
+ pipe
->nrbufs
- 1) &
476 struct pipe_buffer
*buf
= pipe
->bufs
+ lastbuf
;
477 const struct pipe_buf_operations
*ops
= buf
->ops
;
478 int offset
= buf
->offset
+ buf
->len
;
480 if (ops
->can_merge
&& offset
+ chars
<= PAGE_SIZE
) {
481 int error
, atomic
= 1;
484 error
= ops
->confirm(pipe
, buf
);
488 iov_fault_in_pages_read(iov
, chars
);
490 addr
= ops
->map(pipe
, buf
, atomic
);
491 error
= pipe_iov_copy_from_user(offset
+ addr
, iov
,
493 ops
->unmap(pipe
, buf
, addr
);
514 if (!pipe
->readers
) {
515 send_sig(SIGPIPE
, current
, 0);
521 if (bufs
< PIPE_BUFFERS
) {
522 int newbuf
= (pipe
->curbuf
+ bufs
) & (PIPE_BUFFERS
-1);
523 struct pipe_buffer
*buf
= pipe
->bufs
+ newbuf
;
524 struct page
*page
= pipe
->tmp_page
;
526 int error
, atomic
= 1;
529 page
= alloc_page(GFP_HIGHUSER
);
530 if (unlikely(!page
)) {
531 ret
= ret
? : -ENOMEM
;
534 pipe
->tmp_page
= page
;
536 /* Always wake up, even if the copy fails. Otherwise
537 * we lock up (O_NONBLOCK-)readers that sleep due to
539 * FIXME! Is this really true?
543 if (chars
> total_len
)
546 iov_fault_in_pages_read(iov
, chars
);
549 src
= kmap_atomic(page
, KM_USER0
);
553 error
= pipe_iov_copy_from_user(src
, iov
, chars
,
556 kunmap_atomic(src
, KM_USER0
);
560 if (unlikely(error
)) {
571 /* Insert it into the buffer array */
573 buf
->ops
= &anon_pipe_buf_ops
;
576 pipe
->nrbufs
= ++bufs
;
577 pipe
->tmp_page
= NULL
;
583 if (bufs
< PIPE_BUFFERS
)
585 if (filp
->f_flags
& O_NONBLOCK
) {
590 if (signal_pending(current
)) {
596 wake_up_interruptible_sync(&pipe
->wait
);
597 kill_fasync(&pipe
->fasync_readers
, SIGIO
, POLL_IN
);
600 pipe
->waiting_writers
++;
602 pipe
->waiting_writers
--;
605 mutex_unlock(&inode
->i_mutex
);
607 wake_up_interruptible_sync(&pipe
->wait
);
608 kill_fasync(&pipe
->fasync_readers
, SIGIO
, POLL_IN
);
611 file_update_time(filp
);
616 bad_pipe_r(struct file
*filp
, char __user
*buf
, size_t count
, loff_t
*ppos
)
622 bad_pipe_w(struct file
*filp
, const char __user
*buf
, size_t count
,
628 static long pipe_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
630 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
631 struct pipe_inode_info
*pipe
;
632 int count
, buf
, nrbufs
;
636 mutex_lock(&inode
->i_mutex
);
637 pipe
= inode
->i_pipe
;
640 nrbufs
= pipe
->nrbufs
;
641 while (--nrbufs
>= 0) {
642 count
+= pipe
->bufs
[buf
].len
;
643 buf
= (buf
+1) & (PIPE_BUFFERS
-1);
645 mutex_unlock(&inode
->i_mutex
);
647 return put_user(count
, (int __user
*)arg
);
653 /* No kernel lock held - fine */
655 pipe_poll(struct file
*filp
, poll_table
*wait
)
658 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
659 struct pipe_inode_info
*pipe
= inode
->i_pipe
;
662 poll_wait(filp
, &pipe
->wait
, wait
);
664 /* Reading only -- no need for acquiring the semaphore. */
665 nrbufs
= pipe
->nrbufs
;
667 if (filp
->f_mode
& FMODE_READ
) {
668 mask
= (nrbufs
> 0) ? POLLIN
| POLLRDNORM
: 0;
669 if (!pipe
->writers
&& filp
->f_version
!= pipe
->w_counter
)
673 if (filp
->f_mode
& FMODE_WRITE
) {
674 mask
|= (nrbufs
< PIPE_BUFFERS
) ? POLLOUT
| POLLWRNORM
: 0;
676 * Most Unices do not set POLLERR for FIFOs but on Linux they
677 * behave exactly like pipes for poll().
687 pipe_release(struct inode
*inode
, int decr
, int decw
)
689 struct pipe_inode_info
*pipe
;
691 mutex_lock(&inode
->i_mutex
);
692 pipe
= inode
->i_pipe
;
693 pipe
->readers
-= decr
;
694 pipe
->writers
-= decw
;
696 if (!pipe
->readers
&& !pipe
->writers
) {
697 free_pipe_info(inode
);
699 wake_up_interruptible_sync(&pipe
->wait
);
700 kill_fasync(&pipe
->fasync_readers
, SIGIO
, POLL_IN
);
701 kill_fasync(&pipe
->fasync_writers
, SIGIO
, POLL_OUT
);
703 mutex_unlock(&inode
->i_mutex
);
709 pipe_read_fasync(int fd
, struct file
*filp
, int on
)
711 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
714 mutex_lock(&inode
->i_mutex
);
715 retval
= fasync_helper(fd
, filp
, on
, &inode
->i_pipe
->fasync_readers
);
716 mutex_unlock(&inode
->i_mutex
);
723 pipe_write_fasync(int fd
, struct file
*filp
, int on
)
725 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
728 mutex_lock(&inode
->i_mutex
);
729 retval
= fasync_helper(fd
, filp
, on
, &inode
->i_pipe
->fasync_writers
);
730 mutex_unlock(&inode
->i_mutex
);
737 pipe_rdwr_fasync(int fd
, struct file
*filp
, int on
)
739 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
740 struct pipe_inode_info
*pipe
= inode
->i_pipe
;
743 mutex_lock(&inode
->i_mutex
);
744 retval
= fasync_helper(fd
, filp
, on
, &pipe
->fasync_readers
);
746 retval
= fasync_helper(fd
, filp
, on
, &pipe
->fasync_writers
);
747 if (retval
< 0) /* this can happen only if on == T */
748 fasync_helper(-1, filp
, 0, &pipe
->fasync_readers
);
750 mutex_unlock(&inode
->i_mutex
);
756 pipe_read_release(struct inode
*inode
, struct file
*filp
)
758 return pipe_release(inode
, 1, 0);
762 pipe_write_release(struct inode
*inode
, struct file
*filp
)
764 return pipe_release(inode
, 0, 1);
768 pipe_rdwr_release(struct inode
*inode
, struct file
*filp
)
772 decr
= (filp
->f_mode
& FMODE_READ
) != 0;
773 decw
= (filp
->f_mode
& FMODE_WRITE
) != 0;
774 return pipe_release(inode
, decr
, decw
);
778 pipe_read_open(struct inode
*inode
, struct file
*filp
)
780 /* We could have perhaps used atomic_t, but this and friends
781 below are the only places. So it doesn't seem worthwhile. */
782 mutex_lock(&inode
->i_mutex
);
783 inode
->i_pipe
->readers
++;
784 mutex_unlock(&inode
->i_mutex
);
790 pipe_write_open(struct inode
*inode
, struct file
*filp
)
792 mutex_lock(&inode
->i_mutex
);
793 inode
->i_pipe
->writers
++;
794 mutex_unlock(&inode
->i_mutex
);
800 pipe_rdwr_open(struct inode
*inode
, struct file
*filp
)
802 mutex_lock(&inode
->i_mutex
);
803 if (filp
->f_mode
& FMODE_READ
)
804 inode
->i_pipe
->readers
++;
805 if (filp
->f_mode
& FMODE_WRITE
)
806 inode
->i_pipe
->writers
++;
807 mutex_unlock(&inode
->i_mutex
);
813 * The file_operations structs are not static because they
814 * are also used in linux/fs/fifo.c to do operations on FIFOs.
816 * Pipes reuse fifos' file_operations structs.
818 const struct file_operations read_pipefifo_fops
= {
820 .read
= do_sync_read
,
821 .aio_read
= pipe_read
,
824 .unlocked_ioctl
= pipe_ioctl
,
825 .open
= pipe_read_open
,
826 .release
= pipe_read_release
,
827 .fasync
= pipe_read_fasync
,
830 const struct file_operations write_pipefifo_fops
= {
833 .write
= do_sync_write
,
834 .aio_write
= pipe_write
,
836 .unlocked_ioctl
= pipe_ioctl
,
837 .open
= pipe_write_open
,
838 .release
= pipe_write_release
,
839 .fasync
= pipe_write_fasync
,
842 const struct file_operations rdwr_pipefifo_fops
= {
844 .read
= do_sync_read
,
845 .aio_read
= pipe_read
,
846 .write
= do_sync_write
,
847 .aio_write
= pipe_write
,
849 .unlocked_ioctl
= pipe_ioctl
,
850 .open
= pipe_rdwr_open
,
851 .release
= pipe_rdwr_release
,
852 .fasync
= pipe_rdwr_fasync
,
855 struct pipe_inode_info
* alloc_pipe_info(struct inode
*inode
)
857 struct pipe_inode_info
*pipe
;
859 pipe
= kzalloc(sizeof(struct pipe_inode_info
), GFP_KERNEL
);
861 init_waitqueue_head(&pipe
->wait
);
862 pipe
->r_counter
= pipe
->w_counter
= 1;
869 void __free_pipe_info(struct pipe_inode_info
*pipe
)
873 for (i
= 0; i
< PIPE_BUFFERS
; i
++) {
874 struct pipe_buffer
*buf
= pipe
->bufs
+ i
;
876 buf
->ops
->release(pipe
, buf
);
879 __free_page(pipe
->tmp_page
);
883 void free_pipe_info(struct inode
*inode
)
885 __free_pipe_info(inode
->i_pipe
);
886 inode
->i_pipe
= NULL
;
889 static struct vfsmount
*pipe_mnt __read_mostly
;
892 * pipefs_dname() is called from d_path().
894 static char *pipefs_dname(struct dentry
*dentry
, char *buffer
, int buflen
)
896 return dynamic_dname(dentry
, buffer
, buflen
, "pipe:[%lu]",
897 dentry
->d_inode
->i_ino
);
900 static const struct dentry_operations pipefs_dentry_operations
= {
901 .d_dname
= pipefs_dname
,
904 static struct inode
* get_pipe_inode(void)
906 struct inode
*inode
= new_inode(pipe_mnt
->mnt_sb
);
907 struct pipe_inode_info
*pipe
;
912 pipe
= alloc_pipe_info(inode
);
915 inode
->i_pipe
= pipe
;
917 pipe
->readers
= pipe
->writers
= 1;
918 inode
->i_fop
= &rdwr_pipefifo_fops
;
921 * Mark the inode dirty from the very beginning,
922 * that way it will never be moved to the dirty
923 * list because "mark_inode_dirty()" will think
924 * that it already _is_ on the dirty list.
926 inode
->i_state
= I_DIRTY
;
927 inode
->i_mode
= S_IFIFO
| S_IRUSR
| S_IWUSR
;
928 inode
->i_uid
= current_fsuid();
929 inode
->i_gid
= current_fsgid();
930 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
941 struct file
*create_write_pipe(int flags
)
946 struct dentry
*dentry
;
947 struct qstr name
= { .name
= "" };
950 inode
= get_pipe_inode();
955 dentry
= d_alloc(pipe_mnt
->mnt_sb
->s_root
, &name
);
959 dentry
->d_op
= &pipefs_dentry_operations
;
960 d_instantiate(dentry
, inode
);
963 f
= alloc_file(pipe_mnt
, dentry
, FMODE_WRITE
, &write_pipefifo_fops
);
966 f
->f_mapping
= inode
->i_mapping
;
968 f
->f_flags
= O_WRONLY
| (flags
& O_NONBLOCK
);
974 free_pipe_info(inode
);
979 free_pipe_info(inode
);
985 void free_write_pipe(struct file
*f
)
987 free_pipe_info(f
->f_dentry
->d_inode
);
988 path_put(&f
->f_path
);
992 struct file
*create_read_pipe(struct file
*wrf
, int flags
)
994 struct file
*f
= get_empty_filp();
996 return ERR_PTR(-ENFILE
);
998 /* Grab pipe from the writer */
999 f
->f_path
= wrf
->f_path
;
1000 path_get(&wrf
->f_path
);
1001 f
->f_mapping
= wrf
->f_path
.dentry
->d_inode
->i_mapping
;
1004 f
->f_flags
= O_RDONLY
| (flags
& O_NONBLOCK
);
1005 f
->f_op
= &read_pipefifo_fops
;
1006 f
->f_mode
= FMODE_READ
;
1012 int do_pipe_flags(int *fd
, int flags
)
1014 struct file
*fw
, *fr
;
1018 if (flags
& ~(O_CLOEXEC
| O_NONBLOCK
))
1021 fw
= create_write_pipe(flags
);
1024 fr
= create_read_pipe(fw
, flags
);
1025 error
= PTR_ERR(fr
);
1027 goto err_write_pipe
;
1029 error
= get_unused_fd_flags(flags
);
1034 error
= get_unused_fd_flags(flags
);
1039 audit_fd_pair(fdr
, fdw
);
1040 fd_install(fdr
, fr
);
1041 fd_install(fdw
, fw
);
1050 path_put(&fr
->f_path
);
1053 free_write_pipe(fw
);
1058 * sys_pipe() is the normal C calling standard for creating
1059 * a pipe. It's not the way Unix traditionally does this, though.
1061 SYSCALL_DEFINE2(pipe2
, int __user
*, fildes
, int, flags
)
1066 error
= do_pipe_flags(fd
, flags
);
1068 if (copy_to_user(fildes
, fd
, sizeof(fd
))) {
1077 SYSCALL_DEFINE1(pipe
, int __user
*, fildes
)
1079 return sys_pipe2(fildes
, 0);
1083 * pipefs should _never_ be mounted by userland - too much of security hassle,
1084 * no real gain from having the whole whorehouse mounted. So we don't need
1085 * any operations on the root directory. However, we need a non-trivial
1086 * d_name - pipe: will go nicely and kill the special-casing in procfs.
1088 static int pipefs_get_sb(struct file_system_type
*fs_type
,
1089 int flags
, const char *dev_name
, void *data
,
1090 struct vfsmount
*mnt
)
1092 return get_sb_pseudo(fs_type
, "pipe:", NULL
, PIPEFS_MAGIC
, mnt
);
1095 static struct file_system_type pipe_fs_type
= {
1097 .get_sb
= pipefs_get_sb
,
1098 .kill_sb
= kill_anon_super
,
1101 static int __init
init_pipe_fs(void)
1103 int err
= register_filesystem(&pipe_fs_type
);
1106 pipe_mnt
= kern_mount(&pipe_fs_type
);
1107 if (IS_ERR(pipe_mnt
)) {
1108 err
= PTR_ERR(pipe_mnt
);
1109 unregister_filesystem(&pipe_fs_type
);
1115 static void __exit
exit_pipe_fs(void)
1117 unregister_filesystem(&pipe_fs_type
);
1121 fs_initcall(init_pipe_fs
);
1122 module_exit(exit_pipe_fs
);