blob: 9a06e8e48e8dfb366a8c08bd387985788391a5d8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/pipe.c
3 *
4 * Copyright (C) 1991, 1992, 1999 Linus Torvalds
5 */
6
7#include <linux/mm.h>
8#include <linux/file.h>
9#include <linux/poll.h>
10#include <linux/slab.h>
11#include <linux/module.h>
12#include <linux/init.h>
13#include <linux/fs.h>
14#include <linux/mount.h>
15#include <linux/pipe_fs_i.h>
16#include <linux/uio.h>
17#include <linux/highmem.h>
Jens Axboe5274f052006-03-30 15:15:30 +020018#include <linux/pagemap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019
20#include <asm/uaccess.h>
21#include <asm/ioctls.h>
22
23/*
24 * We use a start+len construction, which provides full use of the
25 * allocated memory.
26 * -- Florian Coosmann (FGC)
27 *
28 * Reads with count = 0 should always return 0.
29 * -- Julian Bradfield 1999-06-07.
30 *
31 * FIFOs and Pipes now generate SIGIO for both readers and writers.
32 * -- Jeremy Elson <jelson@circlemud.org> 2001-08-16
33 *
34 * pipe_read & write cleanup
35 * -- Manfred Spraul <manfred@colorfullife.com> 2002-05-09
36 */
37
38/* Drop the inode semaphore and wait for a pipe event, atomically */
Ingo Molnar3a326a22006-04-10 15:18:35 +020039void pipe_wait(struct pipe_inode_info *pipe)
Linus Torvalds1da177e2005-04-16 15:20:36 -070040{
41 DEFINE_WAIT(wait);
42
Ingo Molnard79fc0f2005-09-10 00:26:12 -070043 /*
44 * Pipes are system-local resources, so sleeping on them
45 * is considered a noninteractive wait:
46 */
Ingo Molnar341b4462006-04-11 13:57:45 +020047 prepare_to_wait(&pipe->wait, &wait,
48 TASK_INTERRUPTIBLE | TASK_NONINTERACTIVE);
Ingo Molnar3a326a22006-04-10 15:18:35 +020049 if (pipe->inode)
50 mutex_unlock(&pipe->inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 schedule();
Ingo Molnar3a326a22006-04-10 15:18:35 +020052 finish_wait(&pipe->wait, &wait);
53 if (pipe->inode)
54 mutex_lock(&pipe->inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055}
56
Arjan van de Ven858119e2006-01-14 13:20:43 -080057static int
Jens Axboef6762b72006-05-01 20:02:05 +020058pipe_iov_copy_from_user(void *to, struct iovec *iov, unsigned long len,
59 int atomic)
Linus Torvalds1da177e2005-04-16 15:20:36 -070060{
61 unsigned long copy;
62
63 while (len > 0) {
64 while (!iov->iov_len)
65 iov++;
66 copy = min_t(unsigned long, len, iov->iov_len);
67
Jens Axboef6762b72006-05-01 20:02:05 +020068 if (atomic) {
69 if (__copy_from_user_inatomic(to, iov->iov_base, copy))
70 return -EFAULT;
71 } else {
72 if (copy_from_user(to, iov->iov_base, copy))
73 return -EFAULT;
74 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 to += copy;
76 len -= copy;
77 iov->iov_base += copy;
78 iov->iov_len -= copy;
79 }
80 return 0;
81}
82
Arjan van de Ven858119e2006-01-14 13:20:43 -080083static int
Jens Axboef6762b72006-05-01 20:02:05 +020084pipe_iov_copy_to_user(struct iovec *iov, const void *from, unsigned long len,
85 int atomic)
Linus Torvalds1da177e2005-04-16 15:20:36 -070086{
87 unsigned long copy;
88
89 while (len > 0) {
90 while (!iov->iov_len)
91 iov++;
92 copy = min_t(unsigned long, len, iov->iov_len);
93
Jens Axboef6762b72006-05-01 20:02:05 +020094 if (atomic) {
95 if (__copy_to_user_inatomic(iov->iov_base, from, copy))
96 return -EFAULT;
97 } else {
98 if (copy_to_user(iov->iov_base, from, copy))
99 return -EFAULT;
100 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 from += copy;
102 len -= copy;
103 iov->iov_base += copy;
104 iov->iov_len -= copy;
105 }
106 return 0;
107}
108
Jens Axboef6762b72006-05-01 20:02:05 +0200109/*
110 * Attempt to pre-fault in the user memory, so we can use atomic copies.
111 * Returns the number of bytes not faulted in.
112 */
113static int iov_fault_in_pages_write(struct iovec *iov, unsigned long len)
114{
115 while (!iov->iov_len)
116 iov++;
117
118 while (len > 0) {
119 unsigned long this_len;
120
121 this_len = min_t(unsigned long, len, iov->iov_len);
122 if (fault_in_pages_writeable(iov->iov_base, this_len))
123 break;
124
125 len -= this_len;
126 iov++;
127 }
128
129 return len;
130}
131
132/*
133 * Pre-fault in the user memory, so we can use atomic copies.
134 */
135static void iov_fault_in_pages_read(struct iovec *iov, unsigned long len)
136{
137 while (!iov->iov_len)
138 iov++;
139
140 while (len > 0) {
141 unsigned long this_len;
142
143 this_len = min_t(unsigned long, len, iov->iov_len);
144 fault_in_pages_readable(iov->iov_base, this_len);
145 len -= this_len;
146 iov++;
147 }
148}
149
Ingo Molnar341b4462006-04-11 13:57:45 +0200150static void anon_pipe_buf_release(struct pipe_inode_info *pipe,
151 struct pipe_buffer *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152{
153 struct page *page = buf->page;
154
Jens Axboe5274f052006-03-30 15:15:30 +0200155 /*
156 * If nobody else uses this page, and we don't already have a
157 * temporary page, let's keep track of it as a one-deep
Ingo Molnar341b4462006-04-11 13:57:45 +0200158 * allocation cache. (Otherwise just release our reference to it)
Jens Axboe5274f052006-03-30 15:15:30 +0200159 */
Ingo Molnar341b4462006-04-11 13:57:45 +0200160 if (page_count(page) == 1 && !pipe->tmp_page)
Ingo Molnar923f4f22006-04-11 13:53:33 +0200161 pipe->tmp_page = page;
Ingo Molnar341b4462006-04-11 13:57:45 +0200162 else
163 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164}
165
Jens Axboef84d7512006-05-01 19:59:03 +0200166void *generic_pipe_buf_map(struct pipe_inode_info *pipe,
Jens Axboef6762b72006-05-01 20:02:05 +0200167 struct pipe_buffer *buf, int atomic)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168{
Jens Axboef6762b72006-05-01 20:02:05 +0200169 if (atomic) {
170 buf->flags |= PIPE_BUF_FLAG_ATOMIC;
171 return kmap_atomic(buf->page, KM_USER0);
172 }
173
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 return kmap(buf->page);
175}
176
Jens Axboef84d7512006-05-01 19:59:03 +0200177void generic_pipe_buf_unmap(struct pipe_inode_info *pipe,
Jens Axboef6762b72006-05-01 20:02:05 +0200178 struct pipe_buffer *buf, void *map_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179{
Jens Axboef6762b72006-05-01 20:02:05 +0200180 if (buf->flags & PIPE_BUF_FLAG_ATOMIC) {
181 buf->flags &= ~PIPE_BUF_FLAG_ATOMIC;
182 kunmap_atomic(map_data, KM_USER0);
183 } else
184 kunmap(buf->page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185}
186
Jens Axboe330ab712006-05-02 15:29:57 +0200187int generic_pipe_buf_steal(struct pipe_inode_info *pipe,
188 struct pipe_buffer *buf)
Jens Axboe5abc97a2006-03-30 15:16:46 +0200189{
Jens Axboe46e678c2006-04-30 16:36:32 +0200190 struct page *page = buf->page;
191
192 if (page_count(page) == 1) {
Jens Axboe46e678c2006-04-30 16:36:32 +0200193 lock_page(page);
194 return 0;
195 }
196
197 return 1;
Jens Axboe5abc97a2006-03-30 15:16:46 +0200198}
199
Jens Axboef84d7512006-05-01 19:59:03 +0200200void generic_pipe_buf_get(struct pipe_inode_info *info, struct pipe_buffer *buf)
Jens Axboe70524492006-04-11 15:51:17 +0200201{
202 page_cache_get(buf->page);
203}
204
Jens Axboef84d7512006-05-01 19:59:03 +0200205int generic_pipe_buf_pin(struct pipe_inode_info *info, struct pipe_buffer *buf)
206{
207 return 0;
208}
209
Eric Dumazetd4c3cca2006-12-13 00:34:04 -0800210static const struct pipe_buf_operations anon_pipe_buf_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 .can_merge = 1,
Jens Axboef84d7512006-05-01 19:59:03 +0200212 .map = generic_pipe_buf_map,
213 .unmap = generic_pipe_buf_unmap,
214 .pin = generic_pipe_buf_pin,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 .release = anon_pipe_buf_release,
Jens Axboe330ab712006-05-02 15:29:57 +0200216 .steal = generic_pipe_buf_steal,
Jens Axboef84d7512006-05-01 19:59:03 +0200217 .get = generic_pipe_buf_get,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218};
219
220static ssize_t
Badari Pulavartyee0b3e62006-09-30 23:28:47 -0700221pipe_read(struct kiocb *iocb, const struct iovec *_iov,
222 unsigned long nr_segs, loff_t pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223{
Badari Pulavartyee0b3e62006-09-30 23:28:47 -0700224 struct file *filp = iocb->ki_filp;
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800225 struct inode *inode = filp->f_path.dentry->d_inode;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200226 struct pipe_inode_info *pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 int do_wakeup;
228 ssize_t ret;
229 struct iovec *iov = (struct iovec *)_iov;
230 size_t total_len;
231
232 total_len = iov_length(iov, nr_segs);
233 /* Null read succeeds. */
234 if (unlikely(total_len == 0))
235 return 0;
236
237 do_wakeup = 0;
238 ret = 0;
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200239 mutex_lock(&inode->i_mutex);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200240 pipe = inode->i_pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 for (;;) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200242 int bufs = pipe->nrbufs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 if (bufs) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200244 int curbuf = pipe->curbuf;
245 struct pipe_buffer *buf = pipe->bufs + curbuf;
Eric Dumazetd4c3cca2006-12-13 00:34:04 -0800246 const struct pipe_buf_operations *ops = buf->ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 void *addr;
248 size_t chars = buf->len;
Jens Axboef6762b72006-05-01 20:02:05 +0200249 int error, atomic;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
251 if (chars > total_len)
252 chars = total_len;
253
Jens Axboef84d7512006-05-01 19:59:03 +0200254 error = ops->pin(pipe, buf);
255 if (error) {
Jens Axboe5274f052006-03-30 15:15:30 +0200256 if (!ret)
Jens Axboef84d7512006-05-01 19:59:03 +0200257 error = ret;
Jens Axboe5274f052006-03-30 15:15:30 +0200258 break;
259 }
Jens Axboef84d7512006-05-01 19:59:03 +0200260
Jens Axboef6762b72006-05-01 20:02:05 +0200261 atomic = !iov_fault_in_pages_write(iov, chars);
262redo:
263 addr = ops->map(pipe, buf, atomic);
264 error = pipe_iov_copy_to_user(iov, addr + buf->offset, chars, atomic);
265 ops->unmap(pipe, buf, addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 if (unlikely(error)) {
Jens Axboef6762b72006-05-01 20:02:05 +0200267 /*
268 * Just retry with the slow path if we failed.
269 */
270 if (atomic) {
271 atomic = 0;
272 goto redo;
273 }
Ingo Molnar341b4462006-04-11 13:57:45 +0200274 if (!ret)
Jens Axboef6762b72006-05-01 20:02:05 +0200275 ret = error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 break;
277 }
278 ret += chars;
279 buf->offset += chars;
280 buf->len -= chars;
281 if (!buf->len) {
282 buf->ops = NULL;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200283 ops->release(pipe, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 curbuf = (curbuf + 1) & (PIPE_BUFFERS-1);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200285 pipe->curbuf = curbuf;
286 pipe->nrbufs = --bufs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 do_wakeup = 1;
288 }
289 total_len -= chars;
290 if (!total_len)
291 break; /* common path: read succeeded */
292 }
293 if (bufs) /* More to do? */
294 continue;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200295 if (!pipe->writers)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 break;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200297 if (!pipe->waiting_writers) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 /* syscall merging: Usually we must not sleep
299 * if O_NONBLOCK is set, or if we got some data.
300 * But if a writer sleeps in kernel space, then
301 * we can wait for that data without violating POSIX.
302 */
303 if (ret)
304 break;
305 if (filp->f_flags & O_NONBLOCK) {
306 ret = -EAGAIN;
307 break;
308 }
309 }
310 if (signal_pending(current)) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200311 if (!ret)
312 ret = -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 break;
314 }
315 if (do_wakeup) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200316 wake_up_interruptible_sync(&pipe->wait);
317 kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200319 pipe_wait(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 }
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200321 mutex_unlock(&inode->i_mutex);
Ingo Molnar341b4462006-04-11 13:57:45 +0200322
323 /* Signal writers asynchronously that there is more room. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 if (do_wakeup) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200325 wake_up_interruptible(&pipe->wait);
326 kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 }
328 if (ret > 0)
329 file_accessed(filp);
330 return ret;
331}
332
333static ssize_t
Badari Pulavartyee0b3e62006-09-30 23:28:47 -0700334pipe_write(struct kiocb *iocb, const struct iovec *_iov,
335 unsigned long nr_segs, loff_t ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336{
Badari Pulavartyee0b3e62006-09-30 23:28:47 -0700337 struct file *filp = iocb->ki_filp;
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800338 struct inode *inode = filp->f_path.dentry->d_inode;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200339 struct pipe_inode_info *pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 ssize_t ret;
341 int do_wakeup;
342 struct iovec *iov = (struct iovec *)_iov;
343 size_t total_len;
344 ssize_t chars;
345
346 total_len = iov_length(iov, nr_segs);
347 /* Null write succeeds. */
348 if (unlikely(total_len == 0))
349 return 0;
350
351 do_wakeup = 0;
352 ret = 0;
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200353 mutex_lock(&inode->i_mutex);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200354 pipe = inode->i_pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
Ingo Molnar923f4f22006-04-11 13:53:33 +0200356 if (!pipe->readers) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 send_sig(SIGPIPE, current, 0);
358 ret = -EPIPE;
359 goto out;
360 }
361
362 /* We try to merge small writes */
363 chars = total_len & (PAGE_SIZE-1); /* size of the last buffer */
Ingo Molnar923f4f22006-04-11 13:53:33 +0200364 if (pipe->nrbufs && chars != 0) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200365 int lastbuf = (pipe->curbuf + pipe->nrbufs - 1) &
366 (PIPE_BUFFERS-1);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200367 struct pipe_buffer *buf = pipe->bufs + lastbuf;
Eric Dumazetd4c3cca2006-12-13 00:34:04 -0800368 const struct pipe_buf_operations *ops = buf->ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 int offset = buf->offset + buf->len;
Ingo Molnar341b4462006-04-11 13:57:45 +0200370
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 if (ops->can_merge && offset + chars <= PAGE_SIZE) {
Jens Axboef6762b72006-05-01 20:02:05 +0200372 int error, atomic = 1;
Jens Axboe5274f052006-03-30 15:15:30 +0200373 void *addr;
Jens Axboe5274f052006-03-30 15:15:30 +0200374
Jens Axboef84d7512006-05-01 19:59:03 +0200375 error = ops->pin(pipe, buf);
376 if (error)
Jens Axboe5274f052006-03-30 15:15:30 +0200377 goto out;
Jens Axboef84d7512006-05-01 19:59:03 +0200378
Jens Axboef6762b72006-05-01 20:02:05 +0200379 iov_fault_in_pages_read(iov, chars);
380redo1:
381 addr = ops->map(pipe, buf, atomic);
Jens Axboe5274f052006-03-30 15:15:30 +0200382 error = pipe_iov_copy_from_user(offset + addr, iov,
Jens Axboef6762b72006-05-01 20:02:05 +0200383 chars, atomic);
384 ops->unmap(pipe, buf, addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 ret = error;
386 do_wakeup = 1;
Jens Axboef6762b72006-05-01 20:02:05 +0200387 if (error) {
388 if (atomic) {
389 atomic = 0;
390 goto redo1;
391 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 goto out;
Jens Axboef6762b72006-05-01 20:02:05 +0200393 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 buf->len += chars;
395 total_len -= chars;
396 ret = chars;
397 if (!total_len)
398 goto out;
399 }
400 }
401
402 for (;;) {
403 int bufs;
Ingo Molnar341b4462006-04-11 13:57:45 +0200404
Ingo Molnar923f4f22006-04-11 13:53:33 +0200405 if (!pipe->readers) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 send_sig(SIGPIPE, current, 0);
Ingo Molnar341b4462006-04-11 13:57:45 +0200407 if (!ret)
408 ret = -EPIPE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 break;
410 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200411 bufs = pipe->nrbufs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 if (bufs < PIPE_BUFFERS) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200413 int newbuf = (pipe->curbuf + bufs) & (PIPE_BUFFERS-1);
414 struct pipe_buffer *buf = pipe->bufs + newbuf;
415 struct page *page = pipe->tmp_page;
Jens Axboef6762b72006-05-01 20:02:05 +0200416 char *src;
417 int error, atomic = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
419 if (!page) {
420 page = alloc_page(GFP_HIGHUSER);
421 if (unlikely(!page)) {
422 ret = ret ? : -ENOMEM;
423 break;
424 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200425 pipe->tmp_page = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 }
Ingo Molnar341b4462006-04-11 13:57:45 +0200427 /* Always wake up, even if the copy fails. Otherwise
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 * we lock up (O_NONBLOCK-)readers that sleep due to
429 * syscall merging.
430 * FIXME! Is this really true?
431 */
432 do_wakeup = 1;
433 chars = PAGE_SIZE;
434 if (chars > total_len)
435 chars = total_len;
436
Jens Axboef6762b72006-05-01 20:02:05 +0200437 iov_fault_in_pages_read(iov, chars);
438redo2:
439 if (atomic)
440 src = kmap_atomic(page, KM_USER0);
441 else
442 src = kmap(page);
443
444 error = pipe_iov_copy_from_user(src, iov, chars,
445 atomic);
446 if (atomic)
447 kunmap_atomic(src, KM_USER0);
448 else
449 kunmap(page);
450
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 if (unlikely(error)) {
Jens Axboef6762b72006-05-01 20:02:05 +0200452 if (atomic) {
453 atomic = 0;
454 goto redo2;
455 }
Ingo Molnar341b4462006-04-11 13:57:45 +0200456 if (!ret)
Jens Axboef6762b72006-05-01 20:02:05 +0200457 ret = error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 break;
459 }
460 ret += chars;
461
462 /* Insert it into the buffer array */
463 buf->page = page;
464 buf->ops = &anon_pipe_buf_ops;
465 buf->offset = 0;
466 buf->len = chars;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200467 pipe->nrbufs = ++bufs;
468 pipe->tmp_page = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469
470 total_len -= chars;
471 if (!total_len)
472 break;
473 }
474 if (bufs < PIPE_BUFFERS)
475 continue;
476 if (filp->f_flags & O_NONBLOCK) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200477 if (!ret)
478 ret = -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 break;
480 }
481 if (signal_pending(current)) {
Ingo Molnar341b4462006-04-11 13:57:45 +0200482 if (!ret)
483 ret = -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 break;
485 }
486 if (do_wakeup) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200487 wake_up_interruptible_sync(&pipe->wait);
488 kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 do_wakeup = 0;
490 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200491 pipe->waiting_writers++;
492 pipe_wait(pipe);
493 pipe->waiting_writers--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 }
495out:
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200496 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 if (do_wakeup) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200498 wake_up_interruptible(&pipe->wait);
499 kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 }
501 if (ret > 0)
Christoph Hellwig870f4812006-01-09 20:52:01 -0800502 file_update_time(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 return ret;
504}
505
506static ssize_t
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507bad_pipe_r(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
508{
509 return -EBADF;
510}
511
512static ssize_t
Ingo Molnar341b4462006-04-11 13:57:45 +0200513bad_pipe_w(struct file *filp, const char __user *buf, size_t count,
514 loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515{
516 return -EBADF;
517}
518
519static int
520pipe_ioctl(struct inode *pino, struct file *filp,
521 unsigned int cmd, unsigned long arg)
522{
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800523 struct inode *inode = filp->f_path.dentry->d_inode;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200524 struct pipe_inode_info *pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 int count, buf, nrbufs;
526
527 switch (cmd) {
528 case FIONREAD:
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200529 mutex_lock(&inode->i_mutex);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200530 pipe = inode->i_pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 count = 0;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200532 buf = pipe->curbuf;
533 nrbufs = pipe->nrbufs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 while (--nrbufs >= 0) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200535 count += pipe->bufs[buf].len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 buf = (buf+1) & (PIPE_BUFFERS-1);
537 }
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200538 mutex_unlock(&inode->i_mutex);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200539
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 return put_user(count, (int __user *)arg);
541 default:
542 return -EINVAL;
543 }
544}
545
546/* No kernel lock held - fine */
547static unsigned int
548pipe_poll(struct file *filp, poll_table *wait)
549{
550 unsigned int mask;
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800551 struct inode *inode = filp->f_path.dentry->d_inode;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200552 struct pipe_inode_info *pipe = inode->i_pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 int nrbufs;
554
Ingo Molnar923f4f22006-04-11 13:53:33 +0200555 poll_wait(filp, &pipe->wait, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
557 /* Reading only -- no need for acquiring the semaphore. */
Ingo Molnar923f4f22006-04-11 13:53:33 +0200558 nrbufs = pipe->nrbufs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 mask = 0;
560 if (filp->f_mode & FMODE_READ) {
561 mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200562 if (!pipe->writers && filp->f_version != pipe->w_counter)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 mask |= POLLHUP;
564 }
565
566 if (filp->f_mode & FMODE_WRITE) {
567 mask |= (nrbufs < PIPE_BUFFERS) ? POLLOUT | POLLWRNORM : 0;
Pekka Enberg5e5d7a22005-09-06 15:17:48 -0700568 /*
569 * Most Unices do not set POLLERR for FIFOs but on Linux they
570 * behave exactly like pipes for poll().
571 */
Ingo Molnar923f4f22006-04-11 13:53:33 +0200572 if (!pipe->readers)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 mask |= POLLERR;
574 }
575
576 return mask;
577}
578
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579static int
580pipe_release(struct inode *inode, int decr, int decw)
581{
Ingo Molnar923f4f22006-04-11 13:53:33 +0200582 struct pipe_inode_info *pipe;
583
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200584 mutex_lock(&inode->i_mutex);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200585 pipe = inode->i_pipe;
586 pipe->readers -= decr;
587 pipe->writers -= decw;
Ingo Molnar341b4462006-04-11 13:57:45 +0200588
Ingo Molnar923f4f22006-04-11 13:53:33 +0200589 if (!pipe->readers && !pipe->writers) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 free_pipe_info(inode);
591 } else {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200592 wake_up_interruptible(&pipe->wait);
593 kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
594 kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 }
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200596 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
598 return 0;
599}
600
601static int
602pipe_read_fasync(int fd, struct file *filp, int on)
603{
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800604 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 int retval;
606
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200607 mutex_lock(&inode->i_mutex);
608 retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_readers);
609 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
611 if (retval < 0)
612 return retval;
613
614 return 0;
615}
616
617
618static int
619pipe_write_fasync(int fd, struct file *filp, int on)
620{
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800621 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 int retval;
623
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200624 mutex_lock(&inode->i_mutex);
625 retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_writers);
626 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
628 if (retval < 0)
629 return retval;
630
631 return 0;
632}
633
634
635static int
636pipe_rdwr_fasync(int fd, struct file *filp, int on)
637{
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800638 struct inode *inode = filp->f_path.dentry->d_inode;
Ingo Molnar341b4462006-04-11 13:57:45 +0200639 struct pipe_inode_info *pipe = inode->i_pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 int retval;
641
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200642 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
Ingo Molnar341b4462006-04-11 13:57:45 +0200644 retval = fasync_helper(fd, filp, on, &pipe->fasync_readers);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
646 if (retval >= 0)
Ingo Molnar341b4462006-04-11 13:57:45 +0200647 retval = fasync_helper(fd, filp, on, &pipe->fasync_writers);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200649 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
651 if (retval < 0)
652 return retval;
653
654 return 0;
655}
656
657
658static int
659pipe_read_release(struct inode *inode, struct file *filp)
660{
661 pipe_read_fasync(-1, filp, 0);
662 return pipe_release(inode, 1, 0);
663}
664
665static int
666pipe_write_release(struct inode *inode, struct file *filp)
667{
668 pipe_write_fasync(-1, filp, 0);
669 return pipe_release(inode, 0, 1);
670}
671
672static int
673pipe_rdwr_release(struct inode *inode, struct file *filp)
674{
675 int decr, decw;
676
677 pipe_rdwr_fasync(-1, filp, 0);
678 decr = (filp->f_mode & FMODE_READ) != 0;
679 decw = (filp->f_mode & FMODE_WRITE) != 0;
680 return pipe_release(inode, decr, decw);
681}
682
683static int
684pipe_read_open(struct inode *inode, struct file *filp)
685{
686 /* We could have perhaps used atomic_t, but this and friends
687 below are the only places. So it doesn't seem worthwhile. */
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200688 mutex_lock(&inode->i_mutex);
689 inode->i_pipe->readers++;
690 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
692 return 0;
693}
694
695static int
696pipe_write_open(struct inode *inode, struct file *filp)
697{
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200698 mutex_lock(&inode->i_mutex);
699 inode->i_pipe->writers++;
700 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
702 return 0;
703}
704
705static int
706pipe_rdwr_open(struct inode *inode, struct file *filp)
707{
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200708 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 if (filp->f_mode & FMODE_READ)
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200710 inode->i_pipe->readers++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 if (filp->f_mode & FMODE_WRITE)
Ingo Molnar9aeedfc2006-04-11 13:53:10 +0200712 inode->i_pipe->writers++;
713 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
715 return 0;
716}
717
718/*
719 * The file_operations structs are not static because they
720 * are also used in linux/fs/fifo.c to do operations on FIFOs.
721 */
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800722const struct file_operations read_fifo_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 .llseek = no_llseek,
Badari Pulavartyee0b3e62006-09-30 23:28:47 -0700724 .read = do_sync_read,
725 .aio_read = pipe_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 .write = bad_pipe_w,
Pekka Enberg5e5d7a22005-09-06 15:17:48 -0700727 .poll = pipe_poll,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 .ioctl = pipe_ioctl,
729 .open = pipe_read_open,
730 .release = pipe_read_release,
731 .fasync = pipe_read_fasync,
732};
733
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800734const struct file_operations write_fifo_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 .llseek = no_llseek,
736 .read = bad_pipe_r,
Badari Pulavartyee0b3e62006-09-30 23:28:47 -0700737 .write = do_sync_write,
738 .aio_write = pipe_write,
Pekka Enberg5e5d7a22005-09-06 15:17:48 -0700739 .poll = pipe_poll,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 .ioctl = pipe_ioctl,
741 .open = pipe_write_open,
742 .release = pipe_write_release,
743 .fasync = pipe_write_fasync,
744};
745
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800746const struct file_operations rdwr_fifo_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 .llseek = no_llseek,
Badari Pulavartyee0b3e62006-09-30 23:28:47 -0700748 .read = do_sync_read,
749 .aio_read = pipe_read,
750 .write = do_sync_write,
751 .aio_write = pipe_write,
Pekka Enberg5e5d7a22005-09-06 15:17:48 -0700752 .poll = pipe_poll,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 .ioctl = pipe_ioctl,
754 .open = pipe_rdwr_open,
755 .release = pipe_rdwr_release,
756 .fasync = pipe_rdwr_fasync,
757};
758
Eric Dumazetd4c3cca2006-12-13 00:34:04 -0800759static const struct file_operations read_pipe_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 .llseek = no_llseek,
Badari Pulavartyee0b3e62006-09-30 23:28:47 -0700761 .read = do_sync_read,
762 .aio_read = pipe_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 .write = bad_pipe_w,
764 .poll = pipe_poll,
765 .ioctl = pipe_ioctl,
766 .open = pipe_read_open,
767 .release = pipe_read_release,
768 .fasync = pipe_read_fasync,
769};
770
Eric Dumazetd4c3cca2006-12-13 00:34:04 -0800771static const struct file_operations write_pipe_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 .llseek = no_llseek,
773 .read = bad_pipe_r,
Badari Pulavartyee0b3e62006-09-30 23:28:47 -0700774 .write = do_sync_write,
775 .aio_write = pipe_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 .poll = pipe_poll,
777 .ioctl = pipe_ioctl,
778 .open = pipe_write_open,
779 .release = pipe_write_release,
780 .fasync = pipe_write_fasync,
781};
782
Eric Dumazetd4c3cca2006-12-13 00:34:04 -0800783static const struct file_operations rdwr_pipe_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 .llseek = no_llseek,
Badari Pulavartyee0b3e62006-09-30 23:28:47 -0700785 .read = do_sync_read,
786 .aio_read = pipe_read,
787 .write = do_sync_write,
788 .aio_write = pipe_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 .poll = pipe_poll,
790 .ioctl = pipe_ioctl,
791 .open = pipe_rdwr_open,
792 .release = pipe_rdwr_release,
793 .fasync = pipe_rdwr_fasync,
794};
795
Ingo Molnar3a326a22006-04-10 15:18:35 +0200796struct pipe_inode_info * alloc_pipe_info(struct inode *inode)
797{
Ingo Molnar923f4f22006-04-11 13:53:33 +0200798 struct pipe_inode_info *pipe;
Ingo Molnar3a326a22006-04-10 15:18:35 +0200799
Ingo Molnar923f4f22006-04-11 13:53:33 +0200800 pipe = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
801 if (pipe) {
802 init_waitqueue_head(&pipe->wait);
803 pipe->r_counter = pipe->w_counter = 1;
804 pipe->inode = inode;
Ingo Molnar3a326a22006-04-10 15:18:35 +0200805 }
806
Ingo Molnar923f4f22006-04-11 13:53:33 +0200807 return pipe;
Ingo Molnar3a326a22006-04-10 15:18:35 +0200808}
809
Ingo Molnar923f4f22006-04-11 13:53:33 +0200810void __free_pipe_info(struct pipe_inode_info *pipe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811{
812 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 for (i = 0; i < PIPE_BUFFERS; i++) {
Ingo Molnar923f4f22006-04-11 13:53:33 +0200815 struct pipe_buffer *buf = pipe->bufs + i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 if (buf->ops)
Ingo Molnar923f4f22006-04-11 13:53:33 +0200817 buf->ops->release(pipe, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 }
Ingo Molnar923f4f22006-04-11 13:53:33 +0200819 if (pipe->tmp_page)
820 __free_page(pipe->tmp_page);
821 kfree(pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822}
823
Jens Axboeb92ce552006-04-11 13:52:07 +0200824void free_pipe_info(struct inode *inode)
825{
826 __free_pipe_info(inode->i_pipe);
827 inode->i_pipe = NULL;
828}
829
Eric Dumazetfa3536c2006-03-26 01:37:24 -0800830static struct vfsmount *pipe_mnt __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831static int pipefs_delete_dentry(struct dentry *dentry)
832{
Eric Dumazetd18de5a2006-12-06 20:38:45 -0800833 /*
834 * At creation time, we pretended this dentry was hashed
835 * (by clearing DCACHE_UNHASHED bit in d_flags)
836 * At delete time, we restore the truth : not hashed.
837 * (so that dput() can proceed correctly)
838 */
839 dentry->d_flags |= DCACHE_UNHASHED;
840 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841}
Ingo Molnar341b4462006-04-11 13:57:45 +0200842
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843static struct dentry_operations pipefs_dentry_operations = {
844 .d_delete = pipefs_delete_dentry,
845};
846
847static struct inode * get_pipe_inode(void)
848{
849 struct inode *inode = new_inode(pipe_mnt->mnt_sb);
Ingo Molnar923f4f22006-04-11 13:53:33 +0200850 struct pipe_inode_info *pipe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851
852 if (!inode)
853 goto fail_inode;
854
Ingo Molnar923f4f22006-04-11 13:53:33 +0200855 pipe = alloc_pipe_info(inode);
856 if (!pipe)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 goto fail_iput;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200858 inode->i_pipe = pipe;
Ingo Molnar3a326a22006-04-10 15:18:35 +0200859
Ingo Molnar923f4f22006-04-11 13:53:33 +0200860 pipe->readers = pipe->writers = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 inode->i_fop = &rdwr_pipe_fops;
862
863 /*
864 * Mark the inode dirty from the very beginning,
865 * that way it will never be moved to the dirty
866 * list because "mark_inode_dirty()" will think
867 * that it already _is_ on the dirty list.
868 */
869 inode->i_state = I_DIRTY;
870 inode->i_mode = S_IFIFO | S_IRUSR | S_IWUSR;
871 inode->i_uid = current->fsuid;
872 inode->i_gid = current->fsgid;
873 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
Ingo Molnar923f4f22006-04-11 13:53:33 +0200874
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 return inode;
876
877fail_iput:
878 iput(inode);
Ingo Molnar341b4462006-04-11 13:57:45 +0200879
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880fail_inode:
881 return NULL;
882}
883
Andi Kleend6cbd282006-09-30 23:29:26 -0700884struct file *create_write_pipe(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885{
Andi Kleend6cbd282006-09-30 23:29:26 -0700886 int err;
887 struct inode *inode;
888 struct file *f;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 struct dentry *dentry;
Andi Kleend6cbd282006-09-30 23:29:26 -0700890 char name[32];
891 struct qstr this;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892
Andi Kleend6cbd282006-09-30 23:29:26 -0700893 f = get_empty_filp();
894 if (!f)
895 return ERR_PTR(-ENFILE);
896 err = -ENFILE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 inode = get_pipe_inode();
898 if (!inode)
Andi Kleend6cbd282006-09-30 23:29:26 -0700899 goto err_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900
Eric Dumazetd18de5a2006-12-06 20:38:45 -0800901 this.len = sprintf(name, "[%lu]", inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 this.name = name;
Eric Dumazetd18de5a2006-12-06 20:38:45 -0800903 this.hash = 0;
Andi Kleend6cbd282006-09-30 23:29:26 -0700904 err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 dentry = d_alloc(pipe_mnt->mnt_sb->s_root, &this);
906 if (!dentry)
Andi Kleend6cbd282006-09-30 23:29:26 -0700907 goto err_inode;
Ingo Molnar341b4462006-04-11 13:57:45 +0200908
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 dentry->d_op = &pipefs_dentry_operations;
Eric Dumazetd18de5a2006-12-06 20:38:45 -0800910 /*
911 * We dont want to publish this dentry into global dentry hash table.
912 * We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED
913 * This permits a working /proc/$pid/fd/XXX on pipes
914 */
915 dentry->d_flags &= ~DCACHE_UNHASHED;
916 d_instantiate(dentry, inode);
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800917 f->f_path.mnt = mntget(pipe_mnt);
918 f->f_path.dentry = dentry;
Andi Kleend6cbd282006-09-30 23:29:26 -0700919 f->f_mapping = inode->i_mapping;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920
Andi Kleend6cbd282006-09-30 23:29:26 -0700921 f->f_flags = O_WRONLY;
922 f->f_op = &write_pipe_fops;
923 f->f_mode = FMODE_WRITE;
924 f->f_version = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
Andi Kleend6cbd282006-09-30 23:29:26 -0700926 return f;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927
Andi Kleend6cbd282006-09-30 23:29:26 -0700928 err_inode:
929 free_pipe_info(inode);
930 iput(inode);
931 err_file:
932 put_filp(f);
933 return ERR_PTR(err);
934}
935
936void free_write_pipe(struct file *f)
937{
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800938 mntput(f->f_path.mnt);
939 dput(f->f_path.dentry);
Andi Kleend6cbd282006-09-30 23:29:26 -0700940 put_filp(f);
941}
942
943struct file *create_read_pipe(struct file *wrf)
944{
945 struct file *f = get_empty_filp();
946 if (!f)
947 return ERR_PTR(-ENFILE);
948
949 /* Grab pipe from the writer */
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800950 f->f_path.mnt = mntget(wrf->f_path.mnt);
951 f->f_path.dentry = dget(wrf->f_path.dentry);
952 f->f_mapping = wrf->f_path.dentry->d_inode->i_mapping;
Andi Kleend6cbd282006-09-30 23:29:26 -0700953
954 f->f_pos = 0;
955 f->f_flags = O_RDONLY;
956 f->f_op = &read_pipe_fops;
957 f->f_mode = FMODE_READ;
958 f->f_version = 0;
959
960 return f;
961}
962
963int do_pipe(int *fd)
964{
965 struct file *fw, *fr;
966 int error;
967 int fdw, fdr;
968
969 fw = create_write_pipe();
970 if (IS_ERR(fw))
971 return PTR_ERR(fw);
972 fr = create_read_pipe(fw);
973 error = PTR_ERR(fr);
974 if (IS_ERR(fr))
975 goto err_write_pipe;
976
977 error = get_unused_fd();
978 if (error < 0)
979 goto err_read_pipe;
980 fdr = error;
981
982 error = get_unused_fd();
983 if (error < 0)
984 goto err_fdr;
985 fdw = error;
986
987 fd_install(fdr, fr);
988 fd_install(fdw, fw);
989 fd[0] = fdr;
990 fd[1] = fdw;
Ingo Molnar341b4462006-04-11 13:57:45 +0200991
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 return 0;
993
Andi Kleend6cbd282006-09-30 23:29:26 -0700994 err_fdr:
995 put_unused_fd(fdr);
996 err_read_pipe:
997 put_filp(fr);
998 err_write_pipe:
999 free_write_pipe(fw);
1000 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001}
1002
1003/*
1004 * pipefs should _never_ be mounted by userland - too much of security hassle,
1005 * no real gain from having the whole whorehouse mounted. So we don't need
1006 * any operations on the root directory. However, we need a non-trivial
1007 * d_name - pipe: will go nicely and kill the special-casing in procfs.
1008 */
David Howells454e2392006-06-23 02:02:57 -07001009static int pipefs_get_sb(struct file_system_type *fs_type,
1010 int flags, const char *dev_name, void *data,
1011 struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012{
David Howells454e2392006-06-23 02:02:57 -07001013 return get_sb_pseudo(fs_type, "pipe:", NULL, PIPEFS_MAGIC, mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014}
1015
1016static struct file_system_type pipe_fs_type = {
1017 .name = "pipefs",
1018 .get_sb = pipefs_get_sb,
1019 .kill_sb = kill_anon_super,
1020};
1021
1022static int __init init_pipe_fs(void)
1023{
1024 int err = register_filesystem(&pipe_fs_type);
Ingo Molnar341b4462006-04-11 13:57:45 +02001025
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 if (!err) {
1027 pipe_mnt = kern_mount(&pipe_fs_type);
1028 if (IS_ERR(pipe_mnt)) {
1029 err = PTR_ERR(pipe_mnt);
1030 unregister_filesystem(&pipe_fs_type);
1031 }
1032 }
1033 return err;
1034}
1035
1036static void __exit exit_pipe_fs(void)
1037{
1038 unregister_filesystem(&pipe_fs_type);
1039 mntput(pipe_mnt);
1040}
1041
1042fs_initcall(init_pipe_fs);
1043module_exit(exit_pipe_fs);