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);