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
 228         total_len = iov_length(iov, nr_segs);
 229         /* Null write succeeds. */
 230         if (unlikely(total_len == 0))
 231                 return 0;
 232
 233         do_wakeup = 0;
 234         ret = 0;
 235         down(PIPE_SEM(*inode));
 236         info = inode->i_pipe;
 237
 238         if (!PIPE_READERS(*inode)) {
 239                 send_sig(SIGPIPE, current, 0);
 240                 ret = -EPIPE;
 241                 goto out;
 242         }
 243
 244         /* We try to merge small writes */
 245         if (info->nrbufs && total_len < PAGE_SIZE) {
 246                 int lastbuf = (info->curbuf + info->nrbufs - 1) & (PIPE_BUFFERS-1);
 247                 struct pipe_buffer *buf = info->bufs + lastbuf;
 248                 struct pipe_buf_operations *ops = buf->ops;
 249                 int offset = buf->offset + buf->len;
 250                 if (ops->can_merge && offset + total_len <= PAGE_SIZE) {
 251                         void *addr = ops->map(filp, info, buf);
 252                         int error = pipe_iov_copy_from_user(offset + addr, iov, total_len);
 253                         ops->unmap(info, buf);
 254                         ret = error;
 255                         do_wakeup = 1;
 256                         if (error)
 257                                 goto out;
 258                         buf->len += total_len;
 259                         ret = total_len;
 260                         goto out;
 261                 }
 262
 263         }
 264
 265         for (;;) {
 266                 int bufs;
 267                 if (!PIPE_READERS(*inode)) {
 268                         send_sig(SIGPIPE, current, 0);
 269                         if (!ret) ret = -EPIPE;
 270                         break;
 271                 }
 272                 bufs = info->nrbufs;
 273                 if (bufs < PIPE_BUFFERS) {
 274                         ssize_t chars;
 275                         int newbuf = (info->curbuf + bufs) & (PIPE_BUFFERS-1);
 276                         struct pipe_buffer *buf = info->bufs + newbuf;
 277                         struct page *page = info->tmp_page;
 278                         int error;
 279
 280                         if (!page) {
 281                                 page = alloc_page(GFP_HIGHUSER);
 282                                 if (unlikely(!page)) {
 283                                         ret = ret ? : -ENOMEM;
 284                                         break;
 285                                 }
 286                                 info->tmp_page = page;
 287                         }
 288                         /* Always wakeup, even if the copy fails. Otherwise
 289                          * we lock up (O_NONBLOCK-)readers that sleep due to
 290                          * syscall merging.
 291                          * FIXME! Is this really true?
 292                          */
 293                         do_wakeup = 1;
 294                         chars = PAGE_SIZE;
 295                         if (chars > total_len)
 296                                 chars = total_len;
 297
 298                         error = pipe_iov_copy_from_user(kmap(page), iov, chars);
 299                         kunmap(page);
 300                         if (unlikely(error)) {
 301                                 if (!ret) ret = -EFAULT;
 302                                 break;
 303                         }
 304                         ret += chars;
 305
 306                         /* Insert it into the buffer array */
 307                         buf->page = page;
 308                         buf->ops = &anon_pipe_buf_ops;
 309                         buf->offset = 0;
 310                         buf->len = chars;
 311                         info->nrbufs = ++bufs;
 312                         info->tmp_page = NULL;
 313
 314                         total_len -= chars;
 315                         if (!total_len)
 316                                 break;
 317                 }
 318                 if (bufs < PIPE_BUFFERS)
 319                         continue;
 320                 if (filp->f_flags & O_NONBLOCK) {
 321                         if (!ret) ret = -EAGAIN;
 322                         break;
 323                 }
 324                 if (signal_pending(current)) {
 325                         if (!ret) ret = -ERESTARTSYS;
 326                         break;
 327                 }
 328                 if (do_wakeup) {
 329                         wake_up_interruptible_sync(PIPE_WAIT(*inode));
 330                         kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN);
 331                         do_wakeup = 0;
 332                 }
 333                 PIPE_WAITING_WRITERS(*inode)++;
 334                 pipe_wait(inode);
 335                 PIPE_WAITING_WRITERS(*inode)--;
 336         }
 337 out:
 338         up(PIPE_SEM(*inode));
 339         if (do_wakeup) {
 340                 wake_up_interruptible(PIPE_WAIT(*inode));
 341                 kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN);
 342         }
 343         if (ret > 0)
 344                 inode_update_time(inode, 1);    /* mtime and ctime */
 345         return ret;
 346 }
 347
 348 static ssize_t
 349 pipe_write(struct file *filp, const char __user *buf,
 350            size_t count, loff_t *ppos)
 351 {
 352         struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = count };
 353         return pipe_writev(filp, &iov, 1, ppos);
 354 }
 355
 356 static ssize_t
 357 bad_pipe_r(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
 358 {
 359         return -EBADF;
 360 }
 361
 362 static ssize_t
 363 bad_pipe_w(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
 364 {
 365         return -EBADF;
 366 }
 367
 368 static int
 369 pipe_ioctl(struct inode *pino, struct file *filp,
 370            unsigned int cmd, unsigned long arg)
 371 {
 372         struct inode *inode = filp->f_dentry->d_inode;
 373         struct pipe_inode_info *info;
 374         int count, buf, nrbufs;
 375
 376         switch (cmd) {
 377                 case FIONREAD:
 378                         down(PIPE_SEM(*inode));
 379                         info =  inode->i_pipe;
 380                         count = 0;
 381                         buf = info->curbuf;
 382                         nrbufs = info->nrbufs;
 383                         while (--nrbufs >= 0) {
 384                                 count += info->bufs[buf].len;
 385                                 buf = (buf+1) & (PIPE_BUFFERS-1);
 386                         }
 387                         up(PIPE_SEM(*inode));
 388                         return put_user(count, (int __user *)arg);
 389                 default:
 390                         return -EINVAL;
 391         }
 392 }
 393
 394 /* No kernel lock held - fine */
 395 static unsigned int
 396 pipe_poll(struct file *filp, poll_table *wait)
 397 {
 398         unsigned int mask;
 399         struct inode *inode = filp->f_dentry->d_inode;
 400         struct pipe_inode_info *info = inode->i_pipe;
 401         int nrbufs;
 402
 403         poll_wait(filp, PIPE_WAIT(*inode), wait);
 404
 405         /* Reading only -- no need for acquiring the semaphore.  */
 406         nrbufs = info->nrbufs;
 407         mask = 0;
 408         if (filp->f_mode & FMODE_READ) {
 409                 mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0;
 410                 if (!PIPE_WRITERS(*inode) && filp->f_version != PIPE_WCOUNTER(*inode))
 411                         mask |= POLLHUP;
 412         }
 413
 414         if (filp->f_mode & FMODE_WRITE) {
 415                 mask |= (nrbufs < PIPE_BUFFERS) ? POLLOUT | POLLWRNORM : 0;
 416                 if (!PIPE_READERS(*inode))
 417                         mask |= POLLERR;
 418         }
 419
 420         return mask;
 421 }
 422
 423 /* FIXME: most Unices do not set POLLERR for fifos */
 424 #define fifo_poll pipe_poll
 425
 426 static int
 427 pipe_release(struct inode *inode, int decr, int decw)
 428 {
 429         down(PIPE_SEM(*inode));
 430         PIPE_READERS(*inode) -= decr;
 431         PIPE_WRITERS(*inode) -= decw;
 432         if (!PIPE_READERS(*inode) && !PIPE_WRITERS(*inode)) {
 433                 free_pipe_info(inode);
 434         } else {
 435                 wake_up_interruptible(PIPE_WAIT(*inode));
 436                 kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN);
 437                 kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);
 438         }
 439         up(PIPE_SEM(*inode));
 440
 441         return 0;
 442 }
 443
 444 static int
 445 pipe_read_fasync(int fd, struct file *filp, int on)
 446 {
 447         struct inode *inode = filp->f_dentry->d_inode;
 448         int retval;
 449
 450         down(PIPE_SEM(*inode));
 451         retval = fasync_helper(fd, filp, on, PIPE_FASYNC_READERS(*inode));
 452         up(PIPE_SEM(*inode));
 453
 454         if (retval < 0)
 455                 return retval;
 456
 457         return 0;
 458 }
 459
 460
 461 static int
 462 pipe_write_fasync(int fd, struct file *filp, int on)
 463 {
 464         struct inode *inode = filp->f_dentry->d_inode;
 465         int retval;
 466
 467         down(PIPE_SEM(*inode));
 468         retval = fasync_helper(fd, filp, on, PIPE_FASYNC_WRITERS(*inode));
 469         up(PIPE_SEM(*inode));
 470
 471         if (retval < 0)
 472                 return retval;
 473
 474         return 0;
 475 }
 476
 477
 478 static int
 479 pipe_rdwr_fasync(int fd, struct file *filp, int on)
 480 {
 481         struct inode *inode = filp->f_dentry->d_inode;
 482         int retval;
 483
 484         down(PIPE_SEM(*inode));
 485
 486         retval = fasync_helper(fd, filp, on, PIPE_FASYNC_READERS(*inode));
 487
 488         if (retval >= 0)
 489                 retval = fasync_helper(fd, filp, on, PIPE_FASYNC_WRITERS(*inode));
 490
 491         up(PIPE_SEM(*inode));
 492
 493         if (retval < 0)
 494                 return retval;
 495
 496         return 0;
 497 }
 498
 499
 500 static int
 501 pipe_read_release(struct inode *inode, struct file *filp)
 502 {
 503         pipe_read_fasync(-1, filp, 0);
 504         return pipe_release(inode, 1, 0);
 505 }
 506
 507 static int
 508 pipe_write_release(struct inode *inode, struct file *filp)
 509 {
 510         pipe_write_fasync(-1, filp, 0);
 511         return pipe_release(inode, 0, 1);
 512 }
 513
 514 static int
 515 pipe_rdwr_release(struct inode *inode, struct file *filp)
 516 {
 517         int decr, decw;
 518
 519         pipe_rdwr_fasync(-1, filp, 0);
 520         decr = (filp->f_mode & FMODE_READ) != 0;
 521         decw = (filp->f_mode & FMODE_WRITE) != 0;
 522         return pipe_release(inode, decr, decw);
 523 }
 524
 525 static int
 526 pipe_read_open(struct inode *inode, struct file *filp)
 527 {
 528         /* We could have perhaps used atomic_t, but this and friends
 529            below are the only places.  So it doesn't seem worthwhile.  */
 530         down(PIPE_SEM(*inode));
 531         PIPE_READERS(*inode)++;
 532         up(PIPE_SEM(*inode));
 533
 534         return 0;
 535 }
 536
 537 static int
 538 pipe_write_open(struct inode *inode, struct file *filp)
 539 {
 540         down(PIPE_SEM(*inode));
 541         PIPE_WRITERS(*inode)++;
 542         up(PIPE_SEM(*inode));
 543
 544         return 0;
 545 }
 546
 547 static int
 548 pipe_rdwr_open(struct inode *inode, struct file *filp)
 549 {
 550         down(PIPE_SEM(*inode));
 551         if (filp->f_mode & FMODE_READ)
 552                 PIPE_READERS(*inode)++;
 553         if (filp->f_mode & FMODE_WRITE)
 554                 PIPE_WRITERS(*inode)++;
 555         up(PIPE_SEM(*inode));
 556
 557         return 0;
 558 }
 559
 560 /*
 561  * The file_operations structs are not static because they
 562  * are also used in linux/fs/fifo.c to do operations on FIFOs.
 563  */
 564 struct file_operations read_fifo_fops = {
 565         .llseek         = no_llseek,
 566         .read           = pipe_read,
 567         .readv          = pipe_readv,
 568         .write          = bad_pipe_w,
 569         .poll           = fifo_poll,
 570         .ioctl          = pipe_ioctl,
 571         .open           = pipe_read_open,
 572         .release        = pipe_read_release,
 573         .fasync         = pipe_read_fasync,
 574 };
 575
 576 struct file_operations write_fifo_fops = {
 577         .llseek         = no_llseek,
 578         .read           = bad_pipe_r,
 579         .write          = pipe_write,
 580         .writev         = pipe_writev,
 581         .poll           = fifo_poll,
 582         .ioctl          = pipe_ioctl,
 583         .open           = pipe_write_open,
 584         .release        = pipe_write_release,
 585         .fasync         = pipe_write_fasync,
 586 };
 587
 588 struct file_operations rdwr_fifo_fops = {
 589         .llseek         = no_llseek,
 590         .read           = pipe_read,
 591         .readv          = pipe_readv,
 592         .write          = pipe_write,
 593         .writev         = pipe_writev,
 594         .poll           = fifo_poll,
 595         .ioctl          = pipe_ioctl,
 596         .open           = pipe_rdwr_open,
 597         .release        = pipe_rdwr_release,
 598         .fasync         = pipe_rdwr_fasync,
 599 };
 600
 601 struct file_operations read_pipe_fops = {
 602         .llseek         = no_llseek,
 603         .read           = pipe_read,
 604         .readv          = pipe_readv,
 605         .write          = bad_pipe_w,
 606         .poll           = pipe_poll,
 607         .ioctl          = pipe_ioctl,
 608         .open           = pipe_read_open,
 609         .release        = pipe_read_release,
 610         .fasync         = pipe_read_fasync,
 611 };
 612
 613 struct file_operations write_pipe_fops = {
 614         .llseek         = no_llseek,
 615         .read           = bad_pipe_r,
 616         .write          = pipe_write,
 617         .writev         = pipe_writev,
 618         .poll           = pipe_poll,
 619         .ioctl          = pipe_ioctl,
 620         .open           = pipe_write_open,
 621         .release        = pipe_write_release,
 622         .fasync         = pipe_write_fasync,
 623 };
 624
 625 struct file_operations rdwr_pipe_fops = {
 626         .llseek         = no_llseek,
 627         .read           = pipe_read,
 628         .readv          = pipe_readv,
 629         .write          = pipe_write,
 630         .writev         = pipe_writev,
 631         .poll           = pipe_poll,
 632         .ioctl          = pipe_ioctl,
 633         .open           = pipe_rdwr_open,
 634         .release        = pipe_rdwr_release,
 635         .fasync         = pipe_rdwr_fasync,
 636 };
 637
 638 void free_pipe_info(struct inode *inode)
 639 {
 640         int i;
 641         struct pipe_inode_info *info = inode->i_pipe;
 642
 643         inode->i_pipe = NULL;
 644         for (i = 0; i < PIPE_BUFFERS; i++) {
 645                 struct pipe_buffer *buf = info->bufs + i;
 646                 if (buf->ops)
 647                         buf->ops->release(info, buf);
 648         }
 649         if (info->tmp_page)
 650                 __free_page(info->tmp_page);
 651         kfree(info);
 652 }
 653
 654 struct inode* pipe_new(struct inode* inode)
 655 {
 656         struct pipe_inode_info *info;
 657
 658         info = kmalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
 659         if (!info)
 660                 goto fail_page;
 661         memset(info, 0, sizeof(*info));
 662         inode->i_pipe = info;
 663
 664         init_waitqueue_head(PIPE_WAIT(*inode));
 665         PIPE_RCOUNTER(*inode) = PIPE_WCOUNTER(*inode) = 1;
 666
 667         return inode;
 668 fail_page:
 669         return NULL;
 670 }
 671
 672 static struct vfsmount *pipe_mnt;
 673 static int pipefs_delete_dentry(struct dentry *dentry)
 674 {
 675         return 1;
 676 }
 677 static struct dentry_operations pipefs_dentry_operations = {
 678         .d_delete       = pipefs_delete_dentry,
 679 };
 680
 681 static struct inode * get_pipe_inode(void)
 682 {
 683         struct inode *inode = new_inode(pipe_mnt->mnt_sb);
 684
 685         if (!inode)
 686                 goto fail_inode;
 687
 688         if(!pipe_new(inode))
 689                 goto fail_iput;
 690         PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 1;
 691         inode->i_fop = &rdwr_pipe_fops;
 692
 693         /*
 694          * Mark the inode dirty from the very beginning,
 695          * that way it will never be moved to the dirty
 696          * list because "mark_inode_dirty()" will think
 697          * that it already _is_ on the dirty list.
 698          */
 699         inode->i_state = I_DIRTY;
 700         inode->i_mode = S_IFIFO | S_IRUSR | S_IWUSR;
 701         inode->i_uid = current->fsuid;
 702         inode->i_gid = current->fsgid;
 703         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 704         inode->i_blksize = PAGE_SIZE;
 705         return inode;
 706
 707 fail_iput:
 708         iput(inode);
 709 fail_inode:
 710         return NULL;
 711 }
 712
 713 int do_pipe(int *fd)
 714 {
 715         struct qstr this;
 716         char name[32];
 717         struct dentry *dentry;
 718         struct inode * inode;
 719         struct file *f1, *f2;
 720         int error;
 721         int i,j;
 722
 723         error = -ENFILE;
 724         f1 = get_empty_filp();
 725         if (!f1)
 726                 goto no_files;
 727
 728         f2 = get_empty_filp();
 729         if (!f2)
 730                 goto close_f1;
 731
 732         inode = get_pipe_inode();
 733         if (!inode)
 734                 goto close_f12;
 735
 736         error = get_unused_fd();
 737         if (error < 0)
 738                 goto close_f12_inode;
 739         i = error;
 740
 741         error = get_unused_fd();
 742         if (error < 0)
 743                 goto close_f12_inode_i;
 744         j = error;
 745
 746         error = -ENOMEM;
 747         sprintf(name, "[%lu]", inode->i_ino);
 748         this.name = name;
 749         this.len = strlen(name);
 750         this.hash = inode->i_ino; /* will go */
 751         dentry = d_alloc(pipe_mnt->mnt_sb->s_root, &this);
 752         if (!dentry)
 753                 goto close_f12_inode_i_j;
 754         dentry->d_op = &pipefs_dentry_operations;
 755         d_add(dentry, inode);
 756         f1->f_vfsmnt = f2->f_vfsmnt = mntget(mntget(pipe_mnt));
 757         f1->f_dentry = f2->f_dentry = dget(dentry);
 758         f1->f_mapping = f2->f_mapping = inode->i_mapping;
 759
 760         /* read file */
 761         f1->f_pos = f2->f_pos = 0;
 762         f1->f_flags = O_RDONLY;
 763         f1->f_op = &read_pipe_fops;
 764         f1->f_mode = FMODE_READ;
 765         f1->f_version = 0;
 766
 767         /* write file */
 768         f2->f_flags = O_WRONLY;
 769         f2->f_op = &write_pipe_fops;
 770         f2->f_mode = FMODE_WRITE;
 771         f2->f_version = 0;
 772
 773         fd_install(i, f1);
 774         fd_install(j, f2);
 775         fd[0] = i;
 776         fd[1] = j;
 777         return 0;
 778
 779 close_f12_inode_i_j:
 780         put_unused_fd(j);
 781 close_f12_inode_i:
 782         put_unused_fd(i);
 783 close_f12_inode:
 784         free_pipe_info(inode);
 785         iput(inode);
 786 close_f12:
 787         put_filp(f2);
 788 close_f1:
 789         put_filp(f1);
 790 no_files:
 791         return error;
 792 }
 793
 794 /*
 795  * pipefs should _never_ be mounted by userland - too much of security hassle,
 796  * no real gain from having the whole whorehouse mounted. So we don't need
 797  * any operations on the root directory. However, we need a non-trivial
 798  * d_name - pipe: will go nicely and kill the special-casing in procfs.
 799  */
 800
 801 static struct super_block *pipefs_get_sb(struct file_system_type *fs_type,
 802         int flags, const char *dev_name, void *data)
 803 {
 804         return get_sb_pseudo(fs_type, "pipe:", NULL, PIPEFS_MAGIC);
 805 }
 806
 807 static struct file_system_type pipe_fs_type = {
 808         .name           = "pipefs",
 809         .get_sb         = pipefs_get_sb,
 810         .kill_sb        = kill_anon_super,
 811 };
 812
 813 static int __init init_pipe_fs(void)
 814 {
 815         int err = register_filesystem(&pipe_fs_type);
 816         if (!err) {
 817                 pipe_mnt = kern_mount(&pipe_fs_type);
 818                 if (IS_ERR(pipe_mnt)) {
 819                         err = PTR_ERR(pipe_mnt);
 820                         unregister_filesystem(&pipe_fs_type);
 821                 }
 822         }
 823         return err;
 824 }
 825
 826 static void __exit exit_pipe_fs(void)
 827 {
 828         unregister_filesystem(&pipe_fs_type);
 829         mntput(pipe_mnt);
 830 }
 831
 832 fs_initcall(init_pipe_fs);
 833 module_exit(exit_pipe_fs);