pipe.c 22 KB

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