1 files changed, 129 insertions, 0 deletions

diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index 8e65182f7af1..56ed40703f98 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -254,6 +254,10 @@
 #include <linux/poll.h>
 #include <linux/init.h>
 #include <linux/fs.h>
+#include <linux/skbuff.h>
+#include <linux/splice.h>
+#include <linux/net.h>
+#include <linux/socket.h>
 #include <linux/random.h>
 #include <linux/bootmem.h>
 #include <linux/cache.h>
@@ -265,6 +269,7 @@
 #include <net/xfrm.h>
 #include <net/ip.h>
 #include <net/netdma.h>
+#include <net/sock.h>
 
 #include <asm/uaccess.h>
 #include <asm/ioctls.h>
@@ -292,6 +297,15 @@ EXPORT_SYMBOL(tcp_memory_allocated);
 EXPORT_SYMBOL(tcp_sockets_allocated);
 
 /*
+ * TCP splice context
+ */
+struct tcp_splice_state {
+        struct pipe_inode_info *pipe;
+        size_t len;
+        unsigned int flags;
+};
+
+/*
  * Pressure flag: try to collapse.
  * Technical note: it is used by multiple contexts non atomically.
  * All the sk_stream_mem_schedule() is of this nature: accounting
@@ -501,6 +515,120 @@ static inline void tcp_push(struct sock *sk, int flags, int mss_now,
         }
 }
 
+int tcp_splice_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb,
+                         unsigned int offset, size_t len)
+{
+        struct tcp_splice_state *tss = rd_desc->arg.data;
+
+        return skb_splice_bits(skb, offset, tss->pipe, tss->len, tss->flags);
+}
+
+static int __tcp_splice_read(struct sock *sk, struct tcp_splice_state *tss)
+{
+        /* Store TCP splice context information in read_descriptor_t. */
+        read_descriptor_t rd_desc = {
+                .arg.data = tss,
+        };
+
+        return tcp_read_sock(sk, &rd_desc, tcp_splice_data_recv);
+}
+
+/**
+ *  tcp_splice_read - splice data from TCP socket to a pipe
+ * @sock:       socket to splice from
+ * @ppos:       position (not valid)
+ * @pipe:       pipe to splice to
+ * @len:        number of bytes to splice
+ * @flags:      splice modifier flags
+ *
+ * Description:
+ *    Will read pages from given socket and fill them into a pipe.
+ *
+ **/
+ssize_t tcp_splice_read(struct socket *sock, loff_t *ppos,
+                        struct pipe_inode_info *pipe, size_t len,
+                        unsigned int flags)
+{
+        struct sock *sk = sock->sk;
+        struct tcp_splice_state tss = {
+                .pipe = pipe,
+                .len = len,
+                .flags = flags,
+        };
+        long timeo;
+        ssize_t spliced;
+        int ret;
+
+        /*
+         * We can't seek on a socket input
+         */
+        if (unlikely(*ppos))
+                return -ESPIPE;
+
+        ret = spliced = 0;
+
+        lock_sock(sk);
+
+        timeo = sock_rcvtimeo(sk, flags & SPLICE_F_NONBLOCK);
+        while (tss.len) {
+                ret = __tcp_splice_read(sk, &tss);
+                if (ret < 0)
+                        break;
+                else if (!ret) {
+                        if (spliced)
+                                break;
+                        if (flags & SPLICE_F_NONBLOCK) {
+                                ret = -EAGAIN;
+                                break;
+                        }
+                        if (sock_flag(sk, SOCK_DONE))
+                                break;
+                        if (sk->sk_err) {
+                                ret = sock_error(sk);
+                                break;
+                        }
+                        if (sk->sk_shutdown & RCV_SHUTDOWN)
+                                break;
+                        if (sk->sk_state == TCP_CLOSE) {
+                                /*
+                                 * This occurs when user tries to read
+                                 * from never connected socket.
+                                 */
+                                if (!sock_flag(sk, SOCK_DONE))
+                                        ret = -ENOTCONN;
+                                break;
+                        }
+                        if (!timeo) {
+                                ret = -EAGAIN;
+                                break;
+                        }
+                        sk_wait_data(sk, &timeo);
+                        if (signal_pending(current)) {
+                                ret = sock_intr_errno(timeo);
+                                break;
+                        }
+                        continue;
+                }
+                tss.len -= ret;
+                spliced += ret;
+
+                release_sock(sk);
+                lock_sock(sk);
+
+                if (sk->sk_err || sk->sk_state == TCP_CLOSE ||
+                    (sk->sk_shutdown & RCV_SHUTDOWN) || !timeo ||
+                    signal_pending(current))
+                        break;
+        }
+
+        release_sock(sk);
+
+        if (spliced)
+                return spliced;
+
+        return ret;
+}
+
 static ssize_t do_tcp_sendpages(struct sock *sk, struct page **pages, int poffset,
                          size_t psize, int flags)
 {
@@ -2532,6 +2660,7 @@ EXPORT_SYMBOL(tcp_poll);
 EXPORT_SYMBOL(tcp_read_sock);
 EXPORT_SYMBOL(tcp_recvmsg);
 EXPORT_SYMBOL(tcp_sendmsg);
+EXPORT_SYMBOL(tcp_splice_read);
 EXPORT_SYMBOL(tcp_sendpage);
 EXPORT_SYMBOL(tcp_setsockopt);
 EXPORT_SYMBOL(tcp_shutdown);