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 pipe_inode_info *pipe)
  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, &wait,
  48                         TASK_INTERRUPTIBLE | TASK_NONINTERACTIVE);
  49         if (pipe->inode)
  50                 mutex_unlock(&pipe->inode->i_mutex);
  51         schedule();
  52         finish_wait(&pipe->wait, &wait);
  53         if (pipe->inode)
  54                 mutex_lock(&pipe->inode->i_mutex);
  55 }
  56
  57 static int
  58 pipe_iov_copy_from_user(void *to, struct iovec *iov, unsigned long len,
  59                         int atomic)
  60 {
  61         unsigned long copy;
  62
  63         while (len > 0) {
  64                 while (!iov->iov_len)
  65                         iov++;
  66                 copy = min_t(unsigned long, len, iov->iov_len);
  67
  68                 if (atomic) {
  69                         if (__copy_from_user_inatomic(to, iov->iov_base, copy))
  70                                 return -EFAULT;
  71                 } else {
  72                         if (copy_from_user(to, iov->iov_base, copy))
  73                                 return -EFAULT;
  74                 }
  75                 to += copy;
  76                 len -= copy;
  77                 iov->iov_base += copy;
  78                 iov->iov_len -= copy;
  79         }
  80         return 0;
  81 }
  82
  83 static int
  84 pipe_iov_copy_to_user(struct iovec *iov, const void *from, unsigned long len,
  85                       int atomic)
  86 {
  87         unsigned long copy;
  88
  89         while (len > 0) {
  90                 while (!iov->iov_len)
  91                         iov++;
  92                 copy = min_t(unsigned long, len, iov->iov_len);
  93
  94                 if (atomic) {
  95                         if (__copy_to_user_inatomic(iov->iov_base, from, copy))
  96                                 return -EFAULT;
  97                 } else {
  98                         if (copy_to_user(iov->iov_base, from, copy))
  99                                 return -EFAULT;
 100                 }
 101                 from += copy;
 102                 len -= copy;
 103                 iov->iov_base += copy;
 104                 iov->iov_len -= copy;
 105         }
 106         return 0;
 107 }
 108
 109 /*
 110  * Attempt to pre-fault in the user memory, so we can use atomic copies.
 111  * Returns the number of bytes not faulted in.
 112  */
 113 static int iov_fault_in_pages_write(struct iovec *iov, unsigned long len)
 114 {
 115         while (!iov->iov_len)
 116                 iov++;
 117
 118         while (len > 0) {
 119                 unsigned long this_len;
 120
 121                 this_len = min_t(unsigned long, len, iov->iov_len);
 122                 if (fault_in_pages_writeable(iov->iov_base, this_len))
 123                         break;
 124
 125                 len -= this_len;
 126                 iov++;
 127         }
 128
 129         return len;
 130 }
 131
 132 /*
 133  * Pre-fault in the user memory, so we can use atomic copies.
 134  */
 135 static void iov_fault_in_pages_read(struct iovec *iov, unsigned long len)
 136 {
 137         while (!iov->iov_len)
 138                 iov++;
 139
 140         while (len > 0) {
 141                 unsigned long this_len;
 142
 143                 this_len = min_t(unsigned long, len, iov->iov_len);
 144                 fault_in_pages_readable(iov->iov_base, this_len);
 145                 len -= this_len;
 146                 iov++;
 147         }
 148 }
 149
 150 static void anon_pipe_buf_release(struct pipe_inode_info *pipe,
 151                                   struct pipe_buffer *buf)
 152 {
 153         struct page *page = buf->page;
 154
 155         /*
 156          * If nobody else uses this page, and we don't already have a
 157          * temporary page, let's keep track of it as a one-deep
 158          * allocation cache. (Otherwise just release our reference to it)
 159          */
 160         if (page_count(page) == 1 && !pipe->tmp_page)
 161                 pipe->tmp_page = page;
 162         else
 163                 page_cache_release(page);
 164 }
 165
 166 void *generic_pipe_buf_map(struct pipe_inode_info *pipe,
 167                            struct pipe_buffer *buf, int atomic)
 168 {
 169         if (atomic) {
 170                 buf->flags |= PIPE_BUF_FLAG_ATOMIC;
 171                 return kmap_atomic(buf->page, KM_USER0);
 172         }
 173
 174         return kmap(buf->page);
 175 }
 176
 177 void generic_pipe_buf_unmap(struct pipe_inode_info *pipe,
 178                             struct pipe_buffer *buf, void *map_data)
 179 {
 180         if (buf->flags & PIPE_BUF_FLAG_ATOMIC) {
 181                 buf->flags &= ~PIPE_BUF_FLAG_ATOMIC;
 182                 kunmap_atomic(map_data, KM_USER0);
 183         } else
 184                 kunmap(buf->page);
 185 }
 186
 187 int generic_pipe_buf_steal(struct pipe_inode_info *pipe,
 188                            struct pipe_buffer *buf)
 189 {
 190         struct page *page = buf->page;
 191
 192         if (page_count(page) == 1) {
 193                 lock_page(page);
 194                 return 0;
 195         }
 196
 197         return 1;
 198 }
 199
 200 void generic_pipe_buf_get(struct pipe_inode_info *info, struct pipe_buffer *buf)
 201 {
 202         page_cache_get(buf->page);
 203 }
 204
 205 int generic_pipe_buf_pin(struct pipe_inode_info *info, struct pipe_buffer *buf)
 206 {
 207         return 0;
 208 }
 209
 210 static struct pipe_buf_operations anon_pipe_buf_ops = {
 211         .can_merge = 1,
 212         .map = generic_pipe_buf_map,
 213         .unmap = generic_pipe_buf_unmap,
 214         .pin = generic_pipe_buf_pin,
 215         .release = anon_pipe_buf_release,
 216         .steal = generic_pipe_buf_steal,
 217         .get = generic_pipe_buf_get,
 218 };
 219
 220 static ssize_t
 221 pipe_read(struct kiocb *iocb, const struct iovec *_iov,
 222            unsigned long nr_segs, loff_t pos)
 223 {
 224         struct file *filp = iocb->ki_filp;
 225         struct inode *inode = filp->f_dentry->d_inode;
 226         struct pipe_inode_info *pipe;
 227         int do_wakeup;
 228         ssize_t ret;
 229         struct iovec *iov = (struct iovec *)_iov;
 230         size_t total_len;
 231
 232         total_len = iov_length(iov, nr_segs);
 233         /* Null read succeeds. */
 234         if (unlikely(total_len == 0))
 235                 return 0;
 236
 237         do_wakeup = 0;
 238         ret = 0;
 239         mutex_lock(&inode->i_mutex);
 240 #if 0   // mask by Victor Yu. 02-12-2007
 241         pipe = inode->i_pipe;
 242 #else
 243         pipe = inode->u.i_pipe;
 244 #endif
 245         for (;;) {
 246                 int bufs = pipe->nrbufs;
 247                 if (bufs) {
 248                         int curbuf = pipe->curbuf;
 249                         struct pipe_buffer *buf = pipe->bufs + curbuf;
 250                         struct pipe_buf_operations *ops = buf->ops;
 251                         void *addr;
 252                         size_t chars = buf->len;
 253                         int error, atomic;
 254
 255                         if (chars > total_len)
 256                                 chars = total_len;
 257
 258                         error = ops->pin(pipe, buf);
 259                         if (error) {
 260                                 if (!ret)
 261                                         error = ret;
 262                                 break;
 263                         }
 264
 265                         atomic = !iov_fault_in_pages_write(iov, chars);
 266 redo:
 267                         addr = ops->map(pipe, buf, atomic);
 268                         error = pipe_iov_copy_to_user(iov, addr + buf->offset, chars, atomic);
 269                         ops->unmap(pipe, buf, addr);
 270                         if (unlikely(error)) {
 271                                 /*
 272                                  * Just retry with the slow path if we failed.
 273                                  */
 274                                 if (atomic) {
 275                                         atomic = 0;
 276                                         goto redo;
 277                                 }
 278                                 if (!ret)
 279                                         ret = error;
 280                                 break;
 281                         }
 282                         ret += chars;
 283                         buf->offset += chars;
 284                         buf->len -= chars;
 285                         if (!buf->len) {
 286                                 buf->ops = NULL;
 287                                 ops->release(pipe, buf);
 288                                 curbuf = (curbuf + 1) & (PIPE_BUFFERS-1);
 289                                 pipe->curbuf = curbuf;
 290                                 pipe->nrbufs = --bufs;
 291                                 do_wakeup = 1;
 292                         }
 293                         total_len -= chars;
 294                         if (!total_len)
 295                                 break;  /* common path: read succeeded */
 296                 }
 297                 if (bufs)       /* More to do? */
 298                         continue;
 299                 if (!pipe->writers)
 300                         break;
 301                 if (!pipe->waiting_writers) {
 302                         /* syscall merging: Usually we must not sleep
 303                          * if O_NONBLOCK is set, or if we got some data.
 304                          * But if a writer sleeps in kernel space, then
 305                          * we can wait for that data without violating POSIX.
 306                          */
 307                         if (ret)
 308                                 break;
 309                         if (filp->f_flags & O_NONBLOCK) {
 310                                 ret = -EAGAIN;
 311                                 break;
 312                         }
 313                 }
 314                 if (signal_pending(current)) {
 315                         if (!ret)
 316                                 ret = -ERESTARTSYS;
 317                         break;
 318                 }
 319                 if (do_wakeup) {
 320                         wake_up_interruptible_sync(&pipe->wait);
 321                         kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
 322                 }
 323                 pipe_wait(pipe);
 324         }
 325         mutex_unlock(&inode->i_mutex);
 326
 327         /* Signal writers asynchronously that there is more room. */
 328         if (do_wakeup) {
 329                 wake_up_interruptible(&pipe->wait);
 330                 kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
 331         }
 332         if (ret > 0)
 333                 file_accessed(filp);
 334         return ret;
 335 }
 336
 337 static ssize_t
 338 pipe_write(struct kiocb *iocb, const struct iovec *_iov,
 339             unsigned long nr_segs, loff_t ppos)
 340 {
 341         struct file *filp = iocb->ki_filp;
 342         struct inode *inode = filp->f_dentry->d_inode;
 343         struct pipe_inode_info *pipe;
 344         ssize_t ret;
 345         int do_wakeup;
 346         struct iovec *iov = (struct iovec *)_iov;
 347         size_t total_len;
 348         ssize_t chars;
 349
 350         total_len = iov_length(iov, nr_segs);
 351         /* Null write succeeds. */
 352         if (unlikely(total_len == 0))
 353                 return 0;
 354
 355         do_wakeup = 0;
 356         ret = 0;
 357         mutex_lock(&inode->i_mutex);
 358 #if 0   // mask by Victor Yu. 02-12-2007
 359         pipe = inode->i_pipe;
 360 #else
 361         pipe = inode->u.i_pipe;
 362 #endif
 363
 364         if (!pipe->readers) {
 365                 send_sig(SIGPIPE, current, 0);
 366                 ret = -EPIPE;
 367                 goto out;
 368         }
 369
 370         /* We try to merge small writes */
 371         chars = total_len & (PAGE_SIZE-1); /* size of the last buffer */
 372         if (pipe->nrbufs && chars != 0) {
 373                 int lastbuf = (pipe->curbuf + pipe->nrbufs - 1) &
 374                                                         (PIPE_BUFFERS-1);
 375                 struct pipe_buffer *buf = pipe->bufs + lastbuf;
 376                 struct pipe_buf_operations *ops = buf->ops;
 377                 int offset = buf->offset + buf->len;
 378
 379                 if (ops->can_merge && offset + chars <= PAGE_SIZE) {
 380                         int error, atomic = 1;
 381                         void *addr;
 382
 383                         error = ops->pin(pipe, buf);
 384                         if (error)
 385                                 goto out;
 386
 387                         iov_fault_in_pages_read(iov, chars);
 388 redo1:
 389                         addr = ops->map(pipe, buf, atomic);
 390                         error = pipe_iov_copy_from_user(offset + addr, iov,
 391                                                         chars, atomic);
 392                         ops->unmap(pipe, buf, addr);
 393                         ret = error;
 394                         do_wakeup = 1;
 395                         if (error) {
 396                                 if (atomic) {
 397                                         atomic = 0;
 398                                         goto redo1;
 399                                 }
 400                                 goto out;
 401                         }
 402                         buf->len += chars;
 403                         total_len -= chars;
 404                         ret = chars;
 405                         if (!total_len)
 406                                 goto out;
 407                 }
 408         }
 409
 410         for (;;) {
 411                 int bufs;
 412
 413                 if (!pipe->readers) {
 414                         send_sig(SIGPIPE, current, 0);
 415                         if (!ret)
 416                                 ret = -EPIPE;
 417                         break;
 418                 }
 419                 bufs = pipe->nrbufs;
 420                 if (bufs < PIPE_BUFFERS) {
 421                         int newbuf = (pipe->curbuf + bufs) & (PIPE_BUFFERS-1);
 422                         struct pipe_buffer *buf = pipe->bufs + newbuf;
 423                         struct page *page = pipe->tmp_page;
 424                         char *src;
 425                         int error, atomic = 1;
 426
 427                         if (!page) {
 428                                 page = alloc_page(GFP_HIGHUSER);
 429                                 if (unlikely(!page)) {
 430                                         ret = ret ? : -ENOMEM;
 431                                         break;
 432                                 }
 433                                 pipe->tmp_page = page;
 434                         }
 435                         /* Always wake up, even if the copy fails. Otherwise
 436                          * we lock up (O_NONBLOCK-)readers that sleep due to
 437                          * syscall merging.
 438                          * FIXME! Is this really true?
 439                          */
 440                         do_wakeup = 1;
 441                         chars = PAGE_SIZE;
 442                         if (chars > total_len)
 443                                 chars = total_len;
 444
 445                         iov_fault_in_pages_read(iov, chars);
 446 redo2:
 447                         if (atomic)
 448                                 src = kmap_atomic(page, KM_USER0);
 449                         else
 450                                 src = kmap(page);
 451
 452                         error = pipe_iov_copy_from_user(src, iov, chars,
 453                                                         atomic);
 454                         if (atomic)
 455                                 kunmap_atomic(src, KM_USER0);
 456                         else
 457                                 kunmap(page);
 458
 459                         if (unlikely(error)) {
 460                                 if (atomic) {
 461                                         atomic = 0;
 462                                         goto redo2;
 463                                 }
 464                                 if (!ret)
 465                                         ret = error;
 466                                 break;
 467                         }
 468                         ret += chars;
 469
 470                         /* Insert it into the buffer array */
 471                         buf->page = page;
 472                         buf->ops = &anon_pipe_buf_ops;
 473                         buf->offset = 0;
 474                         buf->len = chars;
 475                         pipe->nrbufs = ++bufs;
 476                         pipe->tmp_page = NULL;
 477
 478                         total_len -= chars;
 479                         if (!total_len)
 480                                 break;
 481                 }
 482                 if (bufs < PIPE_BUFFERS)
 483                         continue;
 484                 if (filp->f_flags & O_NONBLOCK) {
 485                         if (!ret)
 486                                 ret = -EAGAIN;
 487                         break;
 488                 }
 489                 if (signal_pending(current)) {
 490                         if (!ret)
 491                                 ret = -ERESTARTSYS;
 492                         break;
 493                 }
 494                 if (do_wakeup) {
 495                         wake_up_interruptible_sync(&pipe->wait);
 496                         kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
 497                         do_wakeup = 0;
 498                 }
 499                 pipe->waiting_writers++;
 500                 pipe_wait(pipe);
 501                 pipe->waiting_writers--;
 502         }
 503 out:
 504         mutex_unlock(&inode->i_mutex);
 505         if (do_wakeup) {
 506                 wake_up_interruptible(&pipe->wait);
 507                 kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
 508         }
 509         if (ret > 0)
 510                 file_update_time(filp);
 511         return ret;
 512 }
 513
 514 static ssize_t
 515 bad_pipe_r(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
 516 {
 517         return -EBADF;
 518 }
 519
 520 static ssize_t
 521 bad_pipe_w(struct file *filp, const char __user *buf, size_t count,
 522            loff_t *ppos)
 523 {
 524         return -EBADF;
 525 }
 526
 527 static int
 528 pipe_ioctl(struct inode *pino, struct file *filp,
 529            unsigned int cmd, unsigned long arg)
 530 {
 531         struct inode *inode = filp->f_dentry->d_inode;
 532         struct pipe_inode_info *pipe;
 533         int count, buf, nrbufs;
 534
 535         switch (cmd) {
 536                 case FIONREAD:
 537                         mutex_lock(&inode->i_mutex);
 538 #if 0   // mask by Victor Yu. 02-12-2007
 539                         pipe = inode->i_pipe;
 540 #else
 541                         pipe = inode->u.i_pipe;
 542 #endif
 543                         count = 0;
 544                         buf = pipe->curbuf;
 545                         nrbufs = pipe->nrbufs;
 546                         while (--nrbufs >= 0) {
 547                                 count += pipe->bufs[buf].len;
 548                                 buf = (buf+1) & (PIPE_BUFFERS-1);
 549                         }
 550                         mutex_unlock(&inode->i_mutex);
 551
 552                         return put_user(count, (int __user *)arg);
 553                 default:
 554                         return -EINVAL;
 555         }
 556 }
 557
 558 /* No kernel lock held - fine */
 559 static unsigned int
 560 pipe_poll(struct file *filp, poll_table *wait)
 561 {
 562         unsigned int mask;
 563         struct inode *inode = filp->f_dentry->d_inode;
 564 #if 0   // mask by Victor Yu. 02-12-2007
 565         struct pipe_inode_info *pipe = inode->i_pipe;
 566 #else
 567         struct pipe_inode_info *pipe = inode->u.i_pipe;
 568 #endif
 569         int nrbufs;
 570
 571         poll_wait(filp, &pipe->wait, wait);
 572
 573         /* Reading only -- no need for acquiring the semaphore.  */
 574         nrbufs = pipe->nrbufs;
 575         mask = 0;
 576         if (filp->f_mode & FMODE_READ) {
 577                 mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0;
 578                 if (!pipe->writers && filp->f_version != pipe->w_counter)
 579                         mask |= POLLHUP;
 580         }
 581
 582         if (filp->f_mode & FMODE_WRITE) {
 583                 mask |= (nrbufs < PIPE_BUFFERS) ? POLLOUT | POLLWRNORM : 0;
 584                 /*
 585                  * Most Unices do not set POLLERR for FIFOs but on Linux they
 586                  * behave exactly like pipes for poll().
 587                  */
 588                 if (!pipe->readers)
 589                         mask |= POLLERR;
 590         }
 591
 592         return mask;
 593 }
 594
 595 static int
 596 pipe_release(struct inode *inode, int decr, int decw)
 597 {
 598         struct pipe_inode_info *pipe;
 599
 600         mutex_lock(&inode->i_mutex);
 601 #if 0   // mask by Victor Yu. 02-12-2007
 602         pipe = inode->i_pipe;
 603 #else
 604         pipe = inode->u.i_pipe;
 605 #endif
 606         pipe->readers -= decr;
 607         pipe->writers -= decw;
 608
 609         if (!pipe->readers && !pipe->writers) {
 610                 free_pipe_info(inode);
 611         } else {
 612                 wake_up_interruptible(&pipe->wait);
 613                 kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
 614                 kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
 615         }
 616         mutex_unlock(&inode->i_mutex);
 617
 618         return 0;
 619 }
 620
 621 static int
 622 pipe_read_fasync(int fd, struct file *filp, int on)
 623 {
 624         struct inode *inode = filp->f_dentry->d_inode;
 625         int retval;
 626
 627         mutex_lock(&inode->i_mutex);
 628 #if 0   // mask by Victor Yu. 02-12-2007
 629         retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_readers);
 630 #else
 631         retval = fasync_helper(fd, filp, on, &inode->u.i_pipe->fasync_readers);
 632 #endif
 633         mutex_unlock(&inode->i_mutex);
 634
 635         if (retval < 0)
 636                 return retval;
 637
 638         return 0;
 639 }
 640
 641
 642 static int
 643 pipe_write_fasync(int fd, struct file *filp, int on)
 644 {
 645         struct inode *inode = filp->f_dentry->d_inode;
 646         int retval;
 647
 648         mutex_lock(&inode->i_mutex);
 649 #if 0   // mask by Victor Yu. 02-12-2007
 650         retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_writers);
 651 #else
 652         retval = fasync_helper(fd, filp, on, &inode->u.i_pipe->fasync_writers);
 653 #endif
 654         mutex_unlock(&inode->i_mutex);
 655
 656         if (retval < 0)
 657                 return retval;
 658
 659         return 0;
 660 }
 661
 662
 663 static int
 664 pipe_rdwr_fasync(int fd, struct file *filp, int on)
 665 {
 666         struct inode *inode = filp->f_dentry->d_inode;
 667 #if 0   // mask by Victor Yu. 02-12-2007
 668         struct pipe_inode_info *pipe = inode->i_pipe;
 669 #else
 670         struct pipe_inode_info *pipe = inode->u.i_pipe;
 671 #endif
 672         int retval;
 673
 674         mutex_lock(&inode->i_mutex);
 675
 676         retval = fasync_helper(fd, filp, on, &pipe->fasync_readers);
 677
 678         if (retval >= 0)
 679                 retval = fasync_helper(fd, filp, on, &pipe->fasync_writers);
 680
 681         mutex_unlock(&inode->i_mutex);
 682
 683         if (retval < 0)
 684                 return retval;
 685
 686         return 0;
 687 }
 688
 689
 690 static int
 691 pipe_read_release(struct inode *inode, struct file *filp)
 692 {
 693         pipe_read_fasync(-1, filp, 0);
 694         return pipe_release(inode, 1, 0);
 695 }
 696
 697 static int
 698 pipe_write_release(struct inode *inode, struct file *filp)
 699 {
 700         pipe_write_fasync(-1, filp, 0);
 701         return pipe_release(inode, 0, 1);
 702 }
 703
 704 static int
 705 pipe_rdwr_release(struct inode *inode, struct file *filp)
 706 {
 707         int decr, decw;
 708
 709         pipe_rdwr_fasync(-1, filp, 0);
 710         decr = (filp->f_mode & FMODE_READ) != 0;
 711         decw = (filp->f_mode & FMODE_WRITE) != 0;
 712         return pipe_release(inode, decr, decw);
 713 }
 714
 715 static int
 716 pipe_read_open(struct inode *inode, struct file *filp)
 717 {
 718         /* We could have perhaps used atomic_t, but this and friends
 719            below are the only places.  So it doesn't seem worthwhile.  */
 720         mutex_lock(&inode->i_mutex);
 721 #if 0   // mask by Victor Yu. 02-12-2007
 722         inode->i_pipe->readers++;
 723 #else
 724         inode->u.i_pipe->readers++;
 725 #endif
 726         mutex_unlock(&inode->i_mutex);
 727
 728         return 0;
 729 }
 730
 731 static int
 732 pipe_write_open(struct inode *inode, struct file *filp)
 733 {
 734         mutex_lock(&inode->i_mutex);
 735 #if 0   // mask by Victor Yu. 02-12-2007
 736         inode->i_pipe->writers++;
 737 #else
 738         inode->u.i_pipe->writers++;
 739 #endif
 740         mutex_unlock(&inode->i_mutex);
 741
 742         return 0;
 743 }
 744
 745 static int
 746 pipe_rdwr_open(struct inode *inode, struct file *filp)
 747 {
 748         mutex_lock(&inode->i_mutex);
 749         if (filp->f_mode & FMODE_READ)
 750 #if 0   // mask by Victor Yu. 02-12-2007
 751                 inode->i_pipe->readers++;
 752 #else
 753                 inode->u.i_pipe->readers++;
 754 #endif
 755         if (filp->f_mode & FMODE_WRITE)
 756 #if 0   // mask by Victor Yu. 02-12-2007
 757                 inode->i_pipe->writers++;
 758 #else
 759                 inode->u.i_pipe->writers++;
 760 #endif
 761         mutex_unlock(&inode->i_mutex);
 762
 763         return 0;
 764 }
 765
 766 /*
 767  * The file_operations structs are not static because they
 768  * are also used in linux/fs/fifo.c to do operations on FIFOs.
 769  */
 770 const struct file_operations read_fifo_fops = {
 771         .llseek         = no_llseek,
 772         .read           = do_sync_read,
 773         .aio_read       = pipe_read,
 774         .write          = bad_pipe_w,
 775         .poll           = pipe_poll,
 776         .ioctl          = pipe_ioctl,
 777         .open           = pipe_read_open,
 778         .release        = pipe_read_release,
 779         .fasync         = pipe_read_fasync,
 780 };
 781
 782 const struct file_operations write_fifo_fops = {
 783         .llseek         = no_llseek,
 784         .read           = bad_pipe_r,
 785         .write          = do_sync_write,
 786         .aio_write      = pipe_write,
 787         .poll           = pipe_poll,
 788         .ioctl          = pipe_ioctl,
 789         .open           = pipe_write_open,
 790         .release        = pipe_write_release,
 791         .fasync         = pipe_write_fasync,
 792 };
 793
 794 const struct file_operations rdwr_fifo_fops = {
 795         .llseek         = no_llseek,
 796         .read           = do_sync_read,
 797         .aio_read       = pipe_read,
 798         .write          = do_sync_write,
 799         .aio_write      = pipe_write,
 800         .poll           = pipe_poll,
 801         .ioctl          = pipe_ioctl,
 802         .open           = pipe_rdwr_open,
 803         .release        = pipe_rdwr_release,
 804         .fasync         = pipe_rdwr_fasync,
 805 };
 806
 807 static struct file_operations read_pipe_fops = {
 808         .llseek         = no_llseek,
 809         .read           = do_sync_read,
 810         .aio_read       = pipe_read,
 811         .write          = bad_pipe_w,
 812         .poll           = pipe_poll,
 813         .ioctl          = pipe_ioctl,
 814         .open           = pipe_read_open,
 815         .release        = pipe_read_release,
 816         .fasync         = pipe_read_fasync,
 817 };
 818
 819 static struct file_operations write_pipe_fops = {
 820         .llseek         = no_llseek,
 821         .read           = bad_pipe_r,
 822         .write          = do_sync_write,
 823         .aio_write      = pipe_write,
 824         .poll           = pipe_poll,
 825         .ioctl          = pipe_ioctl,
 826         .open           = pipe_write_open,
 827         .release        = pipe_write_release,
 828         .fasync         = pipe_write_fasync,
 829 };
 830
 831 static struct file_operations rdwr_pipe_fops = {
 832         .llseek         = no_llseek,
 833         .read           = do_sync_read,
 834         .aio_read       = pipe_read,
 835         .write          = do_sync_write,
 836         .aio_write      = pipe_write,
 837         .poll           = pipe_poll,
 838         .ioctl          = pipe_ioctl,
 839         .open           = pipe_rdwr_open,
 840         .release        = pipe_rdwr_release,
 841         .fasync         = pipe_rdwr_fasync,
 842 };
 843
 844 struct pipe_inode_info * alloc_pipe_info(struct inode *inode)
 845 {
 846         struct pipe_inode_info *pipe;
 847
 848         pipe = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
 849         if (pipe) {
 850                 init_waitqueue_head(&pipe->wait);
 851                 pipe->r_counter = pipe->w_counter = 1;
 852                 pipe->inode = inode;
 853         }
 854
 855         return pipe;
 856 }
 857
 858 void __free_pipe_info(struct pipe_inode_info *pipe)
 859 {
 860         int i;
 861
 862         for (i = 0; i < PIPE_BUFFERS; i++) {
 863                 struct pipe_buffer *buf = pipe->bufs + i;
 864                 if (buf->ops)
 865                         buf->ops->release(pipe, buf);
 866         }
 867         if (pipe->tmp_page)
 868                 __free_page(pipe->tmp_page);
 869         kfree(pipe);
 870 }
 871
 872 void free_pipe_info(struct inode *inode)
 873 {
 874 #if 0   // mask by Victor Yu. 02-12-2007
 875         __free_pipe_info(inode->i_pipe);
 876         inode->i_pipe = NULL;
 877 #else
 878         __free_pipe_info(inode->u.i_pipe);
 879         inode->u.i_pipe = NULL;
 880 #endif
 881 }
 882
 883 static struct vfsmount *pipe_mnt __read_mostly;
 884 static int pipefs_delete_dentry(struct dentry *dentry)
 885 {
 886         return 1;
 887 }
 888
 889 static struct dentry_operations pipefs_dentry_operations = {
 890         .d_delete       = pipefs_delete_dentry,
 891 };
 892
 893 static struct inode * get_pipe_inode(void)
 894 {
 895         struct inode *inode = new_inode(pipe_mnt->mnt_sb);
 896         struct pipe_inode_info *pipe;
 897
 898         if (!inode)
 899                 goto fail_inode;
 900
 901         pipe = alloc_pipe_info(inode);
 902         if (!pipe)
 903                 goto fail_iput;
 904 #if 0   // mask by Victor Yu. 02-12-2007
 905         inode->i_pipe = pipe;
 906 #else
 907         inode->u.i_pipe = pipe;
 908 #endif
 909
 910         pipe->readers = pipe->writers = 1;
 911         inode->i_fop = &rdwr_pipe_fops;
 912
 913         /*
 914          * Mark the inode dirty from the very beginning,
 915          * that way it will never be moved to the dirty
 916          * list because "mark_inode_dirty()" will think
 917          * that it already _is_ on the dirty list.
 918          */
 919         inode->i_state = I_DIRTY;
 920         inode->i_mode = S_IFIFO | S_IRUSR | S_IWUSR;
 921         inode->i_uid = current->fsuid;
 922         inode->i_gid = current->fsgid;
 923         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 924
 925         return inode;
 926
 927 fail_iput:
 928         iput(inode);
 929
 930 fail_inode:
 931         return NULL;
 932 }
 933
 934 struct file *create_write_pipe(void)
 935 {
 936         int err;
 937         struct inode *inode;
 938         struct file *f;
 939         struct dentry *dentry;
 940         char name[32];
 941         struct qstr this;
 942
 943         f = get_empty_filp();
 944         if (!f)
 945                 return ERR_PTR(-ENFILE);
 946         err = -ENFILE;
 947         inode = get_pipe_inode();
 948         if (!inode)
 949                 goto err_file;
 950
 951         sprintf(name, "[%lu]", inode->i_ino);
 952         this.name = name;
 953         this.len = strlen(name);
 954         this.hash = inode->i_ino; /* will go */
 955         err = -ENOMEM;
 956         dentry = d_alloc(pipe_mnt->mnt_sb->s_root, &this);
 957         if (!dentry)
 958                 goto err_inode;
 959
 960         dentry->d_op = &pipefs_dentry_operations;
 961         d_add(dentry, inode);
 962         f->f_vfsmnt = mntget(pipe_mnt);
 963         f->f_dentry = dentry;
 964         f->f_mapping = inode->i_mapping;
 965
 966         f->f_flags = O_WRONLY;
 967         f->f_op = &write_pipe_fops;
 968         f->f_mode = FMODE_WRITE;
 969         f->f_version = 0;
 970
 971         return f;
 972
 973  err_inode:
 974         free_pipe_info(inode);
 975         iput(inode);
 976  err_file:
 977         put_filp(f);
 978         return ERR_PTR(err);
 979 }
 980
 981 void free_write_pipe(struct file *f)
 982 {
 983         mntput(f->f_vfsmnt);
 984         dput(f->f_dentry);
 985         put_filp(f);
 986 }
 987
 988 struct file *create_read_pipe(struct file *wrf)
 989 {
 990         struct file *f = get_empty_filp();
 991         if (!f)
 992                 return ERR_PTR(-ENFILE);
 993
 994         /* Grab pipe from the writer */
 995         f->f_vfsmnt = mntget(wrf->f_vfsmnt);
 996         f->f_dentry = dget(wrf->f_dentry);
 997         f->f_mapping = wrf->f_dentry->d_inode->i_mapping;
 998
 999         f->f_pos = 0;
1000         f->f_flags = O_RDONLY;
1001         f->f_op = &read_pipe_fops;
1002         f->f_mode = FMODE_READ;
1003         f->f_version = 0;
1004
1005         return f;
1006 }
1007
1008 int do_pipe(int *fd)
1009 {
1010         struct file *fw, *fr;
1011         int error;
1012         int fdw, fdr;
1013
1014         fw = create_write_pipe();
1015         if (IS_ERR(fw))
1016                 return PTR_ERR(fw);
1017         fr = create_read_pipe(fw);
1018         error = PTR_ERR(fr);
1019         if (IS_ERR(fr))
1020                 goto err_write_pipe;
1021
1022         error = get_unused_fd();
1023         if (error < 0)
1024                 goto err_read_pipe;
1025         fdr = error;
1026
1027         error = get_unused_fd();
1028         if (error < 0)
1029                 goto err_fdr;
1030         fdw = error;
1031
1032         fd_install(fdr, fr);
1033         fd_install(fdw, fw);
1034         fd[0] = fdr;
1035         fd[1] = fdw;
1036
1037         return 0;
1038
1039  err_fdr:
1040         put_unused_fd(fdr);
1041  err_read_pipe:
1042         put_filp(fr);
1043  err_write_pipe:
1044         free_write_pipe(fw);
1045         return error;
1046 }
1047
1048 /*
1049  * pipefs should _never_ be mounted by userland - too much of security hassle,
1050  * no real gain from having the whole whorehouse mounted. So we don't need
1051  * any operations on the root directory. However, we need a non-trivial
1052  * d_name - pipe: will go nicely and kill the special-casing in procfs.
1053  */
1054 static int pipefs_get_sb(struct file_system_type *fs_type,
1055                          int flags, const char *dev_name, void *data,
1056                          struct vfsmount *mnt)
1057 {
1058         return get_sb_pseudo(fs_type, "pipe:", NULL, PIPEFS_MAGIC, mnt);
1059 }
1060
1061 static struct file_system_type pipe_fs_type = {
1062         .name           = "pipefs",
1063         .get_sb         = pipefs_get_sb,
1064         .kill_sb        = kill_anon_super,
1065 };
1066
1067 static int __init init_pipe_fs(void)
1068 {
1069         int err = register_filesystem(&pipe_fs_type);
1070
1071         if (!err) {
1072                 pipe_mnt = kern_mount(&pipe_fs_type);
1073                 if (IS_ERR(pipe_mnt)) {
1074                         err = PTR_ERR(pipe_mnt);
1075                         unregister_filesystem(&pipe_fs_type);
1076                 }
1077         }
1078         return err;
1079 }
1080
1081 static void __exit exit_pipe_fs(void)
1082 {
1083         unregister_filesystem(&pipe_fs_type);
1084         mntput(pipe_mnt);
1085 }
1086
1087 fs_initcall(init_pipe_fs);
1088 module_exit(exit_pipe_fs);