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