[PATCH] splice: fix page stealing LRU handling.
[linux-2.6.git] / fs / pipe.c
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/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
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 */
39 void pipe_wait(struct inode * inode)
40 {
41         DEFINE_WAIT(wait);
42
43         /*
44          * Pipes are system-local resources, so sleeping on them
45          * is considered a noninteractive wait:
46          */
47         prepare_to_wait(PIPE_WAIT(*inode), &wait, TASK_INTERRUPTIBLE|TASK_NONINTERACTIVE);
48         mutex_unlock(PIPE_MUTEX(*inode));
49         schedule();
50         finish_wait(PIPE_WAIT(*inode), &wait);
51         mutex_lock(PIPE_MUTEX(*inode));
52 }
53
54 static int
55 pipe_iov_copy_from_user(void *to, struct iovec *iov, unsigned long len)
56 {
57         unsigned long copy;
58
59         while (len > 0) {
60                 while (!iov->iov_len)
61                         iov++;
62                 copy = min_t(unsigned long, len, iov->iov_len);
63
64                 if (copy_from_user(to, iov->iov_base, copy))
65                         return -EFAULT;
66                 to += copy;
67                 len -= copy;
68                 iov->iov_base += copy;
69                 iov->iov_len -= copy;
70         }
71         return 0;
72 }
73
74 static int
75 pipe_iov_copy_to_user(struct iovec *iov, const void *from, unsigned long len)
76 {
77         unsigned long copy;
78
79         while (len > 0) {
80                 while (!iov->iov_len)
81                         iov++;
82                 copy = min_t(unsigned long, len, iov->iov_len);
83
84                 if (copy_to_user(iov->iov_base, from, copy))
85                         return -EFAULT;
86                 from += copy;
87                 len -= copy;
88                 iov->iov_base += copy;
89                 iov->iov_len -= copy;
90         }
91         return 0;
92 }
93
94 static void anon_pipe_buf_release(struct pipe_inode_info *info, struct pipe_buffer *buf)
95 {
96         struct page *page = buf->page;
97
98         buf->flags &= ~PIPE_BUF_FLAG_STOLEN;
99
100         /*
101          * If nobody else uses this page, and we don't already have a
102          * temporary page, let's keep track of it as a one-deep
103          * allocation cache
104          */
105         if (page_count(page) == 1 && !info->tmp_page) {
106                 info->tmp_page = page;
107                 return;
108         }
109
110         /*
111          * Otherwise just release our reference to it
112          */
113         page_cache_release(page);
114 }
115
116 static void *anon_pipe_buf_map(struct file *file, struct pipe_inode_info *info, struct pipe_buffer *buf)
117 {
118         return kmap(buf->page);
119 }
120
121 static void anon_pipe_buf_unmap(struct pipe_inode_info *info, struct pipe_buffer *buf)
122 {
123         kunmap(buf->page);
124 }
125
126 static int anon_pipe_buf_steal(struct pipe_inode_info *info,
127                                struct pipe_buffer *buf)
128 {
129         buf->flags |= PIPE_BUF_FLAG_STOLEN;
130         return 0;
131 }
132
133 static struct pipe_buf_operations anon_pipe_buf_ops = {
134         .can_merge = 1,
135         .map = anon_pipe_buf_map,
136         .unmap = anon_pipe_buf_unmap,
137         .release = anon_pipe_buf_release,
138         .steal = anon_pipe_buf_steal,
139 };
140
141 static ssize_t
142 pipe_readv(struct file *filp, const struct iovec *_iov,
143            unsigned long nr_segs, loff_t *ppos)
144 {
145         struct inode *inode = filp->f_dentry->d_inode;
146         struct pipe_inode_info *info;
147         int do_wakeup;
148         ssize_t ret;
149         struct iovec *iov = (struct iovec *)_iov;
150         size_t total_len;
151
152         total_len = iov_length(iov, nr_segs);
153         /* Null read succeeds. */
154         if (unlikely(total_len == 0))
155                 return 0;
156
157         do_wakeup = 0;
158         ret = 0;
159         mutex_lock(PIPE_MUTEX(*inode));
160         info = inode->i_pipe;
161         for (;;) {
162                 int bufs = info->nrbufs;
163                 if (bufs) {
164                         int curbuf = info->curbuf;
165                         struct pipe_buffer *buf = info->bufs + curbuf;
166                         struct pipe_buf_operations *ops = buf->ops;
167                         void *addr;
168                         size_t chars = buf->len;
169                         int error;
170
171                         if (chars > total_len)
172                                 chars = total_len;
173
174                         addr = ops->map(filp, info, buf);
175                         if (IS_ERR(addr)) {
176                                 if (!ret)
177                                         ret = PTR_ERR(addr);
178                                 break;
179                         }
180                         error = pipe_iov_copy_to_user(iov, addr + buf->offset, chars);
181                         ops->unmap(info, buf);
182                         if (unlikely(error)) {
183                                 if (!ret) ret = -EFAULT;
184                                 break;
185                         }
186                         ret += chars;
187                         buf->offset += chars;
188                         buf->len -= chars;
189                         if (!buf->len) {
190                                 buf->ops = NULL;
191                                 ops->release(info, buf);
192                                 curbuf = (curbuf + 1) & (PIPE_BUFFERS-1);
193                                 info->curbuf = curbuf;
194                                 info->nrbufs = --bufs;
195                                 do_wakeup = 1;
196                         }
197                         total_len -= chars;
198                         if (!total_len)
199                                 break;  /* common path: read succeeded */
200                 }
201                 if (bufs)       /* More to do? */
202                         continue;
203                 if (!PIPE_WRITERS(*inode))
204                         break;
205                 if (!PIPE_WAITING_WRITERS(*inode)) {
206                         /* syscall merging: Usually we must not sleep
207                          * if O_NONBLOCK is set, or if we got some data.
208                          * But if a writer sleeps in kernel space, then
209                          * we can wait for that data without violating POSIX.
210                          */
211                         if (ret)
212                                 break;
213                         if (filp->f_flags & O_NONBLOCK) {
214                                 ret = -EAGAIN;
215                                 break;
216                         }
217                 }
218                 if (signal_pending(current)) {
219                         if (!ret) ret = -ERESTARTSYS;
220                         break;
221                 }
222                 if (do_wakeup) {
223                         wake_up_interruptible_sync(PIPE_WAIT(*inode));
224                         kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);
225                 }
226                 pipe_wait(inode);
227         }
228         mutex_unlock(PIPE_MUTEX(*inode));
229         /* Signal writers asynchronously that there is more room.  */
230         if (do_wakeup) {
231                 wake_up_interruptible(PIPE_WAIT(*inode));
232                 kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);
233         }
234         if (ret > 0)
235                 file_accessed(filp);
236         return ret;
237 }
238
239 static ssize_t
240 pipe_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
241 {
242         struct iovec iov = { .iov_base = buf, .iov_len = count };
243         return pipe_readv(filp, &iov, 1, ppos);
244 }
245
246 static ssize_t
247 pipe_writev(struct file *filp, const struct iovec *_iov,
248             unsigned long nr_segs, loff_t *ppos)
249 {
250         struct inode *inode = filp->f_dentry->d_inode;
251         struct pipe_inode_info *info;
252         ssize_t ret;
253         int do_wakeup;
254         struct iovec *iov = (struct iovec *)_iov;
255         size_t total_len;
256         ssize_t chars;
257
258         total_len = iov_length(iov, nr_segs);
259         /* Null write succeeds. */
260         if (unlikely(total_len == 0))
261                 return 0;
262
263         do_wakeup = 0;
264         ret = 0;
265         mutex_lock(PIPE_MUTEX(*inode));
266         info = inode->i_pipe;
267
268         if (!PIPE_READERS(*inode)) {
269                 send_sig(SIGPIPE, current, 0);
270                 ret = -EPIPE;
271                 goto out;
272         }
273
274         /* We try to merge small writes */
275         chars = total_len & (PAGE_SIZE-1); /* size of the last buffer */
276         if (info->nrbufs && chars != 0) {
277                 int lastbuf = (info->curbuf + info->nrbufs - 1) & (PIPE_BUFFERS-1);
278                 struct pipe_buffer *buf = info->bufs + lastbuf;
279                 struct pipe_buf_operations *ops = buf->ops;
280                 int offset = buf->offset + buf->len;
281                 if (ops->can_merge && offset + chars <= PAGE_SIZE) {
282                         void *addr;
283                         int error;
284
285                         addr = ops->map(filp, info, buf);
286                         if (IS_ERR(addr)) {
287                                 error = PTR_ERR(addr);
288                                 goto out;
289                         }
290                         error = pipe_iov_copy_from_user(offset + addr, iov,
291                                                         chars);
292                         ops->unmap(info, buf);
293                         ret = error;
294                         do_wakeup = 1;
295                         if (error)
296                                 goto out;
297                         buf->len += chars;
298                         total_len -= chars;
299                         ret = chars;
300                         if (!total_len)
301                                 goto out;
302                 }
303         }
304
305         for (;;) {
306                 int bufs;
307                 if (!PIPE_READERS(*inode)) {
308                         send_sig(SIGPIPE, current, 0);
309                         if (!ret) ret = -EPIPE;
310                         break;
311                 }
312                 bufs = info->nrbufs;
313                 if (bufs < PIPE_BUFFERS) {
314                         int newbuf = (info->curbuf + bufs) & (PIPE_BUFFERS-1);
315                         struct pipe_buffer *buf = info->bufs + newbuf;
316                         struct page *page = info->tmp_page;
317                         int error;
318
319                         if (!page) {
320                                 page = alloc_page(GFP_HIGHUSER);
321                                 if (unlikely(!page)) {
322                                         ret = ret ? : -ENOMEM;
323                                         break;
324                                 }
325                                 info->tmp_page = page;
326                         }
327                         /* Always wakeup, even if the copy fails. Otherwise
328                          * we lock up (O_NONBLOCK-)readers that sleep due to
329                          * syscall merging.
330                          * FIXME! Is this really true?
331                          */
332                         do_wakeup = 1;
333                         chars = PAGE_SIZE;
334                         if (chars > total_len)
335                                 chars = total_len;
336
337                         error = pipe_iov_copy_from_user(kmap(page), iov, chars);
338                         kunmap(page);
339                         if (unlikely(error)) {
340                                 if (!ret) ret = -EFAULT;
341                                 break;
342                         }
343                         ret += chars;
344
345                         /* Insert it into the buffer array */
346                         buf->page = page;
347                         buf->ops = &anon_pipe_buf_ops;
348                         buf->offset = 0;
349                         buf->len = chars;
350                         info->nrbufs = ++bufs;
351                         info->tmp_page = NULL;
352
353                         total_len -= chars;
354                         if (!total_len)
355                                 break;
356                 }
357                 if (bufs < PIPE_BUFFERS)
358                         continue;
359                 if (filp->f_flags & O_NONBLOCK) {
360                         if (!ret) ret = -EAGAIN;
361                         break;
362                 }
363                 if (signal_pending(current)) {
364                         if (!ret) ret = -ERESTARTSYS;
365                         break;
366                 }
367                 if (do_wakeup) {
368                         wake_up_interruptible_sync(PIPE_WAIT(*inode));
369                         kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN);
370                         do_wakeup = 0;
371                 }
372                 PIPE_WAITING_WRITERS(*inode)++;
373                 pipe_wait(inode);
374                 PIPE_WAITING_WRITERS(*inode)--;
375         }
376 out:
377         mutex_unlock(PIPE_MUTEX(*inode));
378         if (do_wakeup) {
379                 wake_up_interruptible(PIPE_WAIT(*inode));
380                 kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN);
381         }
382         if (ret > 0)
383                 file_update_time(filp);
384         return ret;
385 }
386
387 static ssize_t
388 pipe_write(struct file *filp, const char __user *buf,
389            size_t count, loff_t *ppos)
390 {
391         struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = count };
392         return pipe_writev(filp, &iov, 1, ppos);
393 }
394
395 static ssize_t
396 bad_pipe_r(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
397 {
398         return -EBADF;
399 }
400
401 static ssize_t
402 bad_pipe_w(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
403 {
404         return -EBADF;
405 }
406
407 static int
408 pipe_ioctl(struct inode *pino, struct file *filp,
409            unsigned int cmd, unsigned long arg)
410 {
411         struct inode *inode = filp->f_dentry->d_inode;
412         struct pipe_inode_info *info;
413         int count, buf, nrbufs;
414
415         switch (cmd) {
416                 case FIONREAD:
417                         mutex_lock(PIPE_MUTEX(*inode));
418                         info =  inode->i_pipe;
419                         count = 0;
420                         buf = info->curbuf;
421                         nrbufs = info->nrbufs;
422                         while (--nrbufs >= 0) {
423                                 count += info->bufs[buf].len;
424                                 buf = (buf+1) & (PIPE_BUFFERS-1);
425                         }
426                         mutex_unlock(PIPE_MUTEX(*inode));
427                         return put_user(count, (int __user *)arg);
428                 default:
429                         return -EINVAL;
430         }
431 }
432
433 /* No kernel lock held - fine */
434 static unsigned int
435 pipe_poll(struct file *filp, poll_table *wait)
436 {
437         unsigned int mask;
438         struct inode *inode = filp->f_dentry->d_inode;
439         struct pipe_inode_info *info = inode->i_pipe;
440         int nrbufs;
441
442         poll_wait(filp, PIPE_WAIT(*inode), wait);
443
444         /* Reading only -- no need for acquiring the semaphore.  */
445         nrbufs = info->nrbufs;
446         mask = 0;
447         if (filp->f_mode & FMODE_READ) {
448                 mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0;
449                 if (!PIPE_WRITERS(*inode) && filp->f_version != PIPE_WCOUNTER(*inode))
450                         mask |= POLLHUP;
451         }
452
453         if (filp->f_mode & FMODE_WRITE) {
454                 mask |= (nrbufs < PIPE_BUFFERS) ? POLLOUT | POLLWRNORM : 0;
455                 /*
456                  * Most Unices do not set POLLERR for FIFOs but on Linux they
457                  * behave exactly like pipes for poll().
458                  */
459                 if (!PIPE_READERS(*inode))
460                         mask |= POLLERR;
461         }
462
463         return mask;
464 }
465
466 static int
467 pipe_release(struct inode *inode, int decr, int decw)
468 {
469         mutex_lock(PIPE_MUTEX(*inode));
470         PIPE_READERS(*inode) -= decr;
471         PIPE_WRITERS(*inode) -= decw;
472         if (!PIPE_READERS(*inode) && !PIPE_WRITERS(*inode)) {
473                 free_pipe_info(inode);
474         } else {
475                 wake_up_interruptible(PIPE_WAIT(*inode));
476                 kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN);
477                 kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);
478         }
479         mutex_unlock(PIPE_MUTEX(*inode));
480
481         return 0;
482 }
483
484 static int
485 pipe_read_fasync(int fd, struct file *filp, int on)
486 {
487         struct inode *inode = filp->f_dentry->d_inode;
488         int retval;
489
490         mutex_lock(PIPE_MUTEX(*inode));
491         retval = fasync_helper(fd, filp, on, PIPE_FASYNC_READERS(*inode));
492         mutex_unlock(PIPE_MUTEX(*inode));
493
494         if (retval < 0)
495                 return retval;
496
497         return 0;
498 }
499
500
501 static int
502 pipe_write_fasync(int fd, struct file *filp, int on)
503 {
504         struct inode *inode = filp->f_dentry->d_inode;
505         int retval;
506
507         mutex_lock(PIPE_MUTEX(*inode));
508         retval = fasync_helper(fd, filp, on, PIPE_FASYNC_WRITERS(*inode));
509         mutex_unlock(PIPE_MUTEX(*inode));
510
511         if (retval < 0)
512                 return retval;
513
514         return 0;
515 }
516
517
518 static int
519 pipe_rdwr_fasync(int fd, struct file *filp, int on)
520 {
521         struct inode *inode = filp->f_dentry->d_inode;
522         int retval;
523
524         mutex_lock(PIPE_MUTEX(*inode));
525
526         retval = fasync_helper(fd, filp, on, PIPE_FASYNC_READERS(*inode));
527
528         if (retval >= 0)
529                 retval = fasync_helper(fd, filp, on, PIPE_FASYNC_WRITERS(*inode));
530
531         mutex_unlock(PIPE_MUTEX(*inode));
532
533         if (retval < 0)
534                 return retval;
535
536         return 0;
537 }
538
539
540 static int
541 pipe_read_release(struct inode *inode, struct file *filp)
542 {
543         pipe_read_fasync(-1, filp, 0);
544         return pipe_release(inode, 1, 0);
545 }
546
547 static int
548 pipe_write_release(struct inode *inode, struct file *filp)
549 {
550         pipe_write_fasync(-1, filp, 0);
551         return pipe_release(inode, 0, 1);
552 }
553
554 static int
555 pipe_rdwr_release(struct inode *inode, struct file *filp)
556 {
557         int decr, decw;
558
559         pipe_rdwr_fasync(-1, filp, 0);
560         decr = (filp->f_mode & FMODE_READ) != 0;
561         decw = (filp->f_mode & FMODE_WRITE) != 0;
562         return pipe_release(inode, decr, decw);
563 }
564
565 static int
566 pipe_read_open(struct inode *inode, struct file *filp)
567 {
568         /* We could have perhaps used atomic_t, but this and friends
569            below are the only places.  So it doesn't seem worthwhile.  */
570         mutex_lock(PIPE_MUTEX(*inode));
571         PIPE_READERS(*inode)++;
572         mutex_unlock(PIPE_MUTEX(*inode));
573
574         return 0;
575 }
576
577 static int
578 pipe_write_open(struct inode *inode, struct file *filp)
579 {
580         mutex_lock(PIPE_MUTEX(*inode));
581         PIPE_WRITERS(*inode)++;
582         mutex_unlock(PIPE_MUTEX(*inode));
583
584         return 0;
585 }
586
587 static int
588 pipe_rdwr_open(struct inode *inode, struct file *filp)
589 {
590         mutex_lock(PIPE_MUTEX(*inode));
591         if (filp->f_mode & FMODE_READ)
592                 PIPE_READERS(*inode)++;
593         if (filp->f_mode & FMODE_WRITE)
594                 PIPE_WRITERS(*inode)++;
595         mutex_unlock(PIPE_MUTEX(*inode));
596
597         return 0;
598 }
599
600 /*
601  * The file_operations structs are not static because they
602  * are also used in linux/fs/fifo.c to do operations on FIFOs.
603  */
604 const struct file_operations read_fifo_fops = {
605         .llseek         = no_llseek,
606         .read           = pipe_read,
607         .readv          = pipe_readv,
608         .write          = bad_pipe_w,
609         .poll           = pipe_poll,
610         .ioctl          = pipe_ioctl,
611         .open           = pipe_read_open,
612         .release        = pipe_read_release,
613         .fasync         = pipe_read_fasync,
614 };
615
616 const struct file_operations write_fifo_fops = {
617         .llseek         = no_llseek,
618         .read           = bad_pipe_r,
619         .write          = pipe_write,
620         .writev         = pipe_writev,
621         .poll           = pipe_poll,
622         .ioctl          = pipe_ioctl,
623         .open           = pipe_write_open,
624         .release        = pipe_write_release,
625         .fasync         = pipe_write_fasync,
626 };
627
628 const struct file_operations rdwr_fifo_fops = {
629         .llseek         = no_llseek,
630         .read           = pipe_read,
631         .readv          = pipe_readv,
632         .write          = pipe_write,
633         .writev         = pipe_writev,
634         .poll           = pipe_poll,
635         .ioctl          = pipe_ioctl,
636         .open           = pipe_rdwr_open,
637         .release        = pipe_rdwr_release,
638         .fasync         = pipe_rdwr_fasync,
639 };
640
641 static struct file_operations read_pipe_fops = {
642         .llseek         = no_llseek,
643         .read           = pipe_read,
644         .readv          = pipe_readv,
645         .write          = bad_pipe_w,
646         .poll           = pipe_poll,
647         .ioctl          = pipe_ioctl,
648         .open           = pipe_read_open,
649         .release        = pipe_read_release,
650         .fasync         = pipe_read_fasync,
651 };
652
653 static struct file_operations write_pipe_fops = {
654         .llseek         = no_llseek,
655         .read           = bad_pipe_r,
656         .write          = pipe_write,
657         .writev         = pipe_writev,
658         .poll           = pipe_poll,
659         .ioctl          = pipe_ioctl,
660         .open           = pipe_write_open,
661         .release        = pipe_write_release,
662         .fasync         = pipe_write_fasync,
663 };
664
665 static struct file_operations rdwr_pipe_fops = {
666         .llseek         = no_llseek,
667         .read           = pipe_read,
668         .readv          = pipe_readv,
669         .write          = pipe_write,
670         .writev         = pipe_writev,
671         .poll           = pipe_poll,
672         .ioctl          = pipe_ioctl,
673         .open           = pipe_rdwr_open,
674         .release        = pipe_rdwr_release,
675         .fasync         = pipe_rdwr_fasync,
676 };
677
678 void free_pipe_info(struct inode *inode)
679 {
680         int i;
681         struct pipe_inode_info *info = inode->i_pipe;
682
683         inode->i_pipe = NULL;
684         for (i = 0; i < PIPE_BUFFERS; i++) {
685                 struct pipe_buffer *buf = info->bufs + i;
686                 if (buf->ops)
687                         buf->ops->release(info, buf);
688         }
689         if (info->tmp_page)
690                 __free_page(info->tmp_page);
691         kfree(info);
692 }
693
694 struct inode* pipe_new(struct inode* inode)
695 {
696         struct pipe_inode_info *info;
697
698         info = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
699         if (!info)
700                 goto fail_page;
701         inode->i_pipe = info;
702
703         init_waitqueue_head(PIPE_WAIT(*inode));
704         PIPE_RCOUNTER(*inode) = PIPE_WCOUNTER(*inode) = 1;
705
706         return inode;
707 fail_page:
708         return NULL;
709 }
710
711 static struct vfsmount *pipe_mnt __read_mostly;
712 static int pipefs_delete_dentry(struct dentry *dentry)
713 {
714         return 1;
715 }
716 static struct dentry_operations pipefs_dentry_operations = {
717         .d_delete       = pipefs_delete_dentry,
718 };
719
720 static struct inode * get_pipe_inode(void)
721 {
722         struct inode *inode = new_inode(pipe_mnt->mnt_sb);
723
724         if (!inode)
725                 goto fail_inode;
726
727         if(!pipe_new(inode))
728                 goto fail_iput;
729         PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 1;
730         inode->i_fop = &rdwr_pipe_fops;
731
732         /*
733          * Mark the inode dirty from the very beginning,
734          * that way it will never be moved to the dirty
735          * list because "mark_inode_dirty()" will think
736          * that it already _is_ on the dirty list.
737          */
738         inode->i_state = I_DIRTY;
739         inode->i_mode = S_IFIFO | S_IRUSR | S_IWUSR;
740         inode->i_uid = current->fsuid;
741         inode->i_gid = current->fsgid;
742         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
743         inode->i_blksize = PAGE_SIZE;
744         return inode;
745
746 fail_iput:
747         iput(inode);
748 fail_inode:
749         return NULL;
750 }
751
752 int do_pipe(int *fd)
753 {
754         struct qstr this;
755         char name[32];
756         struct dentry *dentry;
757         struct inode * inode;
758         struct file *f1, *f2;
759         int error;
760         int i,j;
761
762         error = -ENFILE;
763         f1 = get_empty_filp();
764         if (!f1)
765                 goto no_files;
766
767         f2 = get_empty_filp();
768         if (!f2)
769                 goto close_f1;
770
771         inode = get_pipe_inode();
772         if (!inode)
773                 goto close_f12;
774
775         error = get_unused_fd();
776         if (error < 0)
777                 goto close_f12_inode;
778         i = error;
779
780         error = get_unused_fd();
781         if (error < 0)
782                 goto close_f12_inode_i;
783         j = error;
784
785         error = -ENOMEM;
786         sprintf(name, "[%lu]", inode->i_ino);
787         this.name = name;
788         this.len = strlen(name);
789         this.hash = inode->i_ino; /* will go */
790         dentry = d_alloc(pipe_mnt->mnt_sb->s_root, &this);
791         if (!dentry)
792                 goto close_f12_inode_i_j;
793         dentry->d_op = &pipefs_dentry_operations;
794         d_add(dentry, inode);
795         f1->f_vfsmnt = f2->f_vfsmnt = mntget(mntget(pipe_mnt));
796         f1->f_dentry = f2->f_dentry = dget(dentry);
797         f1->f_mapping = f2->f_mapping = inode->i_mapping;
798
799         /* read file */
800         f1->f_pos = f2->f_pos = 0;
801         f1->f_flags = O_RDONLY;
802         f1->f_op = &read_pipe_fops;
803         f1->f_mode = FMODE_READ;
804         f1->f_version = 0;
805
806         /* write file */
807         f2->f_flags = O_WRONLY;
808         f2->f_op = &write_pipe_fops;
809         f2->f_mode = FMODE_WRITE;
810         f2->f_version = 0;
811
812         fd_install(i, f1);
813         fd_install(j, f2);
814         fd[0] = i;
815         fd[1] = j;
816         return 0;
817
818 close_f12_inode_i_j:
819         put_unused_fd(j);
820 close_f12_inode_i:
821         put_unused_fd(i);
822 close_f12_inode:
823         free_pipe_info(inode);
824         iput(inode);
825 close_f12:
826         put_filp(f2);
827 close_f1:
828         put_filp(f1);
829 no_files:
830         return error;   
831 }
832
833 /*
834  * pipefs should _never_ be mounted by userland - too much of security hassle,
835  * no real gain from having the whole whorehouse mounted. So we don't need
836  * any operations on the root directory. However, we need a non-trivial
837  * d_name - pipe: will go nicely and kill the special-casing in procfs.
838  */
839
840 static struct super_block *pipefs_get_sb(struct file_system_type *fs_type,
841         int flags, const char *dev_name, void *data)
842 {
843         return get_sb_pseudo(fs_type, "pipe:", NULL, PIPEFS_MAGIC);
844 }
845
846 static struct file_system_type pipe_fs_type = {
847         .name           = "pipefs",
848         .get_sb         = pipefs_get_sb,
849         .kill_sb        = kill_anon_super,
850 };
851
852 static int __init init_pipe_fs(void)
853 {
854         int err = register_filesystem(&pipe_fs_type);
855         if (!err) {
856                 pipe_mnt = kern_mount(&pipe_fs_type);
857                 if (IS_ERR(pipe_mnt)) {
858                         err = PTR_ERR(pipe_mnt);
859                         unregister_filesystem(&pipe_fs_type);
860                 }
861         }
862         return err;
863 }
864
865 static void __exit exit_pipe_fs(void)
866 {
867         unregister_filesystem(&pipe_fs_type);
868         mntput(pipe_mnt);
869 }
870
871 fs_initcall(init_pipe_fs);
872 module_exit(exit_pipe_fs);