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