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