LCOV - code coverage report
Current view: top level - fs - splice.c (source / functions) Hit Total Coverage
Test: Real Lines: 0 582 0.0 %
Date: 2020-10-17 15:46:16 Functions: 0 46 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14