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