LCOV - code coverage report
Current view: top level - fs - splice.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 157 725 21.7 %
Date: 2022-04-01 14:58:12 Functions: 9 49 18.4 %
Branches: 46 410 11.2 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * "splice": joining two ropes together by interweaving their strands.
       4                 :            :  *
       5                 :            :  * This is the "extended pipe" functionality, where a pipe is used as
       6                 :            :  * an arbitrary in-memory buffer. Think of a pipe as a small kernel
       7                 :            :  * buffer that you can use to transfer data from one end to the other.
       8                 :            :  *
       9                 :            :  * The traditional unix read/write is extended with a "splice()" operation
      10                 :            :  * that transfers data buffers to or from a pipe buffer.
      11                 :            :  *
      12                 :            :  * Named by Larry McVoy, original implementation from Linus, extended by
      13                 :            :  * Jens to support splicing to files, network, direct splicing, etc and
      14                 :            :  * fixing lots of bugs.
      15                 :            :  *
      16                 :            :  * Copyright (C) 2005-2006 Jens Axboe <axboe@kernel.dk>
      17                 :            :  * Copyright (C) 2005-2006 Linus Torvalds <torvalds@osdl.org>
      18                 :            :  * Copyright (C) 2006 Ingo Molnar <mingo@elte.hu>
      19                 :            :  *
      20                 :            :  */
      21                 :            : #include <linux/bvec.h>
      22                 :            : #include <linux/fs.h>
      23                 :            : #include <linux/file.h>
      24                 :            : #include <linux/pagemap.h>
      25                 :            : #include <linux/splice.h>
      26                 :            : #include <linux/memcontrol.h>
      27                 :            : #include <linux/mm_inline.h>
      28                 :            : #include <linux/swap.h>
      29                 :            : #include <linux/writeback.h>
      30                 :            : #include <linux/export.h>
      31                 :            : #include <linux/syscalls.h>
      32                 :            : #include <linux/uio.h>
      33                 :            : #include <linux/security.h>
      34                 :            : #include <linux/gfp.h>
      35                 :            : #include <linux/socket.h>
      36                 :            : #include <linux/compat.h>
      37                 :            : #include <linux/sched/signal.h>
      38                 :            : 
      39                 :            : #include "internal.h"
      40                 :            : 
      41                 :            : /*
      42                 :            :  * Attempt to steal a page from a pipe buffer. This should perhaps go into
      43                 :            :  * a vm helper function, it's already simplified quite a bit by the
      44                 :            :  * addition of remove_mapping(). If success is returned, the caller may
      45                 :            :  * attempt to reuse this page for another destination.
      46                 :            :  */
      47                 :          0 : static int page_cache_pipe_buf_steal(struct pipe_inode_info *pipe,
      48                 :            :                                      struct pipe_buffer *buf)
      49                 :            : {
      50                 :          0 :         struct page *page = buf->page;
      51                 :          0 :         struct address_space *mapping;
      52                 :            : 
      53                 :          0 :         lock_page(page);
      54                 :            : 
      55                 :          0 :         mapping = page_mapping(page);
      56         [ #  # ]:          0 :         if (mapping) {
      57         [ #  # ]:          0 :                 WARN_ON(!PageUptodate(page));
      58                 :            : 
      59                 :            :                 /*
      60                 :            :                  * At least for ext2 with nobh option, we need to wait on
      61                 :            :                  * writeback completing on this page, since we'll remove it
      62                 :            :                  * from the pagecache.  Otherwise truncate wont wait on the
      63                 :            :                  * page, allowing the disk blocks to be reused by someone else
      64                 :            :                  * before we actually wrote our data to them. fs corruption
      65                 :            :                  * ensues.
      66                 :            :                  */
      67                 :          0 :                 wait_on_page_writeback(page);
      68                 :            : 
      69   [ #  #  #  # ]:          0 :                 if (page_has_private(page) &&
      70                 :          0 :                     !try_to_release_page(page, GFP_KERNEL))
      71                 :          0 :                         goto out_unlock;
      72                 :            : 
      73                 :            :                 /*
      74                 :            :                  * If we succeeded in removing the mapping, set LRU flag
      75                 :            :                  * and return good.
      76                 :            :                  */
      77         [ #  # ]:          0 :                 if (remove_mapping(mapping, page)) {
      78                 :          0 :                         buf->flags |= PIPE_BUF_FLAG_LRU;
      79                 :          0 :                         return 0;
      80                 :            :                 }
      81                 :            :         }
      82                 :            : 
      83                 :            :         /*
      84                 :            :          * Raced with truncate or failed to remove page from current
      85                 :            :          * address space, unlock and return failure.
      86                 :            :          */
      87                 :          0 : out_unlock:
      88                 :          0 :         unlock_page(page);
      89                 :          0 :         return 1;
      90                 :            : }
      91                 :            : 
      92                 :         12 : static void page_cache_pipe_buf_release(struct pipe_inode_info *pipe,
      93                 :            :                                         struct pipe_buffer *buf)
      94                 :            : {
      95                 :         12 :         put_page(buf->page);
      96                 :         12 :         buf->flags &= ~PIPE_BUF_FLAG_LRU;
      97                 :         12 : }
      98                 :            : 
      99                 :            : /*
     100                 :            :  * Check whether the contents of buf is OK to access. Since the content
     101                 :            :  * is a page cache page, IO may be in flight.
     102                 :            :  */
     103                 :         12 : static int page_cache_pipe_buf_confirm(struct pipe_inode_info *pipe,
     104                 :            :                                        struct pipe_buffer *buf)
     105                 :            : {
     106                 :         12 :         struct page *page = buf->page;
     107                 :         12 :         int err;
     108                 :            : 
     109         [ -  + ]:         12 :         if (!PageUptodate(page)) {
     110                 :          0 :                 lock_page(page);
     111                 :            : 
     112                 :            :                 /*
     113                 :            :                  * Page got truncated/unhashed. This will cause a 0-byte
     114                 :            :                  * splice, if this is the first page.
     115                 :            :                  */
     116         [ #  # ]:          0 :                 if (!page->mapping) {
     117                 :          0 :                         err = -ENODATA;
     118                 :          0 :                         goto error;
     119                 :            :                 }
     120                 :            : 
     121                 :            :                 /*
     122                 :            :                  * Uh oh, read-error from disk.
     123                 :            :                  */
     124         [ #  # ]:          0 :                 if (!PageUptodate(page)) {
     125                 :          0 :                         err = -EIO;
     126                 :          0 :                         goto error;
     127                 :            :                 }
     128                 :            : 
     129                 :            :                 /*
     130                 :            :                  * Page is ok afterall, we are done.
     131                 :            :                  */
     132                 :          0 :                 unlock_page(page);
     133                 :            :         }
     134                 :            : 
     135                 :            :         return 0;
     136                 :          0 : error:
     137                 :          0 :         unlock_page(page);
     138                 :          0 :         return err;
     139                 :            : }
     140                 :            : 
     141                 :            : const struct pipe_buf_operations page_cache_pipe_buf_ops = {
     142                 :            :         .confirm = page_cache_pipe_buf_confirm,
     143                 :            :         .release = page_cache_pipe_buf_release,
     144                 :            :         .steal = page_cache_pipe_buf_steal,
     145                 :            :         .get = generic_pipe_buf_get,
     146                 :            : };
     147                 :            : 
     148                 :          0 : static int user_page_pipe_buf_steal(struct pipe_inode_info *pipe,
     149                 :            :                                     struct pipe_buffer *buf)
     150                 :            : {
     151         [ #  # ]:          0 :         if (!(buf->flags & PIPE_BUF_FLAG_GIFT))
     152                 :            :                 return 1;
     153                 :            : 
     154                 :          0 :         buf->flags |= PIPE_BUF_FLAG_LRU;
     155                 :          0 :         return generic_pipe_buf_steal(pipe, buf);
     156                 :            : }
     157                 :            : 
     158                 :            : static const struct pipe_buf_operations user_page_pipe_buf_ops = {
     159                 :            :         .confirm = generic_pipe_buf_confirm,
     160                 :            :         .release = page_cache_pipe_buf_release,
     161                 :            :         .steal = user_page_pipe_buf_steal,
     162                 :            :         .get = generic_pipe_buf_get,
     163                 :            : };
     164                 :            : 
     165                 :          0 : static void wakeup_pipe_readers(struct pipe_inode_info *pipe)
     166                 :            : {
     167                 :          0 :         smp_mb();
     168         [ #  # ]:          0 :         if (waitqueue_active(&pipe->rd_wait))
     169                 :          0 :                 wake_up_interruptible(&pipe->rd_wait);
     170                 :          0 :         kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
     171                 :          0 : }
     172                 :            : 
     173                 :            : /**
     174                 :            :  * splice_to_pipe - fill passed data into a pipe
     175                 :            :  * @pipe:       pipe to fill
     176                 :            :  * @spd:        data to fill
     177                 :            :  *
     178                 :            :  * Description:
     179                 :            :  *    @spd contains a map of pages and len/offset tuples, along with
     180                 :            :  *    the struct pipe_buf_operations associated with these pages. This
     181                 :            :  *    function will link that data to the pipe.
     182                 :            :  *
     183                 :            :  */
     184                 :          0 : ssize_t splice_to_pipe(struct pipe_inode_info *pipe,
     185                 :            :                        struct splice_pipe_desc *spd)
     186                 :            : {
     187                 :          0 :         unsigned int spd_pages = spd->nr_pages;
     188                 :          0 :         unsigned int tail = pipe->tail;
     189                 :          0 :         unsigned int head = pipe->head;
     190                 :          0 :         unsigned int mask = pipe->ring_size - 1;
     191                 :          0 :         int ret = 0, page_nr = 0;
     192                 :            : 
     193         [ #  # ]:          0 :         if (!spd_pages)
     194                 :            :                 return 0;
     195                 :            : 
     196         [ #  # ]:          0 :         if (unlikely(!pipe->readers)) {
     197                 :          0 :                 send_sig(SIGPIPE, current, 0);
     198                 :          0 :                 ret = -EPIPE;
     199                 :          0 :                 goto out;
     200                 :            :         }
     201                 :            : 
     202         [ #  # ]:          0 :         while (!pipe_full(head, tail, pipe->max_usage)) {
     203                 :          0 :                 struct pipe_buffer *buf = &pipe->bufs[head & mask];
     204                 :            : 
     205                 :          0 :                 buf->page = spd->pages[page_nr];
     206                 :          0 :                 buf->offset = spd->partial[page_nr].offset;
     207                 :          0 :                 buf->len = spd->partial[page_nr].len;
     208                 :          0 :                 buf->private = spd->partial[page_nr].private;
     209                 :          0 :                 buf->ops = spd->ops;
     210                 :          0 :                 buf->flags = 0;
     211                 :            : 
     212                 :          0 :                 head++;
     213                 :          0 :                 pipe->head = head;
     214                 :          0 :                 page_nr++;
     215                 :          0 :                 ret += buf->len;
     216                 :            : 
     217         [ #  # ]:          0 :                 if (!--spd->nr_pages)
     218                 :            :                         break;
     219                 :            :         }
     220                 :            : 
     221         [ #  # ]:          0 :         if (!ret)
     222                 :          0 :                 ret = -EAGAIN;
     223                 :            : 
     224                 :          0 : out:
     225         [ #  # ]:          0 :         while (page_nr < spd_pages)
     226                 :          0 :                 spd->spd_release(spd, page_nr++);
     227                 :            : 
     228                 :          0 :         return ret;
     229                 :            : }
     230                 :            : EXPORT_SYMBOL_GPL(splice_to_pipe);
     231                 :            : 
     232                 :          0 : ssize_t add_to_pipe(struct pipe_inode_info *pipe, struct pipe_buffer *buf)
     233                 :            : {
     234                 :          0 :         unsigned int head = pipe->head;
     235                 :          0 :         unsigned int tail = pipe->tail;
     236                 :          0 :         unsigned int mask = pipe->ring_size - 1;
     237                 :          0 :         int ret;
     238                 :            : 
     239         [ #  # ]:          0 :         if (unlikely(!pipe->readers)) {
     240                 :          0 :                 send_sig(SIGPIPE, current, 0);
     241                 :          0 :                 ret = -EPIPE;
     242         [ #  # ]:          0 :         } else if (pipe_full(head, tail, pipe->max_usage)) {
     243                 :            :                 ret = -EAGAIN;
     244                 :            :         } else {
     245                 :          0 :                 pipe->bufs[head & mask] = *buf;
     246                 :          0 :                 pipe->head = head + 1;
     247                 :          0 :                 return buf->len;
     248                 :            :         }
     249                 :          0 :         pipe_buf_release(pipe, buf);
     250                 :          0 :         return ret;
     251                 :            : }
     252                 :            : EXPORT_SYMBOL(add_to_pipe);
     253                 :            : 
     254                 :            : /*
     255                 :            :  * Check if we need to grow the arrays holding pages and partial page
     256                 :            :  * descriptions.
     257                 :            :  */
     258                 :          0 : int splice_grow_spd(const struct pipe_inode_info *pipe, struct splice_pipe_desc *spd)
     259                 :            : {
     260         [ #  # ]:          0 :         unsigned int max_usage = READ_ONCE(pipe->max_usage);
     261                 :            : 
     262                 :          0 :         spd->nr_pages_max = max_usage;
     263         [ #  # ]:          0 :         if (max_usage <= PIPE_DEF_BUFFERS)
     264                 :            :                 return 0;
     265                 :            : 
     266                 :          0 :         spd->pages = kmalloc_array(max_usage, sizeof(struct page *), GFP_KERNEL);
     267                 :          0 :         spd->partial = kmalloc_array(max_usage, sizeof(struct partial_page),
     268                 :            :                                      GFP_KERNEL);
     269                 :            : 
     270   [ #  #  #  # ]:          0 :         if (spd->pages && spd->partial)
     271                 :            :                 return 0;
     272                 :            : 
     273                 :          0 :         kfree(spd->pages);
     274                 :          0 :         kfree(spd->partial);
     275                 :          0 :         return -ENOMEM;
     276                 :            : }
     277                 :            : 
     278                 :          0 : void splice_shrink_spd(struct splice_pipe_desc *spd)
     279                 :            : {
     280         [ #  # ]:          0 :         if (spd->nr_pages_max <= PIPE_DEF_BUFFERS)
     281                 :            :                 return;
     282                 :            : 
     283                 :          0 :         kfree(spd->pages);
     284                 :          0 :         kfree(spd->partial);
     285                 :            : }
     286                 :            : 
     287                 :            : /**
     288                 :            :  * generic_file_splice_read - splice data from file to a pipe
     289                 :            :  * @in:         file to splice from
     290                 :            :  * @ppos:       position in @in
     291                 :            :  * @pipe:       pipe to splice to
     292                 :            :  * @len:        number of bytes to splice
     293                 :            :  * @flags:      splice modifier flags
     294                 :            :  *
     295                 :            :  * Description:
     296                 :            :  *    Will read pages from given file and fill them into a pipe. Can be
     297                 :            :  *    used as long as it has more or less sane ->read_iter().
     298                 :            :  *
     299                 :            :  */
     300                 :         12 : ssize_t generic_file_splice_read(struct file *in, loff_t *ppos,
     301                 :            :                                  struct pipe_inode_info *pipe, size_t len,
     302                 :            :                                  unsigned int flags)
     303                 :            : {
     304                 :         12 :         struct iov_iter to;
     305                 :         12 :         struct kiocb kiocb;
     306                 :         12 :         unsigned int i_head;
     307                 :         12 :         int ret;
     308                 :            : 
     309                 :         12 :         iov_iter_pipe(&to, READ, pipe, len);
     310                 :         12 :         i_head = to.head;
     311                 :         12 :         init_sync_kiocb(&kiocb, in);
     312                 :         12 :         kiocb.ki_pos = *ppos;
     313                 :         12 :         ret = call_read_iter(in, &kiocb, &to);
     314         [ +  - ]:         12 :         if (ret > 0) {
     315                 :         12 :                 *ppos = kiocb.ki_pos;
     316         [ +  - ]:         12 :                 file_accessed(in);
     317         [ #  # ]:          0 :         } else if (ret < 0) {
     318                 :          0 :                 to.head = i_head;
     319                 :          0 :                 to.iov_offset = 0;
     320                 :          0 :                 iov_iter_advance(&to, 0); /* to free what was emitted */
     321                 :            :                 /*
     322                 :            :                  * callers of ->splice_read() expect -EAGAIN on
     323                 :            :                  * "can't put anything in there", rather than -EFAULT.
     324                 :            :                  */
     325         [ #  # ]:          0 :                 if (ret == -EFAULT)
     326                 :          0 :                         ret = -EAGAIN;
     327                 :            :         }
     328                 :            : 
     329                 :         12 :         return ret;
     330                 :            : }
     331                 :            : EXPORT_SYMBOL(generic_file_splice_read);
     332                 :            : 
     333                 :            : const struct pipe_buf_operations default_pipe_buf_ops = {
     334                 :            :         .confirm = generic_pipe_buf_confirm,
     335                 :            :         .release = generic_pipe_buf_release,
     336                 :            :         .steal = generic_pipe_buf_steal,
     337                 :            :         .get = generic_pipe_buf_get,
     338                 :            : };
     339                 :            : 
     340                 :          0 : int generic_pipe_buf_nosteal(struct pipe_inode_info *pipe,
     341                 :            :                              struct pipe_buffer *buf)
     342                 :            : {
     343                 :          0 :         return 1;
     344                 :            : }
     345                 :            : 
     346                 :            : /* Pipe buffer operations for a socket and similar. */
     347                 :            : const struct pipe_buf_operations nosteal_pipe_buf_ops = {
     348                 :            :         .confirm = generic_pipe_buf_confirm,
     349                 :            :         .release = generic_pipe_buf_release,
     350                 :            :         .steal = generic_pipe_buf_nosteal,
     351                 :            :         .get = generic_pipe_buf_get,
     352                 :            : };
     353                 :            : EXPORT_SYMBOL(nosteal_pipe_buf_ops);
     354                 :            : 
     355                 :          0 : static ssize_t kernel_readv(struct file *file, const struct kvec *vec,
     356                 :            :                             unsigned long vlen, loff_t offset)
     357                 :            : {
     358                 :          0 :         mm_segment_t old_fs;
     359                 :          0 :         loff_t pos = offset;
     360                 :          0 :         ssize_t res;
     361                 :            : 
     362                 :          0 :         old_fs = get_fs();
     363                 :          0 :         set_fs(KERNEL_DS);
     364                 :            :         /* The cast to a user pointer is valid due to the set_fs() */
     365                 :          0 :         res = vfs_readv(file, (const struct iovec __user *)vec, vlen, &pos, 0);
     366                 :          0 :         set_fs(old_fs);
     367                 :            : 
     368                 :          0 :         return res;
     369                 :            : }
     370                 :            : 
     371                 :          0 : static ssize_t default_file_splice_read(struct file *in, loff_t *ppos,
     372                 :            :                                  struct pipe_inode_info *pipe, size_t len,
     373                 :            :                                  unsigned int flags)
     374                 :            : {
     375                 :          0 :         struct kvec *vec, __vec[PIPE_DEF_BUFFERS];
     376                 :          0 :         struct iov_iter to;
     377                 :          0 :         struct page **pages;
     378                 :          0 :         unsigned int nr_pages;
     379                 :          0 :         unsigned int mask;
     380                 :          0 :         size_t offset, base, copied = 0;
     381                 :          0 :         ssize_t res;
     382                 :          0 :         int i;
     383                 :            : 
     384         [ #  # ]:          0 :         if (pipe_full(pipe->head, pipe->tail, pipe->max_usage))
     385                 :            :                 return -EAGAIN;
     386                 :            : 
     387                 :            :         /*
     388                 :            :          * Try to keep page boundaries matching to source pagecache ones -
     389                 :            :          * it probably won't be much help, but...
     390                 :            :          */
     391                 :          0 :         offset = *ppos & ~PAGE_MASK;
     392                 :            : 
     393                 :          0 :         iov_iter_pipe(&to, READ, pipe, len + offset);
     394                 :            : 
     395                 :          0 :         res = iov_iter_get_pages_alloc(&to, &pages, len + offset, &base);
     396         [ #  # ]:          0 :         if (res <= 0)
     397                 :            :                 return -ENOMEM;
     398                 :            : 
     399                 :          0 :         nr_pages = DIV_ROUND_UP(res + base, PAGE_SIZE);
     400                 :            : 
     401                 :          0 :         vec = __vec;
     402         [ #  # ]:          0 :         if (nr_pages > PIPE_DEF_BUFFERS) {
     403                 :          0 :                 vec = kmalloc_array(nr_pages, sizeof(struct kvec), GFP_KERNEL);
     404         [ #  # ]:          0 :                 if (unlikely(!vec)) {
     405                 :          0 :                         res = -ENOMEM;
     406                 :          0 :                         goto out;
     407                 :            :                 }
     408                 :            :         }
     409                 :            : 
     410                 :          0 :         mask = pipe->ring_size - 1;
     411                 :          0 :         pipe->bufs[to.head & mask].offset = offset;
     412                 :          0 :         pipe->bufs[to.head & mask].len -= offset;
     413                 :            : 
     414         [ #  # ]:          0 :         for (i = 0; i < nr_pages; i++) {
     415                 :          0 :                 size_t this_len = min_t(size_t, len, PAGE_SIZE - offset);
     416                 :          0 :                 vec[i].iov_base = page_address(pages[i]) + offset;
     417                 :          0 :                 vec[i].iov_len = this_len;
     418                 :          0 :                 len -= this_len;
     419                 :          0 :                 offset = 0;
     420                 :            :         }
     421                 :            : 
     422                 :          0 :         res = kernel_readv(in, vec, nr_pages, *ppos);
     423         [ #  # ]:          0 :         if (res > 0) {
     424                 :          0 :                 copied = res;
     425                 :          0 :                 *ppos += res;
     426                 :            :         }
     427                 :            : 
     428         [ #  # ]:          0 :         if (vec != __vec)
     429                 :          0 :                 kfree(vec);
     430                 :          0 : out:
     431         [ #  # ]:          0 :         for (i = 0; i < nr_pages; i++)
     432                 :          0 :                 put_page(pages[i]);
     433                 :          0 :         kvfree(pages);
     434                 :          0 :         iov_iter_advance(&to, copied);      /* truncates and discards */
     435                 :          0 :         return res;
     436                 :            : }
     437                 :            : 
     438                 :            : /*
     439                 :            :  * Send 'sd->len' bytes to socket from 'sd->file' at position 'sd->pos'
     440                 :            :  * using sendpage(). Return the number of bytes sent.
     441                 :            :  */
     442                 :          0 : static int pipe_to_sendpage(struct pipe_inode_info *pipe,
     443                 :            :                             struct pipe_buffer *buf, struct splice_desc *sd)
     444                 :            : {
     445                 :          0 :         struct file *file = sd->u.file;
     446                 :          0 :         loff_t pos = sd->pos;
     447                 :          0 :         int more;
     448                 :            : 
     449         [ #  # ]:          0 :         if (!likely(file->f_op->sendpage))
     450                 :            :                 return -EINVAL;
     451                 :            : 
     452                 :          0 :         more = (sd->flags & SPLICE_F_MORE) ? MSG_MORE : 0;
     453                 :            : 
     454   [ #  #  #  # ]:          0 :         if (sd->len < sd->total_len &&
     455         [ #  # ]:          0 :             pipe_occupancy(pipe->head, pipe->tail) > 1)
     456                 :          0 :                 more |= MSG_SENDPAGE_NOTLAST;
     457                 :            : 
     458                 :          0 :         return file->f_op->sendpage(file, buf->page, buf->offset,
     459                 :            :                                     sd->len, &pos, more);
     460                 :            : }
     461                 :            : 
     462                 :          0 : static void wakeup_pipe_writers(struct pipe_inode_info *pipe)
     463                 :            : {
     464                 :          0 :         smp_mb();
     465         [ #  # ]:          0 :         if (waitqueue_active(&pipe->wr_wait))
     466                 :          0 :                 wake_up_interruptible(&pipe->wr_wait);
     467                 :          0 :         kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
     468                 :          0 : }
     469                 :            : 
     470                 :            : /**
     471                 :            :  * splice_from_pipe_feed - feed available data from a pipe to a file
     472                 :            :  * @pipe:       pipe to splice from
     473                 :            :  * @sd:         information to @actor
     474                 :            :  * @actor:      handler that splices the data
     475                 :            :  *
     476                 :            :  * Description:
     477                 :            :  *    This function loops over the pipe and calls @actor to do the
     478                 :            :  *    actual moving of a single struct pipe_buffer to the desired
     479                 :            :  *    destination.  It returns when there's no more buffers left in
     480                 :            :  *    the pipe or if the requested number of bytes (@sd->total_len)
     481                 :            :  *    have been copied.  It returns a positive number (one) if the
     482                 :            :  *    pipe needs to be filled with more data, zero if the required
     483                 :            :  *    number of bytes have been copied and -errno on error.
     484                 :            :  *
     485                 :            :  *    This, together with splice_from_pipe_{begin,end,next}, may be
     486                 :            :  *    used to implement the functionality of __splice_from_pipe() when
     487                 :            :  *    locking is required around copying the pipe buffers to the
     488                 :            :  *    destination.
     489                 :            :  */
     490                 :          0 : static int splice_from_pipe_feed(struct pipe_inode_info *pipe, struct splice_desc *sd,
     491                 :            :                           splice_actor *actor)
     492                 :            : {
     493                 :          0 :         unsigned int head = pipe->head;
     494                 :          0 :         unsigned int tail = pipe->tail;
     495                 :          0 :         unsigned int mask = pipe->ring_size - 1;
     496                 :          0 :         int ret;
     497                 :            : 
     498         [ #  # ]:          0 :         while (!pipe_empty(head, tail)) {
     499                 :          0 :                 struct pipe_buffer *buf = &pipe->bufs[tail & mask];
     500                 :            : 
     501                 :          0 :                 sd->len = buf->len;
     502         [ #  # ]:          0 :                 if (sd->len > sd->total_len)
     503                 :          0 :                         sd->len = sd->total_len;
     504                 :            : 
     505                 :          0 :                 ret = pipe_buf_confirm(pipe, buf);
     506         [ #  # ]:          0 :                 if (unlikely(ret)) {
     507         [ #  # ]:          0 :                         if (ret == -ENODATA)
     508                 :          0 :                                 ret = 0;
     509                 :          0 :                         return ret;
     510                 :            :                 }
     511                 :            : 
     512                 :          0 :                 ret = actor(pipe, buf, sd);
     513         [ #  # ]:          0 :                 if (ret <= 0)
     514                 :          0 :                         return ret;
     515                 :            : 
     516                 :          0 :                 buf->offset += ret;
     517                 :          0 :                 buf->len -= ret;
     518                 :            : 
     519                 :          0 :                 sd->num_spliced += ret;
     520                 :          0 :                 sd->len -= ret;
     521                 :          0 :                 sd->pos += ret;
     522                 :          0 :                 sd->total_len -= ret;
     523                 :            : 
     524         [ #  # ]:          0 :                 if (!buf->len) {
     525                 :          0 :                         pipe_buf_release(pipe, buf);
     526                 :          0 :                         tail++;
     527                 :          0 :                         pipe->tail = tail;
     528         [ #  # ]:          0 :                         if (pipe->files)
     529                 :          0 :                                 sd->need_wakeup = true;
     530                 :            :                 }
     531                 :            : 
     532         [ #  # ]:          0 :                 if (!sd->total_len)
     533                 :            :                         return 0;
     534                 :            :         }
     535                 :            : 
     536                 :            :         return 1;
     537                 :            : }
     538                 :            : 
     539                 :            : /**
     540                 :            :  * splice_from_pipe_next - wait for some data to splice from
     541                 :            :  * @pipe:       pipe to splice from
     542                 :            :  * @sd:         information about the splice operation
     543                 :            :  *
     544                 :            :  * Description:
     545                 :            :  *    This function will wait for some data and return a positive
     546                 :            :  *    value (one) if pipe buffers are available.  It will return zero
     547                 :            :  *    or -errno if no more data needs to be spliced.
     548                 :            :  */
     549                 :         12 : static int splice_from_pipe_next(struct pipe_inode_info *pipe, struct splice_desc *sd)
     550                 :            : {
     551                 :            :         /*
     552                 :            :          * Check for signal early to make process killable when there are
     553                 :            :          * always buffers available
     554                 :            :          */
     555         [ +  - ]:         12 :         if (signal_pending(current))
     556                 :            :                 return -ERESTARTSYS;
     557                 :            : 
     558         [ -  + ]:         12 :         while (pipe_empty(pipe->head, pipe->tail)) {
     559         [ #  # ]:          0 :                 if (!pipe->writers)
     560                 :            :                         return 0;
     561                 :            : 
     562         [ #  # ]:          0 :                 if (sd->num_spliced)
     563                 :            :                         return 0;
     564                 :            : 
     565         [ #  # ]:          0 :                 if (sd->flags & SPLICE_F_NONBLOCK)
     566                 :            :                         return -EAGAIN;
     567                 :            : 
     568         [ #  # ]:          0 :                 if (signal_pending(current))
     569                 :            :                         return -ERESTARTSYS;
     570                 :            : 
     571         [ #  # ]:          0 :                 if (sd->need_wakeup) {
     572                 :          0 :                         wakeup_pipe_writers(pipe);
     573                 :          0 :                         sd->need_wakeup = false;
     574                 :            :                 }
     575                 :            : 
     576                 :          0 :                 pipe_wait(pipe);
     577                 :            :         }
     578                 :            : 
     579                 :            :         return 1;
     580                 :            : }
     581                 :            : 
     582                 :            : /**
     583                 :            :  * splice_from_pipe_begin - start splicing from pipe
     584                 :            :  * @sd:         information about the splice operation
     585                 :            :  *
     586                 :            :  * Description:
     587                 :            :  *    This function should be called before a loop containing
     588                 :            :  *    splice_from_pipe_next() and splice_from_pipe_feed() to
     589                 :            :  *    initialize the necessary fields of @sd.
     590                 :            :  */
     591                 :         12 : static void splice_from_pipe_begin(struct splice_desc *sd)
     592                 :            : {
     593                 :         12 :         sd->num_spliced = 0;
     594                 :         12 :         sd->need_wakeup = false;
     595                 :         12 : }
     596                 :            : 
     597                 :            : /**
     598                 :            :  * splice_from_pipe_end - finish splicing from pipe
     599                 :            :  * @pipe:       pipe to splice from
     600                 :            :  * @sd:         information about the splice operation
     601                 :            :  *
     602                 :            :  * Description:
     603                 :            :  *    This function will wake up pipe writers if necessary.  It should
     604                 :            :  *    be called after a loop containing splice_from_pipe_next() and
     605                 :            :  *    splice_from_pipe_feed().
     606                 :            :  */
     607                 :         12 : static void splice_from_pipe_end(struct pipe_inode_info *pipe, struct splice_desc *sd)
     608                 :            : {
     609                 :         12 :         if (sd->need_wakeup)
     610                 :          0 :                 wakeup_pipe_writers(pipe);
     611                 :            : }
     612                 :            : 
     613                 :            : /**
     614                 :            :  * __splice_from_pipe - splice data from a pipe to given actor
     615                 :            :  * @pipe:       pipe to splice from
     616                 :            :  * @sd:         information to @actor
     617                 :            :  * @actor:      handler that splices the data
     618                 :            :  *
     619                 :            :  * Description:
     620                 :            :  *    This function does little more than loop over the pipe and call
     621                 :            :  *    @actor to do the actual moving of a single struct pipe_buffer to
     622                 :            :  *    the desired destination. See pipe_to_file, pipe_to_sendpage, or
     623                 :            :  *    pipe_to_user.
     624                 :            :  *
     625                 :            :  */
     626                 :          0 : ssize_t __splice_from_pipe(struct pipe_inode_info *pipe, struct splice_desc *sd,
     627                 :            :                            splice_actor *actor)
     628                 :            : {
     629                 :          0 :         int ret;
     630                 :            : 
     631                 :          0 :         splice_from_pipe_begin(sd);
     632                 :          0 :         do {
     633                 :          0 :                 cond_resched();
     634                 :          0 :                 ret = splice_from_pipe_next(pipe, sd);
     635         [ #  # ]:          0 :                 if (ret > 0)
     636                 :          0 :                         ret = splice_from_pipe_feed(pipe, sd, actor);
     637         [ #  # ]:          0 :         } while (ret > 0);
     638         [ #  # ]:          0 :         splice_from_pipe_end(pipe, sd);
     639                 :            : 
     640         [ #  # ]:          0 :         return sd->num_spliced ? sd->num_spliced : ret;
     641                 :            : }
     642                 :            : EXPORT_SYMBOL(__splice_from_pipe);
     643                 :            : 
     644                 :            : /**
     645                 :            :  * splice_from_pipe - splice data from a pipe to a file
     646                 :            :  * @pipe:       pipe to splice from
     647                 :            :  * @out:        file to splice to
     648                 :            :  * @ppos:       position in @out
     649                 :            :  * @len:        how many bytes to splice
     650                 :            :  * @flags:      splice modifier flags
     651                 :            :  * @actor:      handler that splices the data
     652                 :            :  *
     653                 :            :  * Description:
     654                 :            :  *    See __splice_from_pipe. This function locks the pipe inode,
     655                 :            :  *    otherwise it's identical to __splice_from_pipe().
     656                 :            :  *
     657                 :            :  */
     658                 :          0 : ssize_t splice_from_pipe(struct pipe_inode_info *pipe, struct file *out,
     659                 :            :                          loff_t *ppos, size_t len, unsigned int flags,
     660                 :            :                          splice_actor *actor)
     661                 :            : {
     662                 :          0 :         ssize_t ret;
     663                 :          0 :         struct splice_desc sd = {
     664                 :            :                 .total_len = len,
     665                 :            :                 .flags = flags,
     666                 :          0 :                 .pos = *ppos,
     667                 :            :                 .u.file = out,
     668                 :            :         };
     669                 :            : 
     670                 :          0 :         pipe_lock(pipe);
     671                 :          0 :         ret = __splice_from_pipe(pipe, &sd, actor);
     672                 :          0 :         pipe_unlock(pipe);
     673                 :            : 
     674                 :          0 :         return ret;
     675                 :            : }
     676                 :            : 
     677                 :            : /**
     678                 :            :  * iter_file_splice_write - splice data from a pipe to a file
     679                 :            :  * @pipe:       pipe info
     680                 :            :  * @out:        file to write to
     681                 :            :  * @ppos:       position in @out
     682                 :            :  * @len:        number of bytes to splice
     683                 :            :  * @flags:      splice modifier flags
     684                 :            :  *
     685                 :            :  * Description:
     686                 :            :  *    Will either move or copy pages (determined by @flags options) from
     687                 :            :  *    the given pipe inode to the given file.
     688                 :            :  *    This one is ->write_iter-based.
     689                 :            :  *
     690                 :            :  */
     691                 :            : ssize_t
     692                 :         12 : iter_file_splice_write(struct pipe_inode_info *pipe, struct file *out,
     693                 :            :                           loff_t *ppos, size_t len, unsigned int flags)
     694                 :            : {
     695                 :         12 :         struct splice_desc sd = {
     696                 :            :                 .total_len = len,
     697                 :            :                 .flags = flags,
     698                 :         12 :                 .pos = *ppos,
     699                 :            :                 .u.file = out,
     700                 :            :         };
     701                 :         12 :         int nbufs = pipe->max_usage;
     702                 :         12 :         struct bio_vec *array = kcalloc(nbufs, sizeof(struct bio_vec),
     703                 :            :                                         GFP_KERNEL);
     704                 :         12 :         ssize_t ret;
     705                 :            : 
     706         [ +  - ]:         12 :         if (unlikely(!array))
     707                 :            :                 return -ENOMEM;
     708                 :            : 
     709                 :         12 :         pipe_lock(pipe);
     710                 :            : 
     711                 :         12 :         splice_from_pipe_begin(&sd);
     712         [ +  + ]:         24 :         while (sd.total_len) {
     713                 :         12 :                 struct iov_iter from;
     714                 :         12 :                 unsigned int head, tail, mask;
     715                 :         12 :                 size_t left;
     716                 :         12 :                 int n;
     717                 :            : 
     718                 :         12 :                 ret = splice_from_pipe_next(pipe, &sd);
     719         [ +  - ]:         12 :                 if (ret <= 0)
     720                 :            :                         break;
     721                 :            : 
     722         [ -  + ]:         12 :                 if (unlikely(nbufs < pipe->max_usage)) {
     723                 :          0 :                         kfree(array);
     724                 :          0 :                         nbufs = pipe->max_usage;
     725                 :          0 :                         array = kcalloc(nbufs, sizeof(struct bio_vec),
     726                 :            :                                         GFP_KERNEL);
     727         [ #  # ]:          0 :                         if (!array) {
     728                 :            :                                 ret = -ENOMEM;
     729                 :            :                                 break;
     730                 :            :                         }
     731                 :            :                 }
     732                 :            : 
     733                 :         12 :                 head = pipe->head;
     734                 :         12 :                 tail = pipe->tail;
     735                 :         12 :                 mask = pipe->ring_size - 1;
     736                 :            : 
     737                 :            :                 /* build the vector */
     738                 :         12 :                 left = sd.total_len;
     739   [ +  +  +  - ]:         24 :                 for (n = 0; !pipe_empty(head, tail) && left && n < nbufs; tail++, n++) {
     740                 :         12 :                         struct pipe_buffer *buf = &pipe->bufs[tail & mask];
     741                 :         12 :                         size_t this_len = buf->len;
     742                 :            : 
     743                 :         12 :                         if (this_len > left)
     744                 :            :                                 this_len = left;
     745                 :            : 
     746                 :         12 :                         ret = pipe_buf_confirm(pipe, buf);
     747         [ -  + ]:         12 :                         if (unlikely(ret)) {
     748         [ #  # ]:          0 :                                 if (ret == -ENODATA)
     749                 :          0 :                                         ret = 0;
     750                 :          0 :                                 goto done;
     751                 :            :                         }
     752                 :            : 
     753                 :         12 :                         array[n].bv_page = buf->page;
     754                 :         12 :                         array[n].bv_len = this_len;
     755                 :         12 :                         array[n].bv_offset = buf->offset;
     756                 :         12 :                         left -= this_len;
     757                 :            :                 }
     758                 :            : 
     759                 :         12 :                 iov_iter_bvec(&from, WRITE, array, n, sd.total_len - left);
     760                 :         12 :                 ret = vfs_iter_write(out, &from, &sd.pos, 0);
     761         [ +  - ]:         12 :                 if (ret <= 0)
     762                 :            :                         break;
     763                 :            : 
     764                 :         12 :                 sd.num_spliced += ret;
     765                 :         12 :                 sd.total_len -= ret;
     766                 :         12 :                 *ppos = sd.pos;
     767                 :            : 
     768                 :            :                 /* dismiss the fully eaten buffers, adjust the partial one */
     769                 :         12 :                 tail = pipe->tail;
     770         [ +  + ]:         24 :                 while (ret) {
     771                 :         12 :                         struct pipe_buffer *buf = &pipe->bufs[tail & mask];
     772         [ +  - ]:         12 :                         if (ret >= buf->len) {
     773                 :         12 :                                 ret -= buf->len;
     774                 :         12 :                                 buf->len = 0;
     775                 :         12 :                                 pipe_buf_release(pipe, buf);
     776                 :         12 :                                 tail++;
     777                 :         12 :                                 pipe->tail = tail;
     778         [ -  + ]:         12 :                                 if (pipe->files)
     779                 :          0 :                                         sd.need_wakeup = true;
     780                 :            :                         } else {
     781                 :          0 :                                 buf->offset += ret;
     782                 :          0 :                                 buf->len -= ret;
     783                 :          0 :                                 ret = 0;
     784                 :            :                         }
     785                 :            :                 }
     786                 :            :         }
     787                 :         12 : done:
     788                 :         12 :         kfree(array);
     789         [ -  + ]:         12 :         splice_from_pipe_end(pipe, &sd);
     790                 :            : 
     791                 :         12 :         pipe_unlock(pipe);
     792                 :            : 
     793         [ +  - ]:         12 :         if (sd.num_spliced)
     794                 :         12 :                 ret = sd.num_spliced;
     795                 :            : 
     796                 :            :         return ret;
     797                 :            : }
     798                 :            : 
     799                 :            : EXPORT_SYMBOL(iter_file_splice_write);
     800                 :            : 
     801                 :          0 : static int write_pipe_buf(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
     802                 :            :                           struct splice_desc *sd)
     803                 :            : {
     804                 :          0 :         int ret;
     805                 :          0 :         void *data;
     806                 :          0 :         loff_t tmp = sd->pos;
     807                 :            : 
     808                 :          0 :         data = kmap(buf->page);
     809                 :          0 :         ret = __kernel_write(sd->u.file, data + buf->offset, sd->len, &tmp);
     810                 :          0 :         kunmap(buf->page);
     811                 :            : 
     812                 :          0 :         return ret;
     813                 :            : }
     814                 :            : 
     815                 :          0 : static ssize_t default_file_splice_write(struct pipe_inode_info *pipe,
     816                 :            :                                          struct file *out, loff_t *ppos,
     817                 :            :                                          size_t len, unsigned int flags)
     818                 :            : {
     819                 :          0 :         ssize_t ret;
     820                 :            : 
     821                 :          0 :         ret = splice_from_pipe(pipe, out, ppos, len, flags, write_pipe_buf);
     822         [ #  # ]:          0 :         if (ret > 0)
     823                 :          0 :                 *ppos += ret;
     824                 :            : 
     825                 :          0 :         return ret;
     826                 :            : }
     827                 :            : 
     828                 :            : /**
     829                 :            :  * generic_splice_sendpage - splice data from a pipe to a socket
     830                 :            :  * @pipe:       pipe to splice from
     831                 :            :  * @out:        socket to write to
     832                 :            :  * @ppos:       position in @out
     833                 :            :  * @len:        number of bytes to splice
     834                 :            :  * @flags:      splice modifier flags
     835                 :            :  *
     836                 :            :  * Description:
     837                 :            :  *    Will send @len bytes from the pipe to a network socket. No data copying
     838                 :            :  *    is involved.
     839                 :            :  *
     840                 :            :  */
     841                 :          0 : ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe, struct file *out,
     842                 :            :                                 loff_t *ppos, size_t len, unsigned int flags)
     843                 :            : {
     844                 :          0 :         return splice_from_pipe(pipe, out, ppos, len, flags, pipe_to_sendpage);
     845                 :            : }
     846                 :            : 
     847                 :            : EXPORT_SYMBOL(generic_splice_sendpage);
     848                 :            : 
     849                 :            : /*
     850                 :            :  * Attempt to initiate a splice from pipe to file.
     851                 :            :  */
     852                 :         12 : static long do_splice_from(struct pipe_inode_info *pipe, struct file *out,
     853                 :            :                            loff_t *ppos, size_t len, unsigned int flags)
     854                 :            : {
     855                 :         12 :         ssize_t (*splice_write)(struct pipe_inode_info *, struct file *,
     856                 :            :                                 loff_t *, size_t, unsigned int);
     857                 :            : 
     858                 :         12 :         if (out->f_op->splice_write)
     859                 :         12 :                 splice_write = out->f_op->splice_write;
     860                 :            :         else
     861                 :            :                 splice_write = default_file_splice_write;
     862                 :            : 
     863                 :         12 :         return splice_write(pipe, out, ppos, len, flags);
     864                 :            : }
     865                 :            : 
     866                 :            : /*
     867                 :            :  * Attempt to initiate a splice from a file to a pipe.
     868                 :            :  */
     869                 :         12 : static long do_splice_to(struct file *in, loff_t *ppos,
     870                 :            :                          struct pipe_inode_info *pipe, size_t len,
     871                 :            :                          unsigned int flags)
     872                 :            : {
     873                 :         12 :         ssize_t (*splice_read)(struct file *, loff_t *,
     874                 :            :                                struct pipe_inode_info *, size_t, unsigned int);
     875                 :         12 :         int ret;
     876                 :            : 
     877         [ +  - ]:         12 :         if (unlikely(!(in->f_mode & FMODE_READ)))
     878                 :            :                 return -EBADF;
     879                 :            : 
     880                 :         12 :         ret = rw_verify_area(READ, in, ppos, len);
     881         [ -  + ]:         12 :         if (unlikely(ret < 0))
     882                 :          0 :                 return ret;
     883                 :            : 
     884         [ -  + ]:         12 :         if (unlikely(len > MAX_RW_COUNT))
     885                 :          0 :                 len = MAX_RW_COUNT;
     886                 :            : 
     887         [ +  - ]:         12 :         if (in->f_op->splice_read)
     888                 :         12 :                 splice_read = in->f_op->splice_read;
     889                 :            :         else
     890                 :            :                 splice_read = default_file_splice_read;
     891                 :            : 
     892                 :         12 :         return splice_read(in, ppos, pipe, len, flags);
     893                 :            : }
     894                 :            : 
     895                 :            : /**
     896                 :            :  * splice_direct_to_actor - splices data directly between two non-pipes
     897                 :            :  * @in:         file to splice from
     898                 :            :  * @sd:         actor information on where to splice to
     899                 :            :  * @actor:      handles the data splicing
     900                 :            :  *
     901                 :            :  * Description:
     902                 :            :  *    This is a special case helper to splice directly between two
     903                 :            :  *    points, without requiring an explicit pipe. Internally an allocated
     904                 :            :  *    pipe is cached in the process, and reused during the lifetime of
     905                 :            :  *    that process.
     906                 :            :  *
     907                 :            :  */
     908                 :         12 : ssize_t splice_direct_to_actor(struct file *in, struct splice_desc *sd,
     909                 :            :                                splice_direct_actor *actor)
     910                 :            : {
     911                 :         12 :         struct pipe_inode_info *pipe;
     912                 :         12 :         long ret, bytes;
     913                 :         12 :         umode_t i_mode;
     914                 :         12 :         size_t len;
     915                 :         12 :         int i, flags, more;
     916                 :            : 
     917                 :            :         /*
     918                 :            :          * We require the input being a regular file, as we don't want to
     919                 :            :          * randomly drop data for eg socket -> socket splicing. Use the
     920                 :            :          * piped splicing for that!
     921                 :            :          */
     922         [ +  - ]:         12 :         i_mode = file_inode(in)->i_mode;
     923         [ +  - ]:         12 :         if (unlikely(!S_ISREG(i_mode) && !S_ISBLK(i_mode)))
     924                 :            :                 return -EINVAL;
     925                 :            : 
     926                 :            :         /*
     927                 :            :          * neither in nor out is a pipe, setup an internal pipe attached to
     928                 :            :          * 'out' and transfer the wanted data from 'in' to 'out' through that
     929                 :            :          */
     930         [ +  + ]:         12 :         pipe = current->splice_pipe;
     931         [ +  + ]:         12 :         if (unlikely(!pipe)) {
     932                 :          3 :                 pipe = alloc_pipe_info();
     933         [ +  - ]:          3 :                 if (!pipe)
     934                 :            :                         return -ENOMEM;
     935                 :            : 
     936                 :            :                 /*
     937                 :            :                  * We don't have an immediate reader, but we'll read the stuff
     938                 :            :                  * out of the pipe right after the splice_to_pipe(). So set
     939                 :            :                  * PIPE_READERS appropriately.
     940                 :            :                  */
     941                 :          3 :                 pipe->readers = 1;
     942                 :            : 
     943                 :          3 :                 current->splice_pipe = pipe;
     944                 :            :         }
     945                 :            : 
     946                 :            :         /*
     947                 :            :          * Do the splice.
     948                 :            :          */
     949                 :         12 :         ret = 0;
     950                 :         12 :         bytes = 0;
     951                 :         12 :         len = sd->total_len;
     952                 :         12 :         flags = sd->flags;
     953                 :            : 
     954                 :            :         /*
     955                 :            :          * Don't block on output, we have to drain the direct pipe.
     956                 :            :          */
     957                 :         12 :         sd->flags &= ~SPLICE_F_NONBLOCK;
     958                 :         12 :         more = sd->flags & SPLICE_F_MORE;
     959                 :            : 
     960         [ -  + ]:         12 :         WARN_ON_ONCE(!pipe_empty(pipe->head, pipe->tail));
     961                 :            : 
     962         [ +  + ]:         24 :         while (len) {
     963                 :         12 :                 unsigned int p_space;
     964                 :         12 :                 size_t read_len;
     965                 :         12 :                 loff_t pos = sd->pos, prev_pos = pos;
     966                 :            : 
     967                 :            :                 /* Don't try to read more the pipe has space for. */
     968                 :         12 :                 p_space = pipe->max_usage -
     969                 :         12 :                         pipe_occupancy(pipe->head, pipe->tail);
     970                 :         12 :                 read_len = min_t(size_t, len, p_space << PAGE_SHIFT);
     971                 :         12 :                 ret = do_splice_to(in, &pos, pipe, read_len, flags);
     972         [ -  + ]:         12 :                 if (unlikely(ret <= 0))
     973                 :          0 :                         goto out_release;
     974                 :            : 
     975                 :         12 :                 read_len = ret;
     976                 :         12 :                 sd->total_len = read_len;
     977                 :            : 
     978                 :            :                 /*
     979                 :            :                  * If more data is pending, set SPLICE_F_MORE
     980                 :            :                  * If this is the last data and SPLICE_F_MORE was not set
     981                 :            :                  * initially, clears it.
     982                 :            :                  */
     983         [ -  + ]:         12 :                 if (read_len < len)
     984                 :          0 :                         sd->flags |= SPLICE_F_MORE;
     985         [ +  - ]:         12 :                 else if (!more)
     986                 :         12 :                         sd->flags &= ~SPLICE_F_MORE;
     987                 :            :                 /*
     988                 :            :                  * NOTE: nonblocking mode only applies to the input. We
     989                 :            :                  * must not do the output in nonblocking mode as then we
     990                 :            :                  * could get stuck data in the internal pipe:
     991                 :            :                  */
     992                 :         12 :                 ret = actor(pipe, sd);
     993         [ -  + ]:         12 :                 if (unlikely(ret <= 0)) {
     994                 :          0 :                         sd->pos = prev_pos;
     995                 :          0 :                         goto out_release;
     996                 :            :                 }
     997                 :            : 
     998                 :         12 :                 bytes += ret;
     999                 :         12 :                 len -= ret;
    1000                 :         12 :                 sd->pos = pos;
    1001                 :            : 
    1002         [ -  + ]:         12 :                 if (ret < read_len) {
    1003                 :          0 :                         sd->pos = prev_pos + ret;
    1004                 :          0 :                         goto out_release;
    1005                 :            :                 }
    1006                 :            :         }
    1007                 :            : 
    1008                 :         12 : done:
    1009                 :         12 :         pipe->tail = pipe->head = 0;
    1010         [ +  - ]:         12 :         file_accessed(in);
    1011                 :            :         return bytes;
    1012                 :            : 
    1013                 :            : out_release:
    1014                 :            :         /*
    1015                 :            :          * If we did an incomplete transfer we must release
    1016                 :            :          * the pipe buffers in question:
    1017                 :            :          */
    1018         [ #  # ]:          0 :         for (i = 0; i < pipe->ring_size; i++) {
    1019                 :          0 :                 struct pipe_buffer *buf = &pipe->bufs[i];
    1020                 :            : 
    1021         [ #  # ]:          0 :                 if (buf->ops)
    1022                 :          0 :                         pipe_buf_release(pipe, buf);
    1023                 :            :         }
    1024                 :            : 
    1025         [ #  # ]:          0 :         if (!bytes)
    1026                 :          0 :                 bytes = ret;
    1027                 :            : 
    1028                 :          0 :         goto done;
    1029                 :            : }
    1030                 :            : EXPORT_SYMBOL(splice_direct_to_actor);
    1031                 :            : 
    1032                 :         12 : static int direct_splice_actor(struct pipe_inode_info *pipe,
    1033                 :            :                                struct splice_desc *sd)
    1034                 :            : {
    1035                 :         12 :         struct file *file = sd->u.file;
    1036                 :            : 
    1037         [ +  - ]:         12 :         return do_splice_from(pipe, file, sd->opos, sd->total_len,
    1038                 :            :                               sd->flags);
    1039                 :            : }
    1040                 :            : 
    1041                 :            : /**
    1042                 :            :  * do_splice_direct - splices data directly between two files
    1043                 :            :  * @in:         file to splice from
    1044                 :            :  * @ppos:       input file offset
    1045                 :            :  * @out:        file to splice to
    1046                 :            :  * @opos:       output file offset
    1047                 :            :  * @len:        number of bytes to splice
    1048                 :            :  * @flags:      splice modifier flags
    1049                 :            :  *
    1050                 :            :  * Description:
    1051                 :            :  *    For use by do_sendfile(). splice can easily emulate sendfile, but
    1052                 :            :  *    doing it in the application would incur an extra system call
    1053                 :            :  *    (splice in + splice out, as compared to just sendfile()). So this helper
    1054                 :            :  *    can splice directly through a process-private pipe.
    1055                 :            :  *
    1056                 :            :  */
    1057                 :         12 : long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
    1058                 :            :                       loff_t *opos, size_t len, unsigned int flags)
    1059                 :            : {
    1060                 :         12 :         struct splice_desc sd = {
    1061                 :            :                 .len            = len,
    1062                 :            :                 .total_len      = len,
    1063                 :            :                 .flags          = flags,
    1064                 :         12 :                 .pos            = *ppos,
    1065                 :            :                 .u.file         = out,
    1066                 :            :                 .opos           = opos,
    1067                 :            :         };
    1068                 :         12 :         long ret;
    1069                 :            : 
    1070         [ +  - ]:         12 :         if (unlikely(!(out->f_mode & FMODE_WRITE)))
    1071                 :            :                 return -EBADF;
    1072                 :            : 
    1073         [ +  - ]:         12 :         if (unlikely(out->f_flags & O_APPEND))
    1074                 :            :                 return -EINVAL;
    1075                 :            : 
    1076                 :         12 :         ret = rw_verify_area(WRITE, out, opos, len);
    1077         [ +  - ]:         12 :         if (unlikely(ret < 0))
    1078                 :            :                 return ret;
    1079                 :            : 
    1080                 :         12 :         ret = splice_direct_to_actor(in, &sd, direct_splice_actor);
    1081         [ +  - ]:         12 :         if (ret > 0)
    1082                 :         12 :                 *ppos = sd.pos;
    1083                 :            : 
    1084                 :            :         return ret;
    1085                 :            : }
    1086                 :            : EXPORT_SYMBOL(do_splice_direct);
    1087                 :            : 
    1088                 :          0 : static int wait_for_space(struct pipe_inode_info *pipe, unsigned flags)
    1089                 :            : {
    1090                 :          0 :         for (;;) {
    1091         [ #  # ]:          0 :                 if (unlikely(!pipe->readers)) {
    1092                 :          0 :                         send_sig(SIGPIPE, current, 0);
    1093                 :          0 :                         return -EPIPE;
    1094                 :            :                 }
    1095         [ #  # ]:          0 :                 if (!pipe_full(pipe->head, pipe->tail, pipe->max_usage))
    1096                 :            :                         return 0;
    1097         [ #  # ]:          0 :                 if (flags & SPLICE_F_NONBLOCK)
    1098                 :            :                         return -EAGAIN;
    1099         [ #  # ]:          0 :                 if (signal_pending(current))
    1100                 :            :                         return -ERESTARTSYS;
    1101                 :          0 :                 pipe_wait(pipe);
    1102                 :            :         }
    1103                 :            : }
    1104                 :            : 
    1105                 :            : static int splice_pipe_to_pipe(struct pipe_inode_info *ipipe,
    1106                 :            :                                struct pipe_inode_info *opipe,
    1107                 :            :                                size_t len, unsigned int flags);
    1108                 :            : 
    1109                 :            : /*
    1110                 :            :  * Determine where to splice to/from.
    1111                 :            :  */
    1112                 :          0 : static long do_splice(struct file *in, loff_t __user *off_in,
    1113                 :            :                       struct file *out, loff_t __user *off_out,
    1114                 :            :                       size_t len, unsigned int flags)
    1115                 :            : {
    1116                 :          0 :         struct pipe_inode_info *ipipe;
    1117                 :          0 :         struct pipe_inode_info *opipe;
    1118                 :          0 :         loff_t offset;
    1119                 :          0 :         long ret;
    1120                 :            : 
    1121                 :          0 :         ipipe = get_pipe_info(in);
    1122                 :          0 :         opipe = get_pipe_info(out);
    1123                 :            : 
    1124         [ #  # ]:          0 :         if (ipipe && opipe) {
    1125         [ #  # ]:          0 :                 if (off_in || off_out)
    1126                 :            :                         return -ESPIPE;
    1127                 :            : 
    1128         [ #  # ]:          0 :                 if (!(in->f_mode & FMODE_READ))
    1129                 :            :                         return -EBADF;
    1130                 :            : 
    1131         [ #  # ]:          0 :                 if (!(out->f_mode & FMODE_WRITE))
    1132                 :            :                         return -EBADF;
    1133                 :            : 
    1134                 :            :                 /* Splicing to self would be fun, but... */
    1135         [ #  # ]:          0 :                 if (ipipe == opipe)
    1136                 :            :                         return -EINVAL;
    1137                 :            : 
    1138         [ #  # ]:          0 :                 if ((in->f_flags | out->f_flags) & O_NONBLOCK)
    1139                 :          0 :                         flags |= SPLICE_F_NONBLOCK;
    1140                 :            : 
    1141                 :          0 :                 return splice_pipe_to_pipe(ipipe, opipe, len, flags);
    1142                 :            :         }
    1143                 :            : 
    1144         [ #  # ]:          0 :         if (ipipe) {
    1145         [ #  # ]:          0 :                 if (off_in)
    1146                 :            :                         return -ESPIPE;
    1147         [ #  # ]:          0 :                 if (off_out) {
    1148         [ #  # ]:          0 :                         if (!(out->f_mode & FMODE_PWRITE))
    1149                 :            :                                 return -EINVAL;
    1150         [ #  # ]:          0 :                         if (copy_from_user(&offset, off_out, sizeof(loff_t)))
    1151                 :            :                                 return -EFAULT;
    1152                 :            :                 } else {
    1153                 :          0 :                         offset = out->f_pos;
    1154                 :            :                 }
    1155                 :            : 
    1156         [ #  # ]:          0 :                 if (unlikely(!(out->f_mode & FMODE_WRITE)))
    1157                 :            :                         return -EBADF;
    1158                 :            : 
    1159         [ #  # ]:          0 :                 if (unlikely(out->f_flags & O_APPEND))
    1160                 :            :                         return -EINVAL;
    1161                 :            : 
    1162                 :          0 :                 ret = rw_verify_area(WRITE, out, &offset, len);
    1163         [ #  # ]:          0 :                 if (unlikely(ret < 0))
    1164                 :            :                         return ret;
    1165                 :            : 
    1166         [ #  # ]:          0 :                 if (in->f_flags & O_NONBLOCK)
    1167                 :          0 :                         flags |= SPLICE_F_NONBLOCK;
    1168                 :            : 
    1169                 :          0 :                 file_start_write(out);
    1170         [ #  # ]:          0 :                 ret = do_splice_from(ipipe, out, &offset, len, flags);
    1171         [ #  # ]:          0 :                 file_end_write(out);
    1172                 :            : 
    1173         [ #  # ]:          0 :                 if (!off_out)
    1174                 :          0 :                         out->f_pos = offset;
    1175         [ #  # ]:          0 :                 else if (copy_to_user(off_out, &offset, sizeof(loff_t)))
    1176                 :          0 :                         ret = -EFAULT;
    1177                 :            : 
    1178                 :          0 :                 return ret;
    1179                 :            :         }
    1180                 :            : 
    1181         [ #  # ]:          0 :         if (opipe) {
    1182         [ #  # ]:          0 :                 if (off_out)
    1183                 :            :                         return -ESPIPE;
    1184         [ #  # ]:          0 :                 if (off_in) {
    1185         [ #  # ]:          0 :                         if (!(in->f_mode & FMODE_PREAD))
    1186                 :            :                                 return -EINVAL;
    1187         [ #  # ]:          0 :                         if (copy_from_user(&offset, off_in, sizeof(loff_t)))
    1188                 :            :                                 return -EFAULT;
    1189                 :            :                 } else {
    1190                 :          0 :                         offset = in->f_pos;
    1191                 :            :                 }
    1192                 :            : 
    1193         [ #  # ]:          0 :                 if (out->f_flags & O_NONBLOCK)
    1194                 :          0 :                         flags |= SPLICE_F_NONBLOCK;
    1195                 :            : 
    1196                 :          0 :                 pipe_lock(opipe);
    1197                 :          0 :                 ret = wait_for_space(opipe, flags);
    1198         [ #  # ]:          0 :                 if (!ret) {
    1199                 :          0 :                         unsigned int p_space;
    1200                 :            : 
    1201                 :            :                         /* Don't try to read more the pipe has space for. */
    1202                 :          0 :                         p_space = opipe->max_usage - pipe_occupancy(opipe->head, opipe->tail);
    1203                 :          0 :                         len = min_t(size_t, len, p_space << PAGE_SHIFT);
    1204                 :            : 
    1205                 :          0 :                         ret = do_splice_to(in, &offset, opipe, len, flags);
    1206                 :            :                 }
    1207                 :          0 :                 pipe_unlock(opipe);
    1208         [ #  # ]:          0 :                 if (ret > 0)
    1209                 :          0 :                         wakeup_pipe_readers(opipe);
    1210         [ #  # ]:          0 :                 if (!off_in)
    1211                 :          0 :                         in->f_pos = offset;
    1212         [ #  # ]:          0 :                 else if (copy_to_user(off_in, &offset, sizeof(loff_t)))
    1213                 :          0 :                         ret = -EFAULT;
    1214                 :            : 
    1215                 :          0 :                 return ret;
    1216                 :            :         }
    1217                 :            : 
    1218                 :            :         return -EINVAL;
    1219                 :            : }
    1220                 :            : 
    1221                 :          0 : static int iter_to_pipe(struct iov_iter *from,
    1222                 :            :                         struct pipe_inode_info *pipe,
    1223                 :            :                         unsigned flags)
    1224                 :            : {
    1225                 :          0 :         struct pipe_buffer buf = {
    1226                 :            :                 .ops = &user_page_pipe_buf_ops,
    1227                 :            :                 .flags = flags
    1228                 :            :         };
    1229                 :          0 :         size_t total = 0;
    1230                 :          0 :         int ret = 0;
    1231                 :          0 :         bool failed = false;
    1232                 :            : 
    1233   [ #  #  #  # ]:          0 :         while (iov_iter_count(from) && !failed) {
    1234                 :          0 :                 struct page *pages[16];
    1235                 :          0 :                 ssize_t copied;
    1236                 :          0 :                 size_t start;
    1237                 :          0 :                 int n;
    1238                 :            : 
    1239                 :          0 :                 copied = iov_iter_get_pages(from, pages, ~0UL, 16, &start);
    1240         [ #  # ]:          0 :                 if (copied <= 0) {
    1241                 :          0 :                         ret = copied;
    1242                 :          0 :                         break;
    1243                 :            :                 }
    1244                 :            : 
    1245         [ #  # ]:          0 :                 for (n = 0; copied; n++, start = 0) {
    1246                 :          0 :                         int size = min_t(int, copied, PAGE_SIZE - start);
    1247         [ #  # ]:          0 :                         if (!failed) {
    1248                 :          0 :                                 buf.page = pages[n];
    1249                 :          0 :                                 buf.offset = start;
    1250                 :          0 :                                 buf.len = size;
    1251                 :          0 :                                 ret = add_to_pipe(pipe, &buf);
    1252         [ #  # ]:          0 :                                 if (unlikely(ret < 0)) {
    1253                 :            :                                         failed = true;
    1254                 :            :                                 } else {
    1255                 :          0 :                                         iov_iter_advance(from, ret);
    1256                 :          0 :                                         total += ret;
    1257                 :            :                                 }
    1258                 :            :                         } else {
    1259                 :          0 :                                 put_page(pages[n]);
    1260                 :            :                         }
    1261                 :          0 :                         copied -= size;
    1262                 :            :                 }
    1263                 :            :         }
    1264         [ #  # ]:          0 :         return total ? total : ret;
    1265                 :            : }
    1266                 :            : 
    1267                 :          0 : static int pipe_to_user(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
    1268                 :            :                         struct splice_desc *sd)
    1269                 :            : {
    1270                 :          0 :         int n = copy_page_to_iter(buf->page, buf->offset, sd->len, sd->u.data);
    1271         [ #  # ]:          0 :         return n == sd->len ? n : -EFAULT;
    1272                 :            : }
    1273                 :            : 
    1274                 :            : /*
    1275                 :            :  * For lack of a better implementation, implement vmsplice() to userspace
    1276                 :            :  * as a simple copy of the pipes pages to the user iov.
    1277                 :            :  */
    1278                 :          0 : static long vmsplice_to_user(struct file *file, struct iov_iter *iter,
    1279                 :            :                              unsigned int flags)
    1280                 :            : {
    1281                 :          0 :         struct pipe_inode_info *pipe = get_pipe_info(file);
    1282                 :          0 :         struct splice_desc sd = {
    1283         [ #  # ]:          0 :                 .total_len = iov_iter_count(iter),
    1284                 :            :                 .flags = flags,
    1285                 :            :                 .u.data = iter
    1286                 :            :         };
    1287                 :          0 :         long ret = 0;
    1288                 :            : 
    1289         [ #  # ]:          0 :         if (!pipe)
    1290                 :            :                 return -EBADF;
    1291                 :            : 
    1292         [ #  # ]:          0 :         if (sd.total_len) {
    1293                 :          0 :                 pipe_lock(pipe);
    1294                 :          0 :                 ret = __splice_from_pipe(pipe, &sd, pipe_to_user);
    1295                 :          0 :                 pipe_unlock(pipe);
    1296                 :            :         }
    1297                 :            : 
    1298                 :            :         return ret;
    1299                 :            : }
    1300                 :            : 
    1301                 :            : /*
    1302                 :            :  * vmsplice splices a user address range into a pipe. It can be thought of
    1303                 :            :  * as splice-from-memory, where the regular splice is splice-from-file (or
    1304                 :            :  * to file). In both cases the output is a pipe, naturally.
    1305                 :            :  */
    1306                 :          0 : static long vmsplice_to_pipe(struct file *file, struct iov_iter *iter,
    1307                 :            :                              unsigned int flags)
    1308                 :            : {
    1309                 :          0 :         struct pipe_inode_info *pipe;
    1310                 :          0 :         long ret = 0;
    1311                 :          0 :         unsigned buf_flag = 0;
    1312                 :            : 
    1313         [ #  # ]:          0 :         if (flags & SPLICE_F_GIFT)
    1314                 :          0 :                 buf_flag = PIPE_BUF_FLAG_GIFT;
    1315                 :            : 
    1316                 :          0 :         pipe = get_pipe_info(file);
    1317         [ #  # ]:          0 :         if (!pipe)
    1318                 :            :                 return -EBADF;
    1319                 :            : 
    1320                 :          0 :         pipe_lock(pipe);
    1321                 :          0 :         ret = wait_for_space(pipe, flags);
    1322         [ #  # ]:          0 :         if (!ret)
    1323                 :          0 :                 ret = iter_to_pipe(iter, pipe, buf_flag);
    1324                 :          0 :         pipe_unlock(pipe);
    1325         [ #  # ]:          0 :         if (ret > 0)
    1326                 :          0 :                 wakeup_pipe_readers(pipe);
    1327                 :            :         return ret;
    1328                 :            : }
    1329                 :            : 
    1330                 :            : static int vmsplice_type(struct fd f, int *type)
    1331                 :            : {
    1332                 :            :         if (!f.file)
    1333                 :            :                 return -EBADF;
    1334                 :            :         if (f.file->f_mode & FMODE_WRITE) {
    1335                 :            :                 *type = WRITE;
    1336                 :            :         } else if (f.file->f_mode & FMODE_READ) {
    1337                 :            :                 *type = READ;
    1338                 :            :         } else {
    1339                 :            :                 fdput(f);
    1340                 :            :                 return -EBADF;
    1341                 :            :         }
    1342                 :            :         return 0;
    1343                 :            : }
    1344                 :            : 
    1345                 :            : /*
    1346                 :            :  * Note that vmsplice only really supports true splicing _from_ user memory
    1347                 :            :  * to a pipe, not the other way around. Splicing from user memory is a simple
    1348                 :            :  * operation that can be supported without any funky alignment restrictions
    1349                 :            :  * or nasty vm tricks. We simply map in the user memory and fill them into
    1350                 :            :  * a pipe. The reverse isn't quite as easy, though. There are two possible
    1351                 :            :  * solutions for that:
    1352                 :            :  *
    1353                 :            :  *      - memcpy() the data internally, at which point we might as well just
    1354                 :            :  *        do a regular read() on the buffer anyway.
    1355                 :            :  *      - Lots of nasty vm tricks, that are neither fast nor flexible (it
    1356                 :            :  *        has restriction limitations on both ends of the pipe).
    1357                 :            :  *
    1358                 :            :  * Currently we punt and implement it as a normal copy, see pipe_to_user().
    1359                 :            :  *
    1360                 :            :  */
    1361                 :          0 : static long do_vmsplice(struct file *f, struct iov_iter *iter, unsigned int flags)
    1362                 :            : {
    1363         [ #  # ]:          0 :         if (unlikely(flags & ~SPLICE_F_ALL))
    1364                 :            :                 return -EINVAL;
    1365                 :            : 
    1366         [ #  # ]:          0 :         if (!iov_iter_count(iter))
    1367                 :            :                 return 0;
    1368                 :            : 
    1369         [ #  # ]:          0 :         if (iov_iter_rw(iter) == WRITE)
    1370                 :          0 :                 return vmsplice_to_pipe(f, iter, flags);
    1371                 :            :         else
    1372                 :          0 :                 return vmsplice_to_user(f, iter, flags);
    1373                 :            : }
    1374                 :            : 
    1375                 :          0 : SYSCALL_DEFINE4(vmsplice, int, fd, const struct iovec __user *, uiov,
    1376                 :            :                 unsigned long, nr_segs, unsigned int, flags)
    1377                 :            : {
    1378                 :          0 :         struct iovec iovstack[UIO_FASTIOV];
    1379                 :          0 :         struct iovec *iov = iovstack;
    1380                 :          0 :         struct iov_iter iter;
    1381                 :          0 :         ssize_t error;
    1382                 :          0 :         struct fd f;
    1383                 :          0 :         int type;
    1384                 :            : 
    1385                 :          0 :         f = fdget(fd);
    1386                 :          0 :         error = vmsplice_type(f, &type);
    1387         [ #  # ]:          0 :         if (error)
    1388                 :            :                 return error;
    1389                 :            : 
    1390                 :          0 :         error = import_iovec(type, uiov, nr_segs,
    1391                 :            :                              ARRAY_SIZE(iovstack), &iov, &iter);
    1392         [ #  # ]:          0 :         if (error >= 0) {
    1393                 :          0 :                 error = do_vmsplice(f.file, &iter, flags);
    1394                 :          0 :                 kfree(iov);
    1395                 :            :         }
    1396         [ #  # ]:          0 :         fdput(f);
    1397                 :            :         return error;
    1398                 :            : }
    1399                 :            : 
    1400                 :            : #ifdef CONFIG_COMPAT
    1401                 :          0 : COMPAT_SYSCALL_DEFINE4(vmsplice, int, fd, const struct compat_iovec __user *, iov32,
    1402                 :            :                     unsigned int, nr_segs, unsigned int, flags)
    1403                 :            : {
    1404                 :          0 :         struct iovec iovstack[UIO_FASTIOV];
    1405                 :          0 :         struct iovec *iov = iovstack;
    1406                 :          0 :         struct iov_iter iter;
    1407                 :          0 :         ssize_t error;
    1408                 :          0 :         struct fd f;
    1409                 :          0 :         int type;
    1410                 :            : 
    1411                 :          0 :         f = fdget(fd);
    1412                 :          0 :         error = vmsplice_type(f, &type);
    1413         [ #  # ]:          0 :         if (error)
    1414                 :            :                 return error;
    1415                 :            : 
    1416                 :          0 :         error = compat_import_iovec(type, iov32, nr_segs,
    1417                 :            :                              ARRAY_SIZE(iovstack), &iov, &iter);
    1418         [ #  # ]:          0 :         if (error >= 0) {
    1419                 :          0 :                 error = do_vmsplice(f.file, &iter, flags);
    1420                 :          0 :                 kfree(iov);
    1421                 :            :         }
    1422         [ #  # ]:          0 :         fdput(f);
    1423                 :            :         return error;
    1424                 :            : }
    1425                 :            : #endif
    1426                 :            : 
    1427                 :          0 : SYSCALL_DEFINE6(splice, int, fd_in, loff_t __user *, off_in,
    1428                 :            :                 int, fd_out, loff_t __user *, off_out,
    1429                 :            :                 size_t, len, unsigned int, flags)
    1430                 :            : {
    1431                 :          0 :         struct fd in, out;
    1432                 :          0 :         long error;
    1433                 :            : 
    1434         [ #  # ]:          0 :         if (unlikely(!len))
    1435                 :            :                 return 0;
    1436                 :            : 
    1437         [ #  # ]:          0 :         if (unlikely(flags & ~SPLICE_F_ALL))
    1438                 :            :                 return -EINVAL;
    1439                 :            : 
    1440                 :          0 :         error = -EBADF;
    1441                 :          0 :         in = fdget(fd_in);
    1442         [ #  # ]:          0 :         if (in.file) {
    1443         [ #  # ]:          0 :                 if (in.file->f_mode & FMODE_READ) {
    1444                 :          0 :                         out = fdget(fd_out);
    1445         [ #  # ]:          0 :                         if (out.file) {
    1446         [ #  # ]:          0 :                                 if (out.file->f_mode & FMODE_WRITE)
    1447                 :          0 :                                         error = do_splice(in.file, off_in,
    1448                 :            :                                                           out.file, off_out,
    1449                 :            :                                                           len, flags);
    1450         [ #  # ]:          0 :                                 fdput(out);
    1451                 :            :                         }
    1452                 :            :                 }
    1453         [ #  # ]:          0 :                 fdput(in);
    1454                 :            :         }
    1455                 :            :         return error;
    1456                 :            : }
    1457                 :            : 
    1458                 :            : /*
    1459                 :            :  * Make sure there's data to read. Wait for input if we can, otherwise
    1460                 :            :  * return an appropriate error.
    1461                 :            :  */
    1462                 :          0 : static int ipipe_prep(struct pipe_inode_info *pipe, unsigned int flags)
    1463                 :            : {
    1464                 :          0 :         int ret;
    1465                 :            : 
    1466                 :            :         /*
    1467                 :            :          * Check the pipe occupancy without the inode lock first. This function
    1468                 :            :          * is speculative anyways, so missing one is ok.
    1469                 :            :          */
    1470         [ #  # ]:          0 :         if (!pipe_empty(pipe->head, pipe->tail))
    1471                 :            :                 return 0;
    1472                 :            : 
    1473                 :          0 :         ret = 0;
    1474                 :          0 :         pipe_lock(pipe);
    1475                 :            : 
    1476         [ #  # ]:          0 :         while (pipe_empty(pipe->head, pipe->tail)) {
    1477         [ #  # ]:          0 :                 if (signal_pending(current)) {
    1478                 :            :                         ret = -ERESTARTSYS;
    1479                 :            :                         break;
    1480                 :            :                 }
    1481         [ #  # ]:          0 :                 if (!pipe->writers)
    1482                 :            :                         break;
    1483         [ #  # ]:          0 :                 if (flags & SPLICE_F_NONBLOCK) {
    1484                 :            :                         ret = -EAGAIN;
    1485                 :            :                         break;
    1486                 :            :                 }
    1487                 :          0 :                 pipe_wait(pipe);
    1488                 :            :         }
    1489                 :            : 
    1490                 :          0 :         pipe_unlock(pipe);
    1491                 :          0 :         return ret;
    1492                 :            : }
    1493                 :            : 
    1494                 :            : /*
    1495                 :            :  * Make sure there's writeable room. Wait for room if we can, otherwise
    1496                 :            :  * return an appropriate error.
    1497                 :            :  */
    1498                 :          0 : static int opipe_prep(struct pipe_inode_info *pipe, unsigned int flags)
    1499                 :            : {
    1500                 :          0 :         int ret;
    1501                 :            : 
    1502                 :            :         /*
    1503                 :            :          * Check pipe occupancy without the inode lock first. This function
    1504                 :            :          * is speculative anyways, so missing one is ok.
    1505                 :            :          */
    1506         [ #  # ]:          0 :         if (pipe_full(pipe->head, pipe->tail, pipe->max_usage))
    1507                 :            :                 return 0;
    1508                 :            : 
    1509                 :          0 :         ret = 0;
    1510                 :          0 :         pipe_lock(pipe);
    1511                 :            : 
    1512         [ #  # ]:          0 :         while (pipe_full(pipe->head, pipe->tail, pipe->max_usage)) {
    1513         [ #  # ]:          0 :                 if (!pipe->readers) {
    1514                 :          0 :                         send_sig(SIGPIPE, current, 0);
    1515                 :          0 :                         ret = -EPIPE;
    1516                 :          0 :                         break;
    1517                 :            :                 }
    1518         [ #  # ]:          0 :                 if (flags & SPLICE_F_NONBLOCK) {
    1519                 :            :                         ret = -EAGAIN;
    1520                 :            :                         break;
    1521                 :            :                 }
    1522         [ #  # ]:          0 :                 if (signal_pending(current)) {
    1523                 :            :                         ret = -ERESTARTSYS;
    1524                 :            :                         break;
    1525                 :            :                 }
    1526                 :          0 :                 pipe_wait(pipe);
    1527                 :            :         }
    1528                 :            : 
    1529                 :          0 :         pipe_unlock(pipe);
    1530                 :          0 :         return ret;
    1531                 :            : }
    1532                 :            : 
    1533                 :            : /*
    1534                 :            :  * Splice contents of ipipe to opipe.
    1535                 :            :  */
    1536                 :          0 : static int splice_pipe_to_pipe(struct pipe_inode_info *ipipe,
    1537                 :            :                                struct pipe_inode_info *opipe,
    1538                 :            :                                size_t len, unsigned int flags)
    1539                 :            : {
    1540                 :          0 :         struct pipe_buffer *ibuf, *obuf;
    1541                 :          0 :         unsigned int i_head, o_head;
    1542                 :          0 :         unsigned int i_tail, o_tail;
    1543                 :          0 :         unsigned int i_mask, o_mask;
    1544                 :          0 :         int ret = 0;
    1545                 :          0 :         bool input_wakeup = false;
    1546                 :            : 
    1547                 :            : 
    1548                 :          0 : retry:
    1549                 :          0 :         ret = ipipe_prep(ipipe, flags);
    1550         [ #  # ]:          0 :         if (ret)
    1551                 :          0 :                 return ret;
    1552                 :            : 
    1553                 :          0 :         ret = opipe_prep(opipe, flags);
    1554         [ #  # ]:          0 :         if (ret)
    1555                 :          0 :                 return ret;
    1556                 :            : 
    1557                 :            :         /*
    1558                 :            :          * Potential ABBA deadlock, work around it by ordering lock
    1559                 :            :          * grabbing by pipe info address. Otherwise two different processes
    1560                 :            :          * could deadlock (one doing tee from A -> B, the other from B -> A).
    1561                 :            :          */
    1562                 :          0 :         pipe_double_lock(ipipe, opipe);
    1563                 :            : 
    1564                 :          0 :         i_tail = ipipe->tail;
    1565                 :          0 :         i_mask = ipipe->ring_size - 1;
    1566                 :          0 :         o_head = opipe->head;
    1567                 :          0 :         o_mask = opipe->ring_size - 1;
    1568                 :            : 
    1569                 :          0 :         do {
    1570                 :          0 :                 size_t o_len;
    1571                 :            : 
    1572         [ #  # ]:          0 :                 if (!opipe->readers) {
    1573                 :          0 :                         send_sig(SIGPIPE, current, 0);
    1574         [ #  # ]:          0 :                         if (!ret)
    1575                 :          0 :                                 ret = -EPIPE;
    1576                 :            :                         break;
    1577                 :            :                 }
    1578                 :            : 
    1579                 :          0 :                 i_head = ipipe->head;
    1580                 :          0 :                 o_tail = opipe->tail;
    1581                 :            : 
    1582   [ #  #  #  # ]:          0 :                 if (pipe_empty(i_head, i_tail) && !ipipe->writers)
    1583                 :            :                         break;
    1584                 :            : 
    1585                 :            :                 /*
    1586                 :            :                  * Cannot make any progress, because either the input
    1587                 :            :                  * pipe is empty or the output pipe is full.
    1588                 :            :                  */
    1589   [ #  #  #  # ]:          0 :                 if (pipe_empty(i_head, i_tail) ||
    1590         [ #  # ]:          0 :                     pipe_full(o_head, o_tail, opipe->max_usage)) {
    1591                 :            :                         /* Already processed some buffers, break */
    1592         [ #  # ]:          0 :                         if (ret)
    1593                 :            :                                 break;
    1594                 :            : 
    1595         [ #  # ]:          0 :                         if (flags & SPLICE_F_NONBLOCK) {
    1596                 :            :                                 ret = -EAGAIN;
    1597                 :            :                                 break;
    1598                 :            :                         }
    1599                 :            : 
    1600                 :            :                         /*
    1601                 :            :                          * We raced with another reader/writer and haven't
    1602                 :            :                          * managed to process any buffers.  A zero return
    1603                 :            :                          * value means EOF, so retry instead.
    1604                 :            :                          */
    1605                 :          0 :                         pipe_unlock(ipipe);
    1606                 :          0 :                         pipe_unlock(opipe);
    1607                 :          0 :                         goto retry;
    1608                 :            :                 }
    1609                 :            : 
    1610                 :          0 :                 ibuf = &ipipe->bufs[i_tail & i_mask];
    1611                 :          0 :                 obuf = &opipe->bufs[o_head & o_mask];
    1612                 :            : 
    1613         [ #  # ]:          0 :                 if (len >= ibuf->len) {
    1614                 :            :                         /*
    1615                 :            :                          * Simply move the whole buffer from ipipe to opipe
    1616                 :            :                          */
    1617                 :          0 :                         *obuf = *ibuf;
    1618                 :          0 :                         ibuf->ops = NULL;
    1619                 :          0 :                         i_tail++;
    1620                 :          0 :                         ipipe->tail = i_tail;
    1621                 :          0 :                         input_wakeup = true;
    1622                 :          0 :                         o_len = obuf->len;
    1623                 :          0 :                         o_head++;
    1624                 :          0 :                         opipe->head = o_head;
    1625                 :            :                 } else {
    1626                 :            :                         /*
    1627                 :            :                          * Get a reference to this pipe buffer,
    1628                 :            :                          * so we can copy the contents over.
    1629                 :            :                          */
    1630         [ #  # ]:          0 :                         if (!pipe_buf_get(ipipe, ibuf)) {
    1631         [ #  # ]:          0 :                                 if (ret == 0)
    1632                 :          0 :                                         ret = -EFAULT;
    1633                 :            :                                 break;
    1634                 :            :                         }
    1635                 :          0 :                         *obuf = *ibuf;
    1636                 :            : 
    1637                 :            :                         /*
    1638                 :            :                          * Don't inherit the gift flag, we need to
    1639                 :            :                          * prevent multiple steals of this page.
    1640                 :            :                          */
    1641                 :          0 :                         obuf->flags &= ~PIPE_BUF_FLAG_GIFT;
    1642                 :            : 
    1643                 :          0 :                         pipe_buf_mark_unmergeable(obuf);
    1644                 :            : 
    1645                 :          0 :                         obuf->len = len;
    1646                 :          0 :                         ibuf->offset += len;
    1647                 :          0 :                         ibuf->len -= len;
    1648                 :          0 :                         o_len = len;
    1649                 :          0 :                         o_head++;
    1650                 :          0 :                         opipe->head = o_head;
    1651                 :            :                 }
    1652                 :          0 :                 ret += o_len;
    1653                 :          0 :                 len -= o_len;
    1654         [ #  # ]:          0 :         } while (len);
    1655                 :            : 
    1656                 :          0 :         pipe_unlock(ipipe);
    1657                 :          0 :         pipe_unlock(opipe);
    1658                 :            : 
    1659                 :            :         /*
    1660                 :            :          * If we put data in the output pipe, wakeup any potential readers.
    1661                 :            :          */
    1662         [ #  # ]:          0 :         if (ret > 0)
    1663                 :          0 :                 wakeup_pipe_readers(opipe);
    1664                 :            : 
    1665         [ #  # ]:          0 :         if (input_wakeup)
    1666                 :          0 :                 wakeup_pipe_writers(ipipe);
    1667                 :            : 
    1668                 :            :         return ret;
    1669                 :            : }
    1670                 :            : 
    1671                 :            : /*
    1672                 :            :  * Link contents of ipipe to opipe.
    1673                 :            :  */
    1674                 :            : static int link_pipe(struct pipe_inode_info *ipipe,
    1675                 :            :                      struct pipe_inode_info *opipe,
    1676                 :            :                      size_t len, unsigned int flags)
    1677                 :            : {
    1678                 :            :         struct pipe_buffer *ibuf, *obuf;
    1679                 :            :         unsigned int i_head, o_head;
    1680                 :            :         unsigned int i_tail, o_tail;
    1681                 :            :         unsigned int i_mask, o_mask;
    1682                 :            :         int ret = 0;
    1683                 :            : 
    1684                 :            :         /*
    1685                 :            :          * Potential ABBA deadlock, work around it by ordering lock
    1686                 :            :          * grabbing by pipe info address. Otherwise two different processes
    1687                 :            :          * could deadlock (one doing tee from A -> B, the other from B -> A).
    1688                 :            :          */
    1689                 :            :         pipe_double_lock(ipipe, opipe);
    1690                 :            : 
    1691                 :            :         i_tail = ipipe->tail;
    1692                 :            :         i_mask = ipipe->ring_size - 1;
    1693                 :            :         o_head = opipe->head;
    1694                 :            :         o_mask = opipe->ring_size - 1;
    1695                 :            : 
    1696                 :            :         do {
    1697                 :            :                 if (!opipe->readers) {
    1698                 :            :                         send_sig(SIGPIPE, current, 0);
    1699                 :            :                         if (!ret)
    1700                 :            :                                 ret = -EPIPE;
    1701                 :            :                         break;
    1702                 :            :                 }
    1703                 :            : 
    1704                 :            :                 i_head = ipipe->head;
    1705                 :            :                 o_tail = opipe->tail;
    1706                 :            : 
    1707                 :            :                 /*
    1708                 :            :                  * If we have iterated all input buffers or run out of
    1709                 :            :                  * output room, break.
    1710                 :            :                  */
    1711                 :            :                 if (pipe_empty(i_head, i_tail) ||
    1712                 :            :                     pipe_full(o_head, o_tail, opipe->max_usage))
    1713                 :            :                         break;
    1714                 :            : 
    1715                 :            :                 ibuf = &ipipe->bufs[i_tail & i_mask];
    1716                 :            :                 obuf = &opipe->bufs[o_head & o_mask];
    1717                 :            : 
    1718                 :            :                 /*
    1719                 :            :                  * Get a reference to this pipe buffer,
    1720                 :            :                  * so we can copy the contents over.
    1721                 :            :                  */
    1722                 :            :                 if (!pipe_buf_get(ipipe, ibuf)) {
    1723                 :            :                         if (ret == 0)
    1724                 :            :                                 ret = -EFAULT;
    1725                 :            :                         break;
    1726                 :            :                 }
    1727                 :            : 
    1728                 :            :                 *obuf = *ibuf;
    1729                 :            : 
    1730                 :            :                 /*
    1731                 :            :                  * Don't inherit the gift flag, we need to
    1732                 :            :                  * prevent multiple steals of this page.
    1733                 :            :                  */
    1734                 :            :                 obuf->flags &= ~PIPE_BUF_FLAG_GIFT;
    1735                 :            : 
    1736                 :            :                 pipe_buf_mark_unmergeable(obuf);
    1737                 :            : 
    1738                 :            :                 if (obuf->len > len)
    1739                 :            :                         obuf->len = len;
    1740                 :            :                 ret += obuf->len;
    1741                 :            :                 len -= obuf->len;
    1742                 :            : 
    1743                 :            :                 o_head++;
    1744                 :            :                 opipe->head = o_head;
    1745                 :            :                 i_tail++;
    1746                 :            :         } while (len);
    1747                 :            : 
    1748                 :            :         pipe_unlock(ipipe);
    1749                 :            :         pipe_unlock(opipe);
    1750                 :            : 
    1751                 :            :         /*
    1752                 :            :          * If we put data in the output pipe, wakeup any potential readers.
    1753                 :            :          */
    1754                 :            :         if (ret > 0)
    1755                 :            :                 wakeup_pipe_readers(opipe);
    1756                 :            : 
    1757                 :            :         return ret;
    1758                 :            : }
    1759                 :            : 
    1760                 :            : /*
    1761                 :            :  * This is a tee(1) implementation that works on pipes. It doesn't copy
    1762                 :            :  * any data, it simply references the 'in' pages on the 'out' pipe.
    1763                 :            :  * The 'flags' used are the SPLICE_F_* variants, currently the only
    1764                 :            :  * applicable one is SPLICE_F_NONBLOCK.
    1765                 :            :  */
    1766                 :          0 : static long do_tee(struct file *in, struct file *out, size_t len,
    1767                 :            :                    unsigned int flags)
    1768                 :            : {
    1769                 :          0 :         struct pipe_inode_info *ipipe = get_pipe_info(in);
    1770                 :          0 :         struct pipe_inode_info *opipe = get_pipe_info(out);
    1771                 :          0 :         int ret = -EINVAL;
    1772                 :            : 
    1773                 :            :         /*
    1774                 :            :          * Duplicate the contents of ipipe to opipe without actually
    1775                 :            :          * copying the data.
    1776                 :            :          */
    1777   [ #  #  #  # ]:          0 :         if (ipipe && opipe && ipipe != opipe) {
    1778         [ #  # ]:          0 :                 if ((in->f_flags | out->f_flags) & O_NONBLOCK)
    1779                 :          0 :                         flags |= SPLICE_F_NONBLOCK;
    1780                 :            : 
    1781                 :            :                 /*
    1782                 :            :                  * Keep going, unless we encounter an error. The ipipe/opipe
    1783                 :            :                  * ordering doesn't really matter.
    1784                 :            :                  */
    1785                 :          0 :                 ret = ipipe_prep(ipipe, flags);
    1786         [ #  # ]:          0 :                 if (!ret) {
    1787                 :          0 :                         ret = opipe_prep(opipe, flags);
    1788         [ #  # ]:          0 :                         if (!ret)
    1789                 :          0 :                                 ret = link_pipe(ipipe, opipe, len, flags);
    1790                 :            :                 }
    1791                 :            :         }
    1792                 :            : 
    1793                 :          0 :         return ret;
    1794                 :            : }
    1795                 :            : 
    1796                 :          0 : SYSCALL_DEFINE4(tee, int, fdin, int, fdout, size_t, len, unsigned int, flags)
    1797                 :            : {
    1798                 :          0 :         struct fd in;
    1799                 :          0 :         int error;
    1800                 :            : 
    1801         [ #  # ]:          0 :         if (unlikely(flags & ~SPLICE_F_ALL))
    1802                 :            :                 return -EINVAL;
    1803                 :            : 
    1804         [ #  # ]:          0 :         if (unlikely(!len))
    1805                 :            :                 return 0;
    1806                 :            : 
    1807                 :          0 :         error = -EBADF;
    1808                 :          0 :         in = fdget(fdin);
    1809         [ #  # ]:          0 :         if (in.file) {
    1810         [ #  # ]:          0 :                 if (in.file->f_mode & FMODE_READ) {
    1811                 :          0 :                         struct fd out = fdget(fdout);
    1812         [ #  # ]:          0 :                         if (out.file) {
    1813         [ #  # ]:          0 :                                 if (out.file->f_mode & FMODE_WRITE)
    1814                 :          0 :                                         error = do_tee(in.file, out.file,
    1815                 :            :                                                         len, flags);
    1816         [ #  # ]:          0 :                                 fdput(out);
    1817                 :            :                         }
    1818                 :            :                 }
    1819         [ #  # ]:          0 :                 fdput(in);
    1820                 :            :         }
    1821                 :            : 
    1822                 :          0 :         return error;
    1823                 :            : }

Generated by: LCOV version 1.14