skb_splice_bits(): get rid of callback

since pipe_lock is the outermost now, we don't need to drop/regain
socket locks around the call of splice_to_pipe() from skb_splice_bits(),
which kills the need to have a socket-specific callback; we can just
call splice_to_pipe() and be done with that.

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 0f665cb26b505729fad04be94ead98ff99e79359..f520251ec43f65a4cd01afc89b02349bcb261726 100644 (file)
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -3021,15 +3021,9 @@ int skb_copy_bits(const struct sk_buff *skb, int offset, void *to, int len);
 int skb_store_bits(struct sk_buff *skb, int offset, const void *from, int len);
 __wsum skb_copy_and_csum_bits(const struct sk_buff *skb, int offset, u8 *to,
                              int len, __wsum csum);
-ssize_t skb_socket_splice(struct sock *sk,
-                         struct pipe_inode_info *pipe,
-                         struct splice_pipe_desc *spd);
 int skb_splice_bits(struct sk_buff *skb, struct sock *sk, unsigned int offset,
                    struct pipe_inode_info *pipe, unsigned int len,
-                   unsigned int flags,
-                   ssize_t (*splice_cb)(struct sock *,
-                                        struct pipe_inode_info *,
-                                        struct splice_pipe_desc *));
+                   unsigned int flags);
 void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
 unsigned int skb_zerocopy_headlen(const struct sk_buff *from);
 int skb_zerocopy(struct sk_buff *to, struct sk_buff *from,

diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index 3864b4b68fa1ee0af153c420c2eecebb908a5e99..208a9bc4af7400c3189584ae46afbb91b1ffd799 100644 (file)
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -1962,37 +1962,13 @@ static bool __skb_splice_bits(struct sk_buff *skb, struct pipe_inode_info *pipe,
        return false;
 }
 
-ssize_t skb_socket_splice(struct sock *sk,
-                         struct pipe_inode_info *pipe,
-                         struct splice_pipe_desc *spd)
-{
-       int ret;
-
-       /* Drop the socket lock, otherwise we have reverse
-        * locking dependencies between sk_lock and i_mutex
-        * here as compared to sendfile(). We enter here
-        * with the socket lock held, and splice_to_pipe() will
-        * grab the pipe inode lock. For sendfile() emulation,
-        * we call into ->sendpage() with the i_mutex lock held
-        * and networking will grab the socket lock.
-        */
-       release_sock(sk);
-       ret = splice_to_pipe(pipe, spd);
-       lock_sock(sk);
-
-       return ret;
-}
-
 /*
  * Map data from the skb to a pipe. Should handle both the linear part,
  * the fragments, and the frag list.
  */
 int skb_splice_bits(struct sk_buff *skb, struct sock *sk, unsigned int offset,
                    struct pipe_inode_info *pipe, unsigned int tlen,
-                   unsigned int flags,
-                   ssize_t (*splice_cb)(struct sock *,
-                                        struct pipe_inode_info *,
-                                        struct splice_pipe_desc *))
+                   unsigned int flags)
 {
        struct partial_page partial[MAX_SKB_FRAGS];
        struct page *pages[MAX_SKB_FRAGS];
@@ -2009,7 +1985,7 @@ int skb_splice_bits(struct sk_buff *skb, struct sock *sk, unsigned int offset,
        __skb_splice_bits(skb, pipe, &offset, &tlen, &spd, sk);
 
        if (spd.nr_pages)
-               ret = splice_cb(sk, pipe, &spd);
+               ret = splice_to_pipe(pipe, &spd);
 
        return ret;
 }

diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index ffbb218de52057afbc55f95386200226a1c60517..ddd2179538f772117d2d132eb077419b1bc3799d 100644 (file)
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -688,8 +688,7 @@ static int tcp_splice_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb,
        int ret;
 
        ret = skb_splice_bits(skb, skb->sk, offset, tss->pipe,
-                             min(rd_desc->count, len), tss->flags,
-                             skb_socket_splice);
+                             min(rd_desc->count, len), tss->flags);
        if (ret > 0)
                rd_desc->count -= ret;
        return ret;

diff --git a/net/kcm/kcmsock.c b/net/kcm/kcmsock.c
index 411693288648dc3eb27b0b2a0c542be92762ad8a..8a720ba50061617e3dcd9e25f455b97016401438 100644 (file)
--- a/net/kcm/kcmsock.c
+++ b/net/kcm/kcmsock.c
@@ -1462,19 +1462,6 @@ out:
        return copied ? : err;
 }
 
-static ssize_t kcm_sock_splice(struct sock *sk,
-                              struct pipe_inode_info *pipe,
-                              struct splice_pipe_desc *spd)
-{
-       int ret;
-
-       release_sock(sk);
-       ret = splice_to_pipe(pipe, spd);
-       lock_sock(sk);
-
-       return ret;
-}
-
 static ssize_t kcm_splice_read(struct socket *sock, loff_t *ppos,
                               struct pipe_inode_info *pipe, size_t len,
                               unsigned int flags)
@@ -1504,8 +1491,7 @@ static ssize_t kcm_splice_read(struct socket *sock, loff_t *ppos,
        if (len > rxm->full_len)
                len = rxm->full_len;
 
-       copied = skb_splice_bits(skb, sk, rxm->offset, pipe, len, flags,
-                                kcm_sock_splice);
+       copied = skb_splice_bits(skb, sk, rxm->offset, pipe, len, flags);
        if (copied < 0) {
                err = copied;
                goto err_out;

diff --git a/net/unix/af_unix.c b/net/unix/af_unix.c
index 8309687a56b04f750560245ace8ed4bfbf969a1e..145082e2ba36068192ccef517804a14aa0d08752 100644 (file)
--- a/net/unix/af_unix.c
+++ b/net/unix/af_unix.c
@@ -2475,28 +2475,13 @@ static int unix_stream_recvmsg(struct socket *sock, struct msghdr *msg,
        return unix_stream_read_generic(&state);
 }
 
-static ssize_t skb_unix_socket_splice(struct sock *sk,
-                                     struct pipe_inode_info *pipe,
-                                     struct splice_pipe_desc *spd)
-{
-       int ret;
-       struct unix_sock *u = unix_sk(sk);
-
-       mutex_unlock(&u->iolock);
-       ret = splice_to_pipe(pipe, spd);
-       mutex_lock(&u->iolock);
-
-       return ret;
-}
-
 static int unix_stream_splice_actor(struct sk_buff *skb,
                                    int skip, int chunk,
                                    struct unix_stream_read_state *state)
 {
        return skb_splice_bits(skb, state->socket->sk,
                               UNIXCB(skb).consumed + skip,
-                              state->pipe, chunk, state->splice_flags,
-                              skb_unix_socket_splice);
+                              state->pipe, chunk, state->splice_flags);
 }
 
 static ssize_t unix_stream_splice_read(struct socket *sock,  loff_t *ppos,