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