linux-imx

/*

 * "splice": joining two ropes together by interweaving their strands.

 *

 * This is the "extended pipe" functionality, where a pipe is used as

 * an arbitrary in-memory buffer. Think of a pipe as a small kernel

 * buffer that you can use to transfer data from one end to the other.

 *

 * The traditional unix read/write is extended with a "splice()" operation

 * that transfers data buffers to or from a pipe buffer.

 *

 * Named by Larry McVoy, original implementation from Linus, extended by

 * Jens to support splicing to files, network, direct splicing, etc and

 * fixing lots of bugs.

 *

 * Copyright (C) 2005-2006 Jens Axboe <axboe@kernel.dk>

 * Copyright (C) 2005-2006 Linus Torvalds <torvalds@osdl.org>

 * Copyright (C) 2006 Ingo Molnar <mingo@elte.hu>

 *

 */

#include <linux/bvec.h>

#include <linux/fs.h>

#include <linux/file.h>

#include <linux/pagemap.h>

#include <linux/splice.h>

#include <linux/memcontrol.h>

#include <linux/mm_inline.h>

#include <linux/swap.h>

#include <linux/writeback.h>

#include <linux/export.h>

#include <linux/syscalls.h>

#include <linux/uio.h>

#include <linux/security.h>

#include <linux/gfp.h>

#include <linux/socket.h>

#include <linux/compat.h>

#include <linux/sched/signal.h>

​

#include "internal.h"

​

/*

 * Attempt to steal a page from a pipe buffer. This should perhaps go into

 * a vm helper function, it's already simplified quite a bit by the

 * addition of remove_mapping(). If success is returned, the caller may

 * attempt to reuse this page for another destination.

 */

static int page_cache_pipe_buf_steal(struct pipe_inode_info *pipe,

                     struct pipe_buffer *buf)

{

    struct page *page = buf->page;

    struct address_space *mapping;

​

    lock_page(page);

​

    mapping = page_mapping(page);

    if (mapping) {

        WARN_ON(!PageUptodate(page));

​

        /*

         * At least for ext2 with nobh option, we need to wait on

         * writeback completing on this page, since we'll remove it

         * from the pagecache.  Otherwise truncate wont wait on the

         * page, allowing the disk blocks to be reused by someone else

         * before we actually wrote our data to them. fs corruption

         * ensues.

         */

        wait_on_page_writeback(page);

​

        if (page_has_private(page) &&

            !try_to_release_page(page, GFP_KERNEL))

            goto out_unlock;

​

        /*

         * If we succeeded in removing the mapping, set LRU flag

         * and return good.

         */

        if (remove_mapping(mapping, page)) {

            buf->flags |= PIPE_BUF_FLAG_LRU;

            return 0;

        }

    }

​

    /*

     * Raced with truncate or failed to remove page from current

     * address space, unlock and return failure.

     */

out_unlock:

    unlock_page(page);

    return 1;

}

​

static void page_cache_pipe_buf_release(struct pipe_inode_info *pipe,

                    struct pipe_buffer *buf)