LCOV - code coverage report
Current view: top level - fs - pipe.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 272 422 64.5 %
Date: 2020-09-30 20:25:40 Functions: 21 38 55.3 %
Branches: 146 385 37.9 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  *  linux/fs/pipe.c
       4                 :            :  *
       5                 :            :  *  Copyright (C) 1991, 1992, 1999  Linus Torvalds
       6                 :            :  */
       7                 :            : 
       8                 :            : #include <linux/mm.h>
       9                 :            : #include <linux/file.h>
      10                 :            : #include <linux/poll.h>
      11                 :            : #include <linux/slab.h>
      12                 :            : #include <linux/module.h>
      13                 :            : #include <linux/init.h>
      14                 :            : #include <linux/fs.h>
      15                 :            : #include <linux/log2.h>
      16                 :            : #include <linux/mount.h>
      17                 :            : #include <linux/pseudo_fs.h>
      18                 :            : #include <linux/magic.h>
      19                 :            : #include <linux/pipe_fs_i.h>
      20                 :            : #include <linux/uio.h>
      21                 :            : #include <linux/highmem.h>
      22                 :            : #include <linux/pagemap.h>
      23                 :            : #include <linux/audit.h>
      24                 :            : #include <linux/syscalls.h>
      25                 :            : #include <linux/fcntl.h>
      26                 :            : #include <linux/memcontrol.h>
      27                 :            : 
      28                 :            : #include <linux/uaccess.h>
      29                 :            : #include <asm/ioctls.h>
      30                 :            : 
      31                 :            : #include "internal.h"
      32                 :            : 
      33                 :            : /*
      34                 :            :  * The max size that a non-root user is allowed to grow the pipe. Can
      35                 :            :  * be set by root in /proc/sys/fs/pipe-max-size
      36                 :            :  */
      37                 :            : unsigned int pipe_max_size = 1048576;
      38                 :            : 
      39                 :            : /* Maximum allocatable pages per user. Hard limit is unset by default, soft
      40                 :            :  * matches default values.
      41                 :            :  */
      42                 :            : unsigned long pipe_user_pages_hard;
      43                 :            : unsigned long pipe_user_pages_soft = PIPE_DEF_BUFFERS * INR_OPEN_CUR;
      44                 :            : 
      45                 :            : /*
      46                 :            :  * We use a start+len construction, which provides full use of the 
      47                 :            :  * allocated memory.
      48                 :            :  * -- Florian Coosmann (FGC)
      49                 :            :  * 
      50                 :            :  * Reads with count = 0 should always return 0.
      51                 :            :  * -- Julian Bradfield 1999-06-07.
      52                 :            :  *
      53                 :            :  * FIFOs and Pipes now generate SIGIO for both readers and writers.
      54                 :            :  * -- Jeremy Elson <jelson@circlemud.org> 2001-08-16
      55                 :            :  *
      56                 :            :  * pipe_read & write cleanup
      57                 :            :  * -- Manfred Spraul <manfred@colorfullife.com> 2002-05-09
      58                 :            :  */
      59                 :            : 
      60                 :            : static void pipe_lock_nested(struct pipe_inode_info *pipe, int subclass)
      61                 :            : {
      62   [ +  -  #  #  :      71936 :         if (pipe->files)
          #  #  #  #  #  
                #  #  # ]
      63                 :      71939 :                 mutex_lock_nested(&pipe->mutex, subclass);
      64                 :            : }
      65                 :            : 
      66                 :          0 : void pipe_lock(struct pipe_inode_info *pipe)
      67                 :            : {
      68                 :            :         /*
      69                 :            :          * pipe_lock() nests non-pipe inode locks (for writing to a file)
      70                 :            :          */
      71                 :            :         pipe_lock_nested(pipe, I_MUTEX_PARENT);
      72                 :          0 : }
      73                 :            : EXPORT_SYMBOL(pipe_lock);
      74                 :            : 
      75                 :          0 : void pipe_unlock(struct pipe_inode_info *pipe)
      76                 :            : {
      77   [ +  -  #  # ]:      71941 :         if (pipe->files)
      78                 :      71941 :                 mutex_unlock(&pipe->mutex);
      79                 :          0 : }
      80                 :            : EXPORT_SYMBOL(pipe_unlock);
      81                 :            : 
      82                 :            : static inline void __pipe_lock(struct pipe_inode_info *pipe)
      83                 :            : {
      84                 :    1003672 :         mutex_lock_nested(&pipe->mutex, I_MUTEX_PARENT);
      85                 :            : }
      86                 :            : 
      87                 :            : static inline void __pipe_unlock(struct pipe_inode_info *pipe)
      88                 :            : {
      89                 :    1003753 :         mutex_unlock(&pipe->mutex);
      90                 :            : }
      91                 :            : 
      92                 :          0 : void pipe_double_lock(struct pipe_inode_info *pipe1,
      93                 :            :                       struct pipe_inode_info *pipe2)
      94                 :            : {
      95         [ #  # ]:          0 :         BUG_ON(pipe1 == pipe2);
      96                 :            : 
      97         [ #  # ]:          0 :         if (pipe1 < pipe2) {
      98                 :            :                 pipe_lock_nested(pipe1, I_MUTEX_PARENT);
      99                 :            :                 pipe_lock_nested(pipe2, I_MUTEX_CHILD);
     100                 :            :         } else {
     101                 :            :                 pipe_lock_nested(pipe2, I_MUTEX_PARENT);
     102                 :            :                 pipe_lock_nested(pipe1, I_MUTEX_CHILD);
     103                 :            :         }
     104                 :          0 : }
     105                 :            : 
     106                 :            : /* Drop the inode semaphore and wait for a pipe event, atomically */
     107                 :      71939 : void pipe_wait(struct pipe_inode_info *pipe)
     108                 :            : {
     109                 :     143878 :         DEFINE_WAIT(wait);
     110                 :            : 
     111                 :            :         /*
     112                 :            :          * Pipes are system-local resources, so sleeping on them
     113                 :            :          * is considered a noninteractive wait:
     114                 :            :          */
     115                 :      71939 :         prepare_to_wait(&pipe->wait, &wait, TASK_INTERRUPTIBLE);
     116                 :            :         pipe_unlock(pipe);
     117                 :      71941 :         schedule();
     118                 :      71934 :         finish_wait(&pipe->wait, &wait);
     119                 :            :         pipe_lock(pipe);
     120                 :      71936 : }
     121                 :            : 
     122                 :      97628 : static void anon_pipe_buf_release(struct pipe_inode_info *pipe,
     123                 :            :                                   struct pipe_buffer *buf)
     124                 :            : {
     125                 :      97628 :         struct page *page = buf->page;
     126                 :            : 
     127                 :            :         /*
     128                 :            :          * If nobody else uses this page, and we don't already have a
     129                 :            :          * temporary page, let's keep track of it as a one-deep
     130                 :            :          * allocation cache. (Otherwise just release our reference to it)
     131                 :            :          */
     132   [ +  -  +  + ]:      97628 :         if (page_count(page) == 1 && !pipe->tmp_page)
     133                 :      93420 :                 pipe->tmp_page = page;
     134                 :            :         else
     135                 :       4208 :                 put_page(page);
     136                 :      97633 : }
     137                 :            : 
     138                 :          0 : static int anon_pipe_buf_steal(struct pipe_inode_info *pipe,
     139                 :            :                                struct pipe_buffer *buf)
     140                 :            : {
     141                 :          0 :         struct page *page = buf->page;
     142                 :            : 
     143         [ #  # ]:          0 :         if (page_count(page) == 1) {
     144                 :          0 :                 memcg_kmem_uncharge(page, 0);
     145                 :            :                 __SetPageLocked(page);
     146                 :          0 :                 return 0;
     147                 :            :         }
     148                 :            :         return 1;
     149                 :            : }
     150                 :            : 
     151                 :            : /**
     152                 :            :  * generic_pipe_buf_steal - attempt to take ownership of a &pipe_buffer
     153                 :            :  * @pipe:       the pipe that the buffer belongs to
     154                 :            :  * @buf:        the buffer to attempt to steal
     155                 :            :  *
     156                 :            :  * Description:
     157                 :            :  *      This function attempts to steal the &struct page attached to
     158                 :            :  *      @buf. If successful, this function returns 0 and returns with
     159                 :            :  *      the page locked. The caller may then reuse the page for whatever
     160                 :            :  *      he wishes; the typical use is insertion into a different file
     161                 :            :  *      page cache.
     162                 :            :  */
     163                 :          0 : int generic_pipe_buf_steal(struct pipe_inode_info *pipe,
     164                 :            :                            struct pipe_buffer *buf)
     165                 :            : {
     166                 :          0 :         struct page *page = buf->page;
     167                 :            : 
     168                 :            :         /*
     169                 :            :          * A reference of one is golden, that means that the owner of this
     170                 :            :          * page is the only one holding a reference to it. lock the page
     171                 :            :          * and return OK.
     172                 :            :          */
     173         [ #  # ]:          0 :         if (page_count(page) == 1) {
     174                 :          0 :                 lock_page(page);
     175                 :          0 :                 return 0;
     176                 :            :         }
     177                 :            : 
     178                 :            :         return 1;
     179                 :            : }
     180                 :            : EXPORT_SYMBOL(generic_pipe_buf_steal);
     181                 :            : 
     182                 :            : /**
     183                 :            :  * generic_pipe_buf_get - get a reference to a &struct pipe_buffer
     184                 :            :  * @pipe:       the pipe that the buffer belongs to
     185                 :            :  * @buf:        the buffer to get a reference to
     186                 :            :  *
     187                 :            :  * Description:
     188                 :            :  *      This function grabs an extra reference to @buf. It's used in
     189                 :            :  *      in the tee() system call, when we duplicate the buffers in one
     190                 :            :  *      pipe into another.
     191                 :            :  */
     192                 :          0 : bool generic_pipe_buf_get(struct pipe_inode_info *pipe, struct pipe_buffer *buf)
     193                 :            : {
     194                 :          0 :         return try_get_page(buf->page);
     195                 :            : }
     196                 :            : EXPORT_SYMBOL(generic_pipe_buf_get);
     197                 :            : 
     198                 :            : /**
     199                 :            :  * generic_pipe_buf_confirm - verify contents of the pipe buffer
     200                 :            :  * @info:       the pipe that the buffer belongs to
     201                 :            :  * @buf:        the buffer to confirm
     202                 :            :  *
     203                 :            :  * Description:
     204                 :            :  *      This function does nothing, because the generic pipe code uses
     205                 :            :  *      pages that are always good when inserted into the pipe.
     206                 :            :  */
     207                 :     255843 : int generic_pipe_buf_confirm(struct pipe_inode_info *info,
     208                 :            :                              struct pipe_buffer *buf)
     209                 :            : {
     210                 :     255843 :         return 0;
     211                 :            : }
     212                 :            : EXPORT_SYMBOL(generic_pipe_buf_confirm);
     213                 :            : 
     214                 :            : /**
     215                 :            :  * generic_pipe_buf_release - put a reference to a &struct pipe_buffer
     216                 :            :  * @pipe:       the pipe that the buffer belongs to
     217                 :            :  * @buf:        the buffer to put a reference to
     218                 :            :  *
     219                 :            :  * Description:
     220                 :            :  *      This function releases a reference to @buf.
     221                 :            :  */
     222                 :          0 : void generic_pipe_buf_release(struct pipe_inode_info *pipe,
     223                 :            :                               struct pipe_buffer *buf)
     224                 :            : {
     225                 :          0 :         put_page(buf->page);
     226                 :          0 : }
     227                 :            : EXPORT_SYMBOL(generic_pipe_buf_release);
     228                 :            : 
     229                 :            : /* New data written to a pipe may be appended to a buffer with this type. */
     230                 :            : static const struct pipe_buf_operations anon_pipe_buf_ops = {
     231                 :            :         .confirm = generic_pipe_buf_confirm,
     232                 :            :         .release = anon_pipe_buf_release,
     233                 :            :         .steal = anon_pipe_buf_steal,
     234                 :            :         .get = generic_pipe_buf_get,
     235                 :            : };
     236                 :            : 
     237                 :            : static const struct pipe_buf_operations anon_pipe_buf_nomerge_ops = {
     238                 :            :         .confirm = generic_pipe_buf_confirm,
     239                 :            :         .release = anon_pipe_buf_release,
     240                 :            :         .steal = anon_pipe_buf_steal,
     241                 :            :         .get = generic_pipe_buf_get,
     242                 :            : };
     243                 :            : 
     244                 :            : static const struct pipe_buf_operations packet_pipe_buf_ops = {
     245                 :            :         .confirm = generic_pipe_buf_confirm,
     246                 :            :         .release = anon_pipe_buf_release,
     247                 :            :         .steal = anon_pipe_buf_steal,
     248                 :            :         .get = generic_pipe_buf_get,
     249                 :            : };
     250                 :            : 
     251                 :            : /**
     252                 :            :  * pipe_buf_mark_unmergeable - mark a &struct pipe_buffer as unmergeable
     253                 :            :  * @buf:        the buffer to mark
     254                 :            :  *
     255                 :            :  * Description:
     256                 :            :  *      This function ensures that no future writes will be merged into the
     257                 :            :  *      given &struct pipe_buffer. This is necessary when multiple pipe buffers
     258                 :            :  *      share the same backing page.
     259                 :            :  */
     260                 :          0 : void pipe_buf_mark_unmergeable(struct pipe_buffer *buf)
     261                 :            : {
     262         [ #  # ]:          0 :         if (buf->ops == &anon_pipe_buf_ops)
     263                 :          0 :                 buf->ops = &anon_pipe_buf_nomerge_ops;
     264                 :          0 : }
     265                 :            : 
     266                 :            : static bool pipe_buf_can_merge(struct pipe_buffer *buf)
     267                 :            : {
     268                 :      85198 :         return buf->ops == &anon_pipe_buf_ops;
     269                 :            : }
     270                 :            : 
     271                 :            : static ssize_t
     272                 :     685162 : pipe_read(struct kiocb *iocb, struct iov_iter *to)
     273                 :            : {
     274                 :            :         size_t total_len = iov_iter_count(to);
     275                 :     685162 :         struct file *filp = iocb->ki_filp;
     276                 :     685162 :         struct pipe_inode_info *pipe = filp->private_data;
     277                 :            :         int do_wakeup;
     278                 :            :         ssize_t ret;
     279                 :            : 
     280                 :            :         /* Null read succeeds. */
     281         [ +  + ]:     685162 :         if (unlikely(total_len == 0))
     282                 :            :                 return 0;
     283                 :            : 
     284                 :            :         do_wakeup = 0;
     285                 :            :         ret = 0;
     286                 :            :         __pipe_lock(pipe);
     287                 :            :         for (;;) {
     288                 :     754476 :                 int bufs = pipe->nrbufs;
     289         [ +  + ]:     754476 :                 if (bufs) {
     290                 :     170853 :                         int curbuf = pipe->curbuf;
     291                 :     170853 :                         struct pipe_buffer *buf = pipe->bufs + curbuf;
     292                 :     170853 :                         size_t chars = buf->len;
     293                 :            :                         size_t written;
     294                 :            :                         int error;
     295                 :            : 
     296         [ +  + ]:     170853 :                         if (chars > total_len)
     297                 :            :                                 chars = total_len;
     298                 :            : 
     299                 :            :                         error = pipe_buf_confirm(pipe, buf);
     300         [ -  + ]:     170852 :                         if (error) {
     301         [ #  # ]:          0 :                                 if (!ret)
     302                 :          0 :                                         ret = error;
     303                 :            :                                 break;
     304                 :            :                         }
     305                 :            : 
     306                 :     170852 :                         written = copy_page_to_iter(buf->page, buf->offset, chars, to);
     307         [ -  + ]:     170854 :                         if (unlikely(written < chars)) {
     308         [ #  # ]:          0 :                                 if (!ret)
     309                 :            :                                         ret = -EFAULT;
     310                 :            :                                 break;
     311                 :            :                         }
     312                 :     170854 :                         ret += chars;
     313                 :     170854 :                         buf->offset += chars;
     314                 :     170854 :                         buf->len -= chars;
     315                 :            : 
     316                 :            :                         /* Was it a packet buffer? Clean up and exit */
     317         [ -  + ]:     170854 :                         if (buf->flags & PIPE_BUF_FLAG_PACKET) {
     318                 :            :                                 total_len = chars;
     319                 :          0 :                                 buf->len = 0;
     320                 :            :                         }
     321                 :            : 
     322         [ +  + ]:     170854 :                         if (!buf->len) {
     323                 :            :                                 pipe_buf_release(pipe, buf);
     324                 :      97210 :                                 curbuf = (curbuf + 1) & (pipe->buffers - 1);
     325                 :      97210 :                                 pipe->curbuf = curbuf;
     326                 :      97210 :                                 pipe->nrbufs = --bufs;
     327                 :            :                                 do_wakeup = 1;
     328                 :            :                         }
     329                 :     170851 :                         total_len -= chars;
     330         [ +  + ]:     170851 :                         if (!total_len)
     331                 :            :                                 break;  /* common path: read succeeded */
     332                 :            :                 }
     333         [ +  + ]:     669681 :                 if (bufs)       /* More to do? */
     334                 :          5 :                         continue;
     335         [ +  + ]:     669676 :                 if (!pipe->writers)
     336                 :            :                         break;
     337         [ +  + ]:     149263 :                 if (!pipe->waiting_writers) {
     338                 :            :                         /* syscall merging: Usually we must not sleep
     339                 :            :                          * if O_NONBLOCK is set, or if we got some data.
     340                 :            :                          * But if a writer sleeps in kernel space, then
     341                 :            :                          * we can wait for that data without violating POSIX.
     342                 :            :                          */
     343         [ +  + ]:     149273 :                         if (ret)
     344                 :            :                                 break;
     345         [ +  + ]:      70385 :                         if (filp->f_flags & O_NONBLOCK) {
     346                 :            :                                 ret = -EAGAIN;
     347                 :            :                                 break;
     348                 :            :                         }
     349                 :            :                 }
     350         [ +  + ]:     140700 :                 if (signal_pending(current)) {
     351         [ +  - ]:         24 :                         if (!ret)
     352                 :            :                                 ret = -ERESTARTSYS;
     353                 :            :                         break;
     354                 :            :                 }
     355         [ -  + ]:      70326 :                 if (do_wakeup) {
     356                 :          0 :                         wake_up_interruptible_sync_poll(&pipe->wait, EPOLLOUT | EPOLLWRNORM);
     357                 :          0 :                         kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
     358                 :            :                 }
     359                 :      70326 :                 pipe_wait(pipe);
     360                 :            :         }
     361                 :            :         __pipe_unlock(pipe);
     362                 :            : 
     363                 :            :         /* Signal writers asynchronously that there is more room. */
     364         [ +  + ]:     684146 :         if (do_wakeup) {
     365                 :      97210 :                 wake_up_interruptible_sync_poll(&pipe->wait, EPOLLOUT | EPOLLWRNORM);
     366                 :      97216 :                 kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
     367                 :            :         }
     368         [ +  + ]:     684138 :         if (ret > 0)
     369                 :            :                 file_accessed(filp);
     370                 :     684137 :         return ret;
     371                 :            : }
     372                 :            : 
     373                 :            : static inline int is_packetized(struct file *file)
     374                 :            : {
     375                 :      97626 :         return (file->f_flags & O_DIRECT) != 0;
     376                 :            : }
     377                 :            : 
     378                 :            : static ssize_t
     379                 :     177238 : pipe_write(struct kiocb *iocb, struct iov_iter *from)
     380                 :            : {
     381                 :     177238 :         struct file *filp = iocb->ki_filp;
     382                 :     177238 :         struct pipe_inode_info *pipe = filp->private_data;
     383                 :            :         ssize_t ret = 0;
     384                 :            :         int do_wakeup = 0;
     385                 :            :         size_t total_len = iov_iter_count(from);
     386                 :            :         ssize_t chars;
     387                 :            : 
     388                 :            :         /* Null write succeeds. */
     389         [ +  + ]:     177238 :         if (unlikely(total_len == 0))
     390                 :            :                 return 0;
     391                 :            : 
     392                 :            :         __pipe_lock(pipe);
     393                 :            : 
     394         [ -  + ]:     177239 :         if (!pipe->readers) {
     395                 :          0 :                 send_sig(SIGPIPE, current, 0);
     396                 :            :                 ret = -EPIPE;
     397                 :          0 :                 goto out;
     398                 :            :         }
     399                 :            : 
     400                 :            :         /* We try to merge small writes */
     401                 :     177239 :         chars = total_len & (PAGE_SIZE-1); /* size of the last buffer */
     402   [ +  +  +  + ]:     177239 :         if (pipe->nrbufs && chars != 0) {
     403                 :     170396 :                 int lastbuf = (pipe->curbuf + pipe->nrbufs - 1) &
     404                 :      85198 :                                                         (pipe->buffers - 1);
     405                 :      85198 :                 struct pipe_buffer *buf = pipe->bufs + lastbuf;
     406                 :      85198 :                 int offset = buf->offset + buf->len;
     407                 :            : 
     408   [ +  -  +  + ]:      85198 :                 if (pipe_buf_can_merge(buf) && offset + chars <= PAGE_SIZE) {
     409                 :            :                         ret = pipe_buf_confirm(pipe, buf);
     410         [ +  - ]:      84986 :                         if (ret)
     411                 :            :                                 goto out;
     412                 :            : 
     413                 :      84986 :                         ret = copy_page_from_iter(buf->page, offset, chars, from);
     414         [ +  - ]:      84987 :                         if (unlikely(ret < chars)) {
     415                 :            :                                 ret = -EFAULT;
     416                 :            :                                 goto out;
     417                 :            :                         }
     418                 :            :                         do_wakeup = 1;
     419                 :      84987 :                         buf->len += ret;
     420         [ -  + ]:      84987 :                         if (!iov_iter_count(from))
     421                 :            :                                 goto out;
     422                 :            :                 }
     423                 :            :         }
     424                 :            : 
     425                 :            :         for (;;) {
     426                 :            :                 int bufs;
     427                 :            : 
     428         [ -  + ]:      97850 :                 if (!pipe->readers) {
     429                 :          0 :                         send_sig(SIGPIPE, current, 0);
     430         [ #  # ]:          0 :                         if (!ret)
     431                 :            :                                 ret = -EPIPE;
     432                 :            :                         break;
     433                 :            :                 }
     434                 :      97850 :                 bufs = pipe->nrbufs;
     435         [ +  + ]:      97850 :                 if (bufs < pipe->buffers) {
     436                 :      97607 :                         int newbuf = (pipe->curbuf + bufs) & (pipe->buffers-1);
     437                 :      97607 :                         struct pipe_buffer *buf = pipe->bufs + newbuf;
     438                 :      97607 :                         struct page *page = pipe->tmp_page;
     439                 :            :                         int copied;
     440                 :            : 
     441         [ +  + ]:      97607 :                         if (!page) {
     442                 :            :                                 page = alloc_page(GFP_HIGHUSER | __GFP_ACCOUNT);
     443         [ -  + ]:      48224 :                                 if (unlikely(!page)) {
     444         [ #  # ]:          0 :                                         ret = ret ? : -ENOMEM;
     445                 :          0 :                                         break;
     446                 :            :                                 }
     447                 :      48224 :                                 pipe->tmp_page = page;
     448                 :            :                         }
     449                 :            :                         /* Always wake up, even if the copy fails. Otherwise
     450                 :            :                          * we lock up (O_NONBLOCK-)readers that sleep due to
     451                 :            :                          * syscall merging.
     452                 :            :                          * FIXME! Is this really true?
     453                 :            :                          */
     454                 :            :                         do_wakeup = 1;
     455                 :      97623 :                         copied = copy_page_from_iter(page, 0, PAGE_SIZE, from);
     456   [ +  +  -  + ]:     189221 :                         if (unlikely(copied < PAGE_SIZE && iov_iter_count(from))) {
     457         [ #  # ]:          0 :                                 if (!ret)
     458                 :            :                                         ret = -EFAULT;
     459                 :            :                                 break;
     460                 :            :                         }
     461                 :      97626 :                         ret += copied;
     462                 :            : 
     463                 :            :                         /* Insert it into the buffer array */
     464                 :      97626 :                         buf->page = page;
     465                 :      97626 :                         buf->ops = &anon_pipe_buf_ops;
     466                 :      97626 :                         buf->offset = 0;
     467                 :      97626 :                         buf->len = copied;
     468                 :      97626 :                         buf->flags = 0;
     469         [ -  + ]:      97626 :                         if (is_packetized(filp)) {
     470                 :          0 :                                 buf->ops = &packet_pipe_buf_ops;
     471                 :          0 :                                 buf->flags = PIPE_BUF_FLAG_PACKET;
     472                 :            :                         }
     473                 :      97626 :                         pipe->nrbufs = ++bufs;
     474                 :      97626 :                         pipe->tmp_page = NULL;
     475                 :            : 
     476         [ +  + ]:      97626 :                         if (!iov_iter_count(from))
     477                 :            :                                 break;
     478                 :            :                 }
     479         [ +  + ]:       5608 :                 if (bufs < pipe->buffers)
     480                 :       4001 :                         continue;
     481         [ -  + ]:       1607 :                 if (filp->f_flags & O_NONBLOCK) {
     482         [ #  # ]:          0 :                         if (!ret)
     483                 :            :                                 ret = -EAGAIN;
     484                 :            :                         break;
     485                 :            :                 }
     486         [ -  + ]:       3214 :                 if (signal_pending(current)) {
     487         [ #  # ]:          0 :                         if (!ret)
     488                 :            :                                 ret = -ERESTARTSYS;
     489                 :            :                         break;
     490                 :            :                 }
     491         [ +  + ]:       1607 :                 if (do_wakeup) {
     492                 :       1381 :                         wake_up_interruptible_sync_poll(&pipe->wait, EPOLLIN | EPOLLRDNORM);
     493                 :       1381 :                         kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
     494                 :            :                         do_wakeup = 0;
     495                 :            :                 }
     496                 :       1607 :                 pipe->waiting_writers++;
     497                 :       1607 :                 pipe_wait(pipe);
     498                 :       1607 :                 pipe->waiting_writers--;
     499                 :            :         }
     500                 :            : out:
     501                 :            :         __pipe_unlock(pipe);
     502         [ +  + ]:     177237 :         if (do_wakeup) {
     503                 :     177230 :                 wake_up_interruptible_sync_poll(&pipe->wait, EPOLLIN | EPOLLRDNORM);
     504                 :     177240 :                 kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
     505                 :            :         }
     506   [ +  +  +  + ]:     531707 :         if (ret > 0 && sb_start_write_trylock(file_inode(filp)->i_sb)) {
     507                 :     177230 :                 int err = file_update_time(filp);
     508         [ -  + ]:     177227 :                 if (err)
     509                 :            :                         ret = err;
     510                 :     177227 :                 sb_end_write(file_inode(filp)->i_sb);
     511                 :            :         }
     512                 :     177239 :         return ret;
     513                 :            : }
     514                 :            : 
     515                 :       5644 : static long pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
     516                 :            : {
     517                 :       5644 :         struct pipe_inode_info *pipe = filp->private_data;
     518                 :            :         int count, buf, nrbufs;
     519                 :            : 
     520         [ -  + ]:       5644 :         switch (cmd) {
     521                 :            :                 case FIONREAD:
     522                 :            :                         __pipe_lock(pipe);
     523                 :            :                         count = 0;
     524                 :          0 :                         buf = pipe->curbuf;
     525                 :          0 :                         nrbufs = pipe->nrbufs;
     526         [ #  # ]:          0 :                         while (--nrbufs >= 0) {
     527                 :          0 :                                 count += pipe->bufs[buf].len;
     528                 :          0 :                                 buf = (buf+1) & (pipe->buffers - 1);
     529                 :            :                         }
     530                 :            :                         __pipe_unlock(pipe);
     531                 :            : 
     532                 :          0 :                         return put_user(count, (int __user *)arg);
     533                 :            :                 default:
     534                 :            :                         return -ENOIOCTLCMD;
     535                 :            :         }
     536                 :            : }
     537                 :            : 
     538                 :            : /* No kernel lock held - fine */
     539                 :            : static __poll_t
     540                 :     715350 : pipe_poll(struct file *filp, poll_table *wait)
     541                 :            : {
     542                 :            :         __poll_t mask;
     543                 :     715350 :         struct pipe_inode_info *pipe = filp->private_data;
     544                 :            :         int nrbufs;
     545                 :            : 
     546                 :     715350 :         poll_wait(filp, &pipe->wait, wait);
     547                 :            : 
     548                 :            :         /* Reading only -- no need for acquiring the semaphore.  */
     549                 :     715389 :         nrbufs = pipe->nrbufs;
     550                 :            :         mask = 0;
     551         [ +  + ]:     715389 :         if (filp->f_mode & FMODE_READ) {
     552         [ +  + ]:     715389 :                 mask = (nrbufs > 0) ? EPOLLIN | EPOLLRDNORM : 0;
     553   [ +  +  +  + ]:     715389 :                 if (!pipe->writers && filp->f_version != pipe->w_counter)
     554                 :     510318 :                         mask |= EPOLLHUP;
     555                 :            :         }
     556                 :            : 
     557         [ +  + ]:     715389 :         if (filp->f_mode & FMODE_WRITE) {
     558         [ -  + ]:        207 :                 mask |= (nrbufs < pipe->buffers) ? EPOLLOUT | EPOLLWRNORM : 0;
     559                 :            :                 /*
     560                 :            :                  * Most Unices do not set EPOLLERR for FIFOs but on Linux they
     561                 :            :                  * behave exactly like pipes for poll().
     562                 :            :                  */
     563         [ -  + ]:        207 :                 if (!pipe->readers)
     564                 :          0 :                         mask |= EPOLLERR;
     565                 :            :         }
     566                 :            : 
     567                 :     715389 :         return mask;
     568                 :            : }
     569                 :            : 
     570                 :     141320 : static void put_pipe_info(struct inode *inode, struct pipe_inode_info *pipe)
     571                 :            : {
     572                 :            :         int kill = 0;
     573                 :            : 
     574                 :            :         spin_lock(&inode->i_lock);
     575         [ +  + ]:     141320 :         if (!--pipe->files) {
     576                 :      70451 :                 inode->i_pipe = NULL;
     577                 :            :                 kill = 1;
     578                 :            :         }
     579                 :            :         spin_unlock(&inode->i_lock);
     580                 :            : 
     581         [ +  + ]:     141304 :         if (kill)
     582                 :      70452 :                 free_pipe_info(pipe);
     583                 :     141305 : }
     584                 :            : 
     585                 :            : static int
     586                 :     141319 : pipe_release(struct inode *inode, struct file *file)
     587                 :            : {
     588                 :     141319 :         struct pipe_inode_info *pipe = file->private_data;
     589                 :            : 
     590                 :            :         __pipe_lock(pipe);
     591         [ +  + ]:     141316 :         if (file->f_mode & FMODE_READ)
     592                 :      70658 :                 pipe->readers--;
     593         [ +  + ]:     141316 :         if (file->f_mode & FMODE_WRITE)
     594                 :      70652 :                 pipe->writers--;
     595                 :            : 
     596   [ +  +  +  + ]:     141316 :         if (pipe->readers || pipe->writers) {
     597                 :      70866 :                 wake_up_interruptible_sync_poll(&pipe->wait, EPOLLIN | EPOLLOUT | EPOLLRDNORM | EPOLLWRNORM | EPOLLERR | EPOLLHUP);
     598                 :      70867 :                 kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
     599                 :      70867 :                 kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
     600                 :            :         }
     601                 :            :         __pipe_unlock(pipe);
     602                 :            : 
     603                 :     141302 :         put_pipe_info(inode, pipe);
     604                 :     141319 :         return 0;
     605                 :            : }
     606                 :            : 
     607                 :            : static int
     608                 :          0 : pipe_fasync(int fd, struct file *filp, int on)
     609                 :            : {
     610                 :          0 :         struct pipe_inode_info *pipe = filp->private_data;
     611                 :            :         int retval = 0;
     612                 :            : 
     613                 :            :         __pipe_lock(pipe);
     614         [ #  # ]:          0 :         if (filp->f_mode & FMODE_READ)
     615                 :          0 :                 retval = fasync_helper(fd, filp, on, &pipe->fasync_readers);
     616   [ #  #  #  # ]:          0 :         if ((filp->f_mode & FMODE_WRITE) && retval >= 0) {
     617                 :          0 :                 retval = fasync_helper(fd, filp, on, &pipe->fasync_writers);
     618   [ #  #  #  # ]:          0 :                 if (retval < 0 && (filp->f_mode & FMODE_READ))
     619                 :            :                         /* this can happen only if on == T */
     620                 :          0 :                         fasync_helper(-1, filp, 0, &pipe->fasync_readers);
     621                 :            :         }
     622                 :            :         __pipe_unlock(pipe);
     623                 :          0 :         return retval;
     624                 :            : }
     625                 :            : 
     626                 :      70453 : static unsigned long account_pipe_buffers(struct user_struct *user,
     627                 :            :                                  unsigned long old, unsigned long new)
     628                 :            : {
     629                 :     288818 :         return atomic_long_add_return(new - old, &user->pipe_bufs);
     630                 :            : }
     631                 :            : 
     632                 :            : static bool too_many_pipe_buffers_soft(unsigned long user_bufs)
     633                 :            : {
     634                 :            :         unsigned long soft_limit = READ_ONCE(pipe_user_pages_soft);
     635                 :            : 
     636                 :      73961 :         return soft_limit && user_bufs > soft_limit;
     637                 :            : }
     638                 :            : 
     639                 :            : static bool too_many_pipe_buffers_hard(unsigned long user_bufs)
     640                 :            : {
     641                 :            :         unsigned long hard_limit = READ_ONCE(pipe_user_pages_hard);
     642                 :            : 
     643                 :      73961 :         return hard_limit && user_bufs > hard_limit;
     644                 :            : }
     645                 :            : 
     646                 :          0 : static bool is_unprivileged_user(void)
     647                 :            : {
     648   [ #  #  #  # ]:          0 :         return !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN);
     649                 :            : }
     650                 :            : 
     651                 :      73964 : struct pipe_inode_info *alloc_pipe_info(void)
     652                 :            : {
     653                 :            :         struct pipe_inode_info *pipe;
     654                 :            :         unsigned long pipe_bufs = PIPE_DEF_BUFFERS;
     655                 :      73964 :         struct user_struct *user = get_current_user();
     656                 :            :         unsigned long user_bufs;
     657                 :            :         unsigned int max_size = READ_ONCE(pipe_max_size);
     658                 :            : 
     659                 :      73961 :         pipe = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL_ACCOUNT);
     660         [ +  + ]:      73964 :         if (pipe == NULL)
     661                 :            :                 goto out_free_uid;
     662                 :            : 
     663   [ -  +  #  # ]:      73962 :         if (pipe_bufs * PAGE_SIZE > max_size && !capable(CAP_SYS_RESOURCE))
     664                 :          0 :                 pipe_bufs = max_size >> PAGE_SHIFT;
     665                 :            : 
     666                 :            :         user_bufs = account_pipe_buffers(user, 0, pipe_bufs);
     667                 :            : 
     668   [ -  +  #  # ]:      73961 :         if (too_many_pipe_buffers_soft(user_bufs) && is_unprivileged_user()) {
     669                 :            :                 user_bufs = account_pipe_buffers(user, pipe_bufs, 1);
     670                 :            :                 pipe_bufs = 1;
     671                 :            :         }
     672                 :            : 
     673   [ -  +  #  # ]:      73961 :         if (too_many_pipe_buffers_hard(user_bufs) && is_unprivileged_user())
     674                 :            :                 goto out_revert_acct;
     675                 :            : 
     676                 :      73960 :         pipe->bufs = kcalloc(pipe_bufs, sizeof(struct pipe_buffer),
     677                 :            :                              GFP_KERNEL_ACCOUNT);
     678                 :            : 
     679         [ +  - ]:      73960 :         if (pipe->bufs) {
     680                 :      73962 :                 init_waitqueue_head(&pipe->wait);
     681                 :      73959 :                 pipe->r_counter = pipe->w_counter = 1;
     682                 :      73959 :                 pipe->buffers = pipe_bufs;
     683                 :      73959 :                 pipe->user = user;
     684                 :      73959 :                 mutex_init(&pipe->mutex);
     685                 :      73965 :                 return pipe;
     686                 :            :         }
     687                 :            : 
     688                 :            : out_revert_acct:
     689                 :          0 :         (void) account_pipe_buffers(user, pipe_bufs, 0);
     690                 :          0 :         kfree(pipe);
     691                 :            : out_free_uid:
     692                 :          6 :         free_uid(user);
     693                 :          0 :         return NULL;
     694                 :            : }
     695                 :            : 
     696                 :      70419 : void free_pipe_info(struct pipe_inode_info *pipe)
     697                 :            : {
     698                 :            :         int i;
     699                 :            : 
     700                 :      70419 :         (void) account_pipe_buffers(pipe->user, pipe->buffers, 0);
     701                 :      70449 :         free_uid(pipe->user);
     702         [ +  + ]:    1196908 :         for (i = 0; i < pipe->buffers; i++) {
     703                 :    1126458 :                 struct pipe_buffer *buf = pipe->bufs + i;
     704         [ +  + ]:    1126458 :                 if (buf->ops)
     705                 :            :                         pipe_buf_release(pipe, buf);
     706                 :            :         }
     707         [ +  + ]:      70450 :         if (pipe->tmp_page)
     708                 :      42771 :                 __free_page(pipe->tmp_page);
     709                 :      70449 :         kfree(pipe->bufs);
     710                 :      70453 :         kfree(pipe);
     711                 :      70453 : }
     712                 :            : 
     713                 :            : static struct vfsmount *pipe_mnt __read_mostly;
     714                 :            : 
     715                 :            : /*
     716                 :            :  * pipefs_dname() is called from d_path().
     717                 :            :  */
     718                 :          0 : static char *pipefs_dname(struct dentry *dentry, char *buffer, int buflen)
     719                 :            : {
     720                 :          0 :         return dynamic_dname(dentry, buffer, buflen, "pipe:[%lu]",
     721                 :            :                                 d_inode(dentry)->i_ino);
     722                 :            : }
     723                 :            : 
     724                 :            : static const struct dentry_operations pipefs_dentry_operations = {
     725                 :            :         .d_dname        = pipefs_dname,
     726                 :            : };
     727                 :            : 
     728                 :      73337 : static struct inode * get_pipe_inode(void)
     729                 :            : {
     730                 :      73337 :         struct inode *inode = new_inode_pseudo(pipe_mnt->mnt_sb);
     731                 :            :         struct pipe_inode_info *pipe;
     732                 :            : 
     733         [ +  - ]:      73351 :         if (!inode)
     734                 :            :                 goto fail_inode;
     735                 :            : 
     736                 :      73351 :         inode->i_ino = get_next_ino();
     737                 :            : 
     738                 :      73346 :         pipe = alloc_pipe_info();
     739         [ +  - ]:      73349 :         if (!pipe)
     740                 :            :                 goto fail_iput;
     741                 :            : 
     742                 :      73349 :         inode->i_pipe = pipe;
     743                 :      73349 :         pipe->files = 2;
     744                 :      73349 :         pipe->readers = pipe->writers = 1;
     745                 :      73349 :         inode->i_fop = &pipefifo_fops;
     746                 :            : 
     747                 :            :         /*
     748                 :            :          * Mark the inode dirty from the very beginning,
     749                 :            :          * that way it will never be moved to the dirty
     750                 :            :          * list because "mark_inode_dirty()" will think
     751                 :            :          * that it already _is_ on the dirty list.
     752                 :            :          */
     753                 :      73349 :         inode->i_state = I_DIRTY;
     754                 :      73349 :         inode->i_mode = S_IFIFO | S_IRUSR | S_IWUSR;
     755                 :      73349 :         inode->i_uid = current_fsuid();
     756                 :      73349 :         inode->i_gid = current_fsgid();
     757                 :      73349 :         inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
     758                 :            : 
     759                 :      73338 :         return inode;
     760                 :            : 
     761                 :            : fail_iput:
     762                 :          0 :         iput(inode);
     763                 :            : 
     764                 :            : fail_inode:
     765                 :            :         return NULL;
     766                 :            : }
     767                 :            : 
     768                 :      73351 : int create_pipe_files(struct file **res, int flags)
     769                 :            : {
     770                 :      73351 :         struct inode *inode = get_pipe_inode();
     771                 :            :         struct file *f;
     772                 :            : 
     773         [ +  - ]:      73314 :         if (!inode)
     774                 :            :                 return -ENFILE;
     775                 :            : 
     776                 :     146650 :         f = alloc_file_pseudo(inode, pipe_mnt, "",
     777                 :      73325 :                                 O_WRONLY | (flags & (O_NONBLOCK | O_DIRECT)),
     778                 :            :                                 &pipefifo_fops);
     779         [ -  + ]:      73334 :         if (IS_ERR(f)) {
     780                 :          0 :                 free_pipe_info(inode->i_pipe);
     781                 :          0 :                 iput(inode);
     782                 :          0 :                 return PTR_ERR(f);
     783                 :            :         }
     784                 :            : 
     785                 :      73334 :         f->private_data = inode->i_pipe;
     786                 :            : 
     787                 :      73334 :         res[0] = alloc_file_clone(f, O_RDONLY | (flags & O_NONBLOCK),
     788                 :            :                                   &pipefifo_fops);
     789         [ -  + ]:      73344 :         if (IS_ERR(res[0])) {
     790                 :          0 :                 put_pipe_info(inode, inode->i_pipe);
     791                 :          0 :                 fput(f);
     792                 :          0 :                 return PTR_ERR(res[0]);
     793                 :            :         }
     794                 :      73344 :         res[0]->private_data = inode->i_pipe;
     795                 :      73344 :         res[1] = f;
     796                 :      73344 :         return 0;
     797                 :            : }
     798                 :            : 
     799                 :      73348 : static int __do_pipe_flags(int *fd, struct file **files, int flags)
     800                 :            : {
     801                 :            :         int error;
     802                 :            :         int fdw, fdr;
     803                 :            : 
     804         [ +  + ]:      73348 :         if (flags & ~(O_CLOEXEC | O_NONBLOCK | O_DIRECT))
     805                 :            :                 return -EINVAL;
     806                 :            : 
     807                 :      73343 :         error = create_pipe_files(files, flags);
     808         [ +  + ]:      73342 :         if (error)
     809                 :            :                 return error;
     810                 :            : 
     811                 :      73345 :         error = get_unused_fd_flags(flags);
     812         [ +  - ]:      73350 :         if (error < 0)
     813                 :            :                 goto err_read_pipe;
     814                 :            :         fdr = error;
     815                 :            : 
     816                 :      73351 :         error = get_unused_fd_flags(flags);
     817         [ +  - ]:      73351 :         if (error < 0)
     818                 :            :                 goto err_fdr;
     819                 :            :         fdw = error;
     820                 :            : 
     821                 :      73351 :         audit_fd_pair(fdr, fdw);
     822                 :      73347 :         fd[0] = fdr;
     823                 :      73347 :         fd[1] = fdw;
     824                 :      73347 :         return 0;
     825                 :            : 
     826                 :            :  err_fdr:
     827                 :          0 :         put_unused_fd(fdr);
     828                 :            :  err_read_pipe:
     829                 :          0 :         fput(files[0]);
     830                 :          0 :         fput(files[1]);
     831                 :          0 :         return error;
     832                 :            : }
     833                 :            : 
     834                 :          0 : int do_pipe_flags(int *fd, int flags)
     835                 :            : {
     836                 :            :         struct file *files[2];
     837                 :          0 :         int error = __do_pipe_flags(fd, files, flags);
     838         [ #  # ]:          0 :         if (!error) {
     839                 :          0 :                 fd_install(fd[0], files[0]);
     840                 :          0 :                 fd_install(fd[1], files[1]);
     841                 :            :         }
     842                 :          0 :         return error;
     843                 :            : }
     844                 :            : 
     845                 :            : /*
     846                 :            :  * sys_pipe() is the normal C calling standard for creating
     847                 :            :  * a pipe. It's not the way Unix traditionally does this, though.
     848                 :            :  */
     849                 :      73351 : static int do_pipe2(int __user *fildes, int flags)
     850                 :            : {
     851                 :            :         struct file *files[2];
     852                 :            :         int fd[2];
     853                 :            :         int error;
     854                 :            : 
     855                 :      73351 :         error = __do_pipe_flags(fd, files, flags);
     856         [ +  + ]:      73346 :         if (!error) {
     857         [ -  + ]:      73346 :                 if (unlikely(copy_to_user(fildes, fd, sizeof(fd)))) {
     858                 :          0 :                         fput(files[0]);
     859                 :          0 :                         fput(files[1]);
     860                 :          0 :                         put_unused_fd(fd[0]);
     861                 :          0 :                         put_unused_fd(fd[1]);
     862                 :            :                         error = -EFAULT;
     863                 :            :                 } else {
     864                 :      73346 :                         fd_install(fd[0], files[0]);
     865                 :      73348 :                         fd_install(fd[1], files[1]);
     866                 :            :                 }
     867                 :            :         }
     868                 :      73377 :         return error;
     869                 :            : }
     870                 :            : 
     871                 :      65825 : SYSCALL_DEFINE2(pipe2, int __user *, fildes, int, flags)
     872                 :            : {
     873                 :      32913 :         return do_pipe2(fildes, flags);
     874                 :            : }
     875                 :            : 
     876                 :      80875 : SYSCALL_DEFINE1(pipe, int __user *, fildes)
     877                 :            : {
     878                 :      40438 :         return do_pipe2(fildes, 0);
     879                 :            : }
     880                 :            : 
     881                 :          0 : static int wait_for_partner(struct pipe_inode_info *pipe, unsigned int *cnt)
     882                 :            : {
     883                 :          0 :         int cur = *cnt; 
     884                 :            : 
     885         [ #  # ]:          0 :         while (cur == *cnt) {
     886                 :          0 :                 pipe_wait(pipe);
     887         [ #  # ]:          0 :                 if (signal_pending(current))
     888                 :            :                         break;
     889                 :            :         }
     890         [ #  # ]:          0 :         return cur == *cnt ? -ERESTARTSYS : 0;
     891                 :            : }
     892                 :            : 
     893                 :            : static void wake_up_partner(struct pipe_inode_info *pipe)
     894                 :            : {
     895                 :       1035 :         wake_up_interruptible(&pipe->wait);
     896                 :            : }
     897                 :            : 
     898                 :       1035 : static int fifo_open(struct inode *inode, struct file *filp)
     899                 :            : {
     900                 :            :         struct pipe_inode_info *pipe;
     901                 :       1035 :         bool is_pipe = inode->i_sb->s_magic == PIPEFS_MAGIC;
     902                 :            :         int ret;
     903                 :            : 
     904                 :       1035 :         filp->f_version = 0;
     905                 :            : 
     906                 :            :         spin_lock(&inode->i_lock);
     907         [ +  + ]:       1035 :         if (inode->i_pipe) {
     908                 :            :                 pipe = inode->i_pipe;
     909                 :        414 :                 pipe->files++;
     910                 :            :                 spin_unlock(&inode->i_lock);
     911                 :            :         } else {
     912                 :            :                 spin_unlock(&inode->i_lock);
     913                 :        621 :                 pipe = alloc_pipe_info();
     914         [ +  - ]:        621 :                 if (!pipe)
     915                 :            :                         return -ENOMEM;
     916                 :        621 :                 pipe->files = 1;
     917                 :            :                 spin_lock(&inode->i_lock);
     918         [ -  + ]:        621 :                 if (unlikely(inode->i_pipe)) {
     919                 :          0 :                         inode->i_pipe->files++;
     920                 :            :                         spin_unlock(&inode->i_lock);
     921                 :          0 :                         free_pipe_info(pipe);
     922                 :          0 :                         pipe = inode->i_pipe;
     923                 :            :                 } else {
     924                 :        621 :                         inode->i_pipe = pipe;
     925                 :            :                         spin_unlock(&inode->i_lock);
     926                 :            :                 }
     927                 :            :         }
     928                 :       1035 :         filp->private_data = pipe;
     929                 :            :         /* OK, we have a pipe and it's pinned down */
     930                 :            : 
     931                 :            :         __pipe_lock(pipe);
     932                 :            : 
     933                 :            :         /* We can only do regular read/write on fifos */
     934                 :       1035 :         filp->f_mode &= (FMODE_READ | FMODE_WRITE);
     935                 :            : 
     936   [ +  +  +  - ]:       1035 :         switch (filp->f_mode) {
     937                 :            :         case FMODE_READ:
     938                 :            :         /*
     939                 :            :          *  O_RDONLY
     940                 :            :          *  POSIX.1 says that O_NONBLOCK means return with the FIFO
     941                 :            :          *  opened, even when there is no process writing the FIFO.
     942                 :            :          */
     943                 :        414 :                 pipe->r_counter++;
     944         [ +  - ]:        414 :                 if (pipe->readers++ == 0)
     945                 :            :                         wake_up_partner(pipe);
     946                 :            : 
     947   [ +  -  +  - ]:        414 :                 if (!is_pipe && !pipe->writers) {
     948         [ +  - ]:        414 :                         if ((filp->f_flags & O_NONBLOCK)) {
     949                 :            :                                 /* suppress EPOLLHUP until we have
     950                 :            :                                  * seen a writer */
     951                 :        414 :                                 filp->f_version = pipe->w_counter;
     952                 :            :                         } else {
     953         [ #  # ]:          0 :                                 if (wait_for_partner(pipe, &pipe->w_counter))
     954                 :            :                                         goto err_rd;
     955                 :            :                         }
     956                 :            :                 }
     957                 :            :                 break;
     958                 :            :         
     959                 :            :         case FMODE_WRITE:
     960                 :            :         /*
     961                 :            :          *  O_WRONLY
     962                 :            :          *  POSIX.1 says that O_NONBLOCK means return -1 with
     963                 :            :          *  errno=ENXIO when there is no process reading the FIFO.
     964                 :            :          */
     965                 :            :                 ret = -ENXIO;
     966   [ +  -  +  -  :        414 :                 if (!is_pipe && (filp->f_flags & O_NONBLOCK) && !pipe->readers)
                   +  - ]
     967                 :            :                         goto err;
     968                 :            : 
     969                 :        414 :                 pipe->w_counter++;
     970         [ +  - ]:        414 :                 if (!pipe->writers++)
     971                 :            :                         wake_up_partner(pipe);
     972                 :            : 
     973   [ +  -  -  + ]:        414 :                 if (!is_pipe && !pipe->readers) {
     974         [ #  # ]:          0 :                         if (wait_for_partner(pipe, &pipe->r_counter))
     975                 :            :                                 goto err_wr;
     976                 :            :                 }
     977                 :            :                 break;
     978                 :            :         
     979                 :            :         case FMODE_READ | FMODE_WRITE:
     980                 :            :         /*
     981                 :            :          *  O_RDWR
     982                 :            :          *  POSIX.1 leaves this case "undefined" when O_NONBLOCK is set.
     983                 :            :          *  This implementation will NEVER block on a O_RDWR open, since
     984                 :            :          *  the process can at least talk to itself.
     985                 :            :          */
     986                 :            : 
     987                 :        207 :                 pipe->readers++;
     988                 :        207 :                 pipe->writers++;
     989                 :        207 :                 pipe->r_counter++;
     990                 :        207 :                 pipe->w_counter++;
     991   [ -  +  #  # ]:        207 :                 if (pipe->readers == 1 || pipe->writers == 1)
     992                 :            :                         wake_up_partner(pipe);
     993                 :            :                 break;
     994                 :            : 
     995                 :            :         default:
     996                 :            :                 ret = -EINVAL;
     997                 :            :                 goto err;
     998                 :            :         }
     999                 :            : 
    1000                 :            :         /* Ok! */
    1001                 :            :         __pipe_unlock(pipe);
    1002                 :       1035 :         return 0;
    1003                 :            : 
    1004                 :            : err_rd:
    1005         [ #  # ]:          0 :         if (!--pipe->readers)
    1006                 :          0 :                 wake_up_interruptible(&pipe->wait);
    1007                 :            :         ret = -ERESTARTSYS;
    1008                 :            :         goto err;
    1009                 :            : 
    1010                 :            : err_wr:
    1011         [ #  # ]:          0 :         if (!--pipe->writers)
    1012                 :          0 :                 wake_up_interruptible(&pipe->wait);
    1013                 :            :         ret = -ERESTARTSYS;
    1014                 :            :         goto err;
    1015                 :            : 
    1016                 :            : err:
    1017                 :            :         __pipe_unlock(pipe);
    1018                 :            : 
    1019                 :          0 :         put_pipe_info(inode, pipe);
    1020                 :          0 :         return ret;
    1021                 :            : }
    1022                 :            : 
    1023                 :            : const struct file_operations pipefifo_fops = {
    1024                 :            :         .open           = fifo_open,
    1025                 :            :         .llseek         = no_llseek,
    1026                 :            :         .read_iter      = pipe_read,
    1027                 :            :         .write_iter     = pipe_write,
    1028                 :            :         .poll           = pipe_poll,
    1029                 :            :         .unlocked_ioctl = pipe_ioctl,
    1030                 :            :         .release        = pipe_release,
    1031                 :            :         .fasync         = pipe_fasync,
    1032                 :            : };
    1033                 :            : 
    1034                 :            : /*
    1035                 :            :  * Currently we rely on the pipe array holding a power-of-2 number
    1036                 :            :  * of pages. Returns 0 on error.
    1037                 :            :  */
    1038                 :          0 : unsigned int round_pipe_size(unsigned long size)
    1039                 :            : {
    1040         [ #  # ]:          0 :         if (size > (1U << 31))
    1041                 :            :                 return 0;
    1042                 :            : 
    1043                 :            :         /* Minimum pipe size, as required by POSIX */
    1044         [ #  # ]:          0 :         if (size < PAGE_SIZE)
    1045                 :            :                 return PAGE_SIZE;
    1046                 :            : 
    1047   [ #  #  #  #  :          0 :         return roundup_pow_of_two(size);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                      # ]
    1048                 :            : }
    1049                 :            : 
    1050                 :            : /*
    1051                 :            :  * Allocate a new array of pipe buffers and copy the info over. Returns the
    1052                 :            :  * pipe size if successful, or return -ERROR on error.
    1053                 :            :  */
    1054                 :          0 : static long pipe_set_size(struct pipe_inode_info *pipe, unsigned long arg)
    1055                 :            : {
    1056                 :            :         struct pipe_buffer *bufs;
    1057                 :            :         unsigned int size, nr_pages;
    1058                 :            :         unsigned long user_bufs;
    1059                 :            :         long ret = 0;
    1060                 :            : 
    1061                 :          0 :         size = round_pipe_size(arg);
    1062                 :          0 :         nr_pages = size >> PAGE_SHIFT;
    1063                 :            : 
    1064         [ #  # ]:          0 :         if (!nr_pages)
    1065                 :            :                 return -EINVAL;
    1066                 :            : 
    1067                 :            :         /*
    1068                 :            :          * If trying to increase the pipe capacity, check that an
    1069                 :            :          * unprivileged user is not trying to exceed various limits
    1070                 :            :          * (soft limit check here, hard limit check just below).
    1071                 :            :          * Decreasing the pipe capacity is always permitted, even
    1072                 :            :          * if the user is currently over a limit.
    1073                 :            :          */
    1074   [ #  #  #  # ]:          0 :         if (nr_pages > pipe->buffers &&
    1075         [ #  # ]:          0 :                         size > pipe_max_size && !capable(CAP_SYS_RESOURCE))
    1076                 :            :                 return -EPERM;
    1077                 :            : 
    1078                 :          0 :         user_bufs = account_pipe_buffers(pipe->user, pipe->buffers, nr_pages);
    1079                 :            : 
    1080   [ #  #  #  # ]:          0 :         if (nr_pages > pipe->buffers &&
    1081         [ #  # ]:          0 :                         (too_many_pipe_buffers_hard(user_bufs) ||
    1082         [ #  # ]:          0 :                          too_many_pipe_buffers_soft(user_bufs)) &&
    1083                 :          0 :                         is_unprivileged_user()) {
    1084                 :            :                 ret = -EPERM;
    1085                 :            :                 goto out_revert_acct;
    1086                 :            :         }
    1087                 :            : 
    1088                 :            :         /*
    1089                 :            :          * We can shrink the pipe, if arg >= pipe->nrbufs. Since we don't
    1090                 :            :          * expect a lot of shrink+grow operations, just free and allocate
    1091                 :            :          * again like we would do for growing. If the pipe currently
    1092                 :            :          * contains more buffers than arg, then return busy.
    1093                 :            :          */
    1094         [ #  # ]:          0 :         if (nr_pages < pipe->nrbufs) {
    1095                 :            :                 ret = -EBUSY;
    1096                 :            :                 goto out_revert_acct;
    1097                 :            :         }
    1098                 :            : 
    1099                 :            :         bufs = kcalloc(nr_pages, sizeof(*bufs),
    1100                 :            :                        GFP_KERNEL_ACCOUNT | __GFP_NOWARN);
    1101         [ #  # ]:          0 :         if (unlikely(!bufs)) {
    1102                 :            :                 ret = -ENOMEM;
    1103                 :            :                 goto out_revert_acct;
    1104                 :            :         }
    1105                 :            : 
    1106                 :            :         /*
    1107                 :            :          * The pipe array wraps around, so just start the new one at zero
    1108                 :            :          * and adjust the indexes.
    1109                 :            :          */
    1110         [ #  # ]:          0 :         if (pipe->nrbufs) {
    1111                 :            :                 unsigned int tail;
    1112                 :            :                 unsigned int head;
    1113                 :            : 
    1114                 :          0 :                 tail = pipe->curbuf + pipe->nrbufs;
    1115         [ #  # ]:          0 :                 if (tail < pipe->buffers)
    1116                 :            :                         tail = 0;
    1117                 :            :                 else
    1118                 :          0 :                         tail &= (pipe->buffers - 1);
    1119                 :            : 
    1120                 :          0 :                 head = pipe->nrbufs - tail;
    1121         [ #  # ]:          0 :                 if (head)
    1122                 :          0 :                         memcpy(bufs, pipe->bufs + pipe->curbuf, head * sizeof(struct pipe_buffer));
    1123         [ #  # ]:          0 :                 if (tail)
    1124                 :          0 :                         memcpy(bufs + head, pipe->bufs, tail * sizeof(struct pipe_buffer));
    1125                 :            :         }
    1126                 :            : 
    1127                 :          0 :         pipe->curbuf = 0;
    1128                 :          0 :         kfree(pipe->bufs);
    1129                 :          0 :         pipe->bufs = bufs;
    1130                 :          0 :         pipe->buffers = nr_pages;
    1131                 :          0 :         return nr_pages * PAGE_SIZE;
    1132                 :            : 
    1133                 :            : out_revert_acct:
    1134                 :          0 :         (void) account_pipe_buffers(pipe->user, nr_pages, pipe->buffers);
    1135                 :          0 :         return ret;
    1136                 :            : }
    1137                 :            : 
    1138                 :            : /*
    1139                 :            :  * After the inode slimming patch, i_pipe/i_bdev/i_cdev share the same
    1140                 :            :  * location, so checking ->i_pipe is not enough to verify that this is a
    1141                 :            :  * pipe.
    1142                 :            :  */
    1143                 :          0 : struct pipe_inode_info *get_pipe_info(struct file *file)
    1144                 :            : {
    1145   [ #  #  #  # ]:          0 :         return file->f_op == &pipefifo_fops ? file->private_data : NULL;
    1146                 :            : }
    1147                 :            : 
    1148                 :          0 : long pipe_fcntl(struct file *file, unsigned int cmd, unsigned long arg)
    1149                 :            : {
    1150                 :            :         struct pipe_inode_info *pipe;
    1151                 :            :         long ret;
    1152                 :            : 
    1153                 :            :         pipe = get_pipe_info(file);
    1154         [ #  # ]:          0 :         if (!pipe)
    1155                 :            :                 return -EBADF;
    1156                 :            : 
    1157                 :            :         __pipe_lock(pipe);
    1158                 :            : 
    1159      [ #  #  # ]:          0 :         switch (cmd) {
    1160                 :            :         case F_SETPIPE_SZ:
    1161                 :          0 :                 ret = pipe_set_size(pipe, arg);
    1162                 :          0 :                 break;
    1163                 :            :         case F_GETPIPE_SZ:
    1164                 :          0 :                 ret = pipe->buffers * PAGE_SIZE;
    1165                 :          0 :                 break;
    1166                 :            :         default:
    1167                 :            :                 ret = -EINVAL;
    1168                 :            :                 break;
    1169                 :            :         }
    1170                 :            : 
    1171                 :            :         __pipe_unlock(pipe);
    1172                 :          0 :         return ret;
    1173                 :            : }
    1174                 :            : 
    1175                 :            : static const struct super_operations pipefs_ops = {
    1176                 :            :         .destroy_inode = free_inode_nonrcu,
    1177                 :            :         .statfs = simple_statfs,
    1178                 :            : };
    1179                 :            : 
    1180                 :            : /*
    1181                 :            :  * pipefs should _never_ be mounted by userland - too much of security hassle,
    1182                 :            :  * no real gain from having the whole whorehouse mounted. So we don't need
    1183                 :            :  * any operations on the root directory. However, we need a non-trivial
    1184                 :            :  * d_name - pipe: will go nicely and kill the special-casing in procfs.
    1185                 :            :  */
    1186                 :            : 
    1187                 :        207 : static int pipefs_init_fs_context(struct fs_context *fc)
    1188                 :            : {
    1189                 :        207 :         struct pseudo_fs_context *ctx = init_pseudo(fc, PIPEFS_MAGIC);
    1190         [ +  - ]:        207 :         if (!ctx)
    1191                 :            :                 return -ENOMEM;
    1192                 :        207 :         ctx->ops = &pipefs_ops;
    1193                 :        207 :         ctx->dops = &pipefs_dentry_operations;
    1194                 :        207 :         return 0;
    1195                 :            : }
    1196                 :            : 
    1197                 :            : static struct file_system_type pipe_fs_type = {
    1198                 :            :         .name           = "pipefs",
    1199                 :            :         .init_fs_context = pipefs_init_fs_context,
    1200                 :            :         .kill_sb        = kill_anon_super,
    1201                 :            : };
    1202                 :            : 
    1203                 :        207 : static int __init init_pipe_fs(void)
    1204                 :            : {
    1205                 :        207 :         int err = register_filesystem(&pipe_fs_type);
    1206                 :            : 
    1207         [ +  - ]:        207 :         if (!err) {
    1208                 :        207 :                 pipe_mnt = kern_mount(&pipe_fs_type);
    1209         [ -  + ]:        207 :                 if (IS_ERR(pipe_mnt)) {
    1210                 :            :                         err = PTR_ERR(pipe_mnt);
    1211                 :          0 :                         unregister_filesystem(&pipe_fs_type);
    1212                 :            :                 }
    1213                 :            :         }
    1214                 :        207 :         return err;
    1215                 :            : }
    1216                 :            : 
    1217                 :            : fs_initcall(init_pipe_fs);

Generated by: LCOV version 1.14