iov_iter, net: Move csum_and_copy_to/from_iter() to net/

Move csum_and_copy_to/from_iter() to net code now that the iteration
framework can be #included.

Signed-off-by: David Howells <dhowells@redhat.com>
Link: https://lore.kernel.org/r/20230925120309.1731676-10-dhowells@redhat.com
cc: Alexander Viro <viro@zeniv.linux.org.uk>
cc: Jens Axboe <axboe@kernel.dk>
cc: Christoph Hellwig <hch@lst.de>
cc: Christian Brauner <christian@brauner.io>
cc: Matthew Wilcox <willy@infradead.org>
cc: Linus Torvalds <torvalds@linux-foundation.org>
cc: David Laight <David.Laight@ACULAB.COM>
cc: "David S. Miller" <davem@davemloft.net>
cc: Eric Dumazet <edumazet@google.com>
cc: Jakub Kicinski <kuba@kernel.org>
cc: Paolo Abeni <pabeni@redhat.com>
cc: linux-block@vger.kernel.org
cc: linux-fsdevel@vger.kernel.org
cc: linux-mm@kvack.org
cc: netdev@vger.kernel.org
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 4174c4b82d13b90198d155acdf3a3a455b759c9c..d0656cc11c16a372879c3bc4d01392084cf25bfb 100644 (file)
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -3679,6 +3679,31 @@ static inline int __must_check skb_put_padto(struct sk_buff *skb, unsigned int l
        return __skb_put_padto(skb, len, true);
 }
 
+static inline __wsum csum_and_memcpy(void *to, const void *from, size_t len,
+                                    __wsum sum, size_t off)
+{
+       __wsum next = csum_partial_copy_nocheck(from, to, len);
+       return csum_block_add(sum, next, off);
+}
+
+struct csum_state {
+       __wsum csum;
+       size_t off;
+};
+
+size_t csum_and_copy_from_iter(void *addr, size_t bytes, __wsum *csum, struct iov_iter *i);
+
+static __always_inline __must_check
+bool csum_and_copy_from_iter_full(void *addr, size_t bytes,
+                                 __wsum *csum, struct iov_iter *i)
+{
+       size_t copied = csum_and_copy_from_iter(addr, bytes, csum, i);
+       if (likely(copied == bytes))
+               return true;
+       iov_iter_revert(i, copied);
+       return false;
+}
+
 static inline int skb_add_data(struct sk_buff *skb,
                               struct iov_iter *from, int copy)
 {

diff --git a/include/linux/uio.h b/include/linux/uio.h
index 65d9143f83c8f323978d4f8172aea8f7d1f07f8a..0a5426c97e024343fd5daec4270cab29b20bdc87 100644 (file)
--- a/include/linux/uio.h
+++ b/include/linux/uio.h
@@ -338,24 +338,6 @@ iov_iter_npages_cap(struct iov_iter *i, int maxpages, size_t max_bytes)
        return npages;
 }
 
-struct csum_state {
-       __wsum csum;
-       size_t off;
-};
-
-size_t csum_and_copy_to_iter(const void *addr, size_t bytes, void *csstate, struct iov_iter *i);
-size_t csum_and_copy_from_iter(void *addr, size_t bytes, __wsum *csum, struct iov_iter *i);
-
-static __always_inline __must_check
-bool csum_and_copy_from_iter_full(void *addr, size_t bytes,
-                                 __wsum *csum, struct iov_iter *i)
-{
-       size_t copied = csum_and_copy_from_iter(addr, bytes, csum, i);
-       if (likely(copied == bytes))
-               return true;
-       iov_iter_revert(i, copied);
-       return false;
-}
 size_t hash_and_copy_to_iter(const void *addr, size_t bytes, void *hashp,
                struct iov_iter *i);
 

diff --git a/lib/iov_iter.c b/lib/iov_iter.c
index 0a7160aa4e31320d2d16e0e6eb57fda193d4a7e7..3f913616ce8847a581276b24c41c02c38f10b1c0 100644 (file)
--- a/lib/iov_iter.c
+++ b/lib/iov_iter.c
@@ -10,7 +10,6 @@
 #include <linux/vmalloc.h>
 #include <linux/splice.h>
 #include <linux/compat.h>
-#include <net/checksum.h>
 #include <linux/scatterlist.h>
 #include <linux/instrumented.h>
 #include <linux/iov_iter.h>
@@ -179,13 +178,6 @@ void iov_iter_init(struct iov_iter *i, unsigned int direction,
 }
 EXPORT_SYMBOL(iov_iter_init);
 
-static __wsum csum_and_memcpy(void *to, const void *from, size_t len,
-                             __wsum sum, size_t off)
-{
-       __wsum next = csum_partial_copy_nocheck(from, to, len);
-       return csum_block_add(sum, next, off);
-}
-
 size_t _copy_to_iter(const void *addr, size_t bytes, struct iov_iter *i)
 {
        if (WARN_ON_ONCE(i->data_source))
@@ -1097,87 +1089,6 @@ ssize_t iov_iter_get_pages_alloc2(struct iov_iter *i,
 }
 EXPORT_SYMBOL(iov_iter_get_pages_alloc2);
 
-static __always_inline
-size_t copy_from_user_iter_csum(void __user *iter_from, size_t progress,
-                               size_t len, void *to, void *priv2)
-{
-       __wsum next, *csum = priv2;
-
-       next = csum_and_copy_from_user(iter_from, to + progress, len);
-       *csum = csum_block_add(*csum, next, progress);
-       return next ? 0 : len;
-}
-
-static __always_inline
-size_t memcpy_from_iter_csum(void *iter_from, size_t progress,
-                            size_t len, void *to, void *priv2)
-{
-       __wsum *csum = priv2;
-
-       *csum = csum_and_memcpy(to + progress, iter_from, len, *csum, progress);
-       return 0;
-}
-
-size_t csum_and_copy_from_iter(void *addr, size_t bytes, __wsum *csum,
-                              struct iov_iter *i)
-{
-       if (WARN_ON_ONCE(!i->data_source))
-               return 0;
-       return iterate_and_advance2(i, bytes, addr, csum,
-                                   copy_from_user_iter_csum,
-                                   memcpy_from_iter_csum);
-}
-EXPORT_SYMBOL(csum_and_copy_from_iter);
-
-static __always_inline
-size_t copy_to_user_iter_csum(void __user *iter_to, size_t progress,
-                             size_t len, void *from, void *priv2)
-{
-       __wsum next, *csum = priv2;
-
-       next = csum_and_copy_to_user(from + progress, iter_to, len);
-       *csum = csum_block_add(*csum, next, progress);
-       return next ? 0 : len;
-}
-
-static __always_inline
-size_t memcpy_to_iter_csum(void *iter_to, size_t progress,
-                          size_t len, void *from, void *priv2)
-{
-       __wsum *csum = priv2;
-
-       *csum = csum_and_memcpy(iter_to, from + progress, len, *csum, progress);
-       return 0;
-}
-
-size_t csum_and_copy_to_iter(const void *addr, size_t bytes, void *_csstate,
-                            struct iov_iter *i)
-{
-       struct csum_state *csstate = _csstate;
-       __wsum sum;
-
-       if (WARN_ON_ONCE(i->data_source))
-               return 0;
-       if (unlikely(iov_iter_is_discard(i))) {
-               // can't use csum_memcpy() for that one - data is not copied
-               csstate->csum = csum_block_add(csstate->csum,
-                                              csum_partial(addr, bytes, 0),
-                                              csstate->off);
-               csstate->off += bytes;
-               return bytes;
-       }
-
-       sum = csum_shift(csstate->csum, csstate->off);
-       
-       bytes = iterate_and_advance2(i, bytes, (void *)addr, &sum,
-                                    copy_to_user_iter_csum,
-                                    memcpy_to_iter_csum);
-       csstate->csum = csum_shift(sum, csstate->off);
-       csstate->off += bytes;
-       return bytes;
-}
-EXPORT_SYMBOL(csum_and_copy_to_iter);
-
 size_t hash_and_copy_to_iter(const void *addr, size_t bytes, void *hashp,
                struct iov_iter *i)
 {

diff --git a/net/core/datagram.c b/net/core/datagram.c
index 176eb58347461b160890ce2d6b2d3cbc7412e321..37c89d0933b700e72ac6cc911f74e33af623b184 100644 (file)
--- a/net/core/datagram.c
+++ b/net/core/datagram.c
@@ -50,7 +50,7 @@
 #include <linux/spinlock.h>
 #include <linux/slab.h>
 #include <linux/pagemap.h>
-#include <linux/uio.h>
+#include <linux/iov_iter.h>
 #include <linux/indirect_call_wrapper.h>
 
 #include <net/protocol.h>
@@ -716,6 +716,54 @@ int zerocopy_sg_from_iter(struct sk_buff *skb, struct iov_iter *from)
 }
 EXPORT_SYMBOL(zerocopy_sg_from_iter);
 
+static __always_inline
+size_t copy_to_user_iter_csum(void __user *iter_to, size_t progress,
+                             size_t len, void *from, void *priv2)
+{
+       __wsum next, *csum = priv2;
+
+       next = csum_and_copy_to_user(from + progress, iter_to, len);
+       *csum = csum_block_add(*csum, next, progress);
+       return next ? 0 : len;
+}
+
+static __always_inline
+size_t memcpy_to_iter_csum(void *iter_to, size_t progress,
+                          size_t len, void *from, void *priv2)
+{
+       __wsum *csum = priv2;
+
+       *csum = csum_and_memcpy(iter_to, from + progress, len, *csum, progress);
+       return 0;
+}
+
+static size_t csum_and_copy_to_iter(const void *addr, size_t bytes, void *_csstate,
+                                   struct iov_iter *i)
+{
+       struct csum_state *csstate = _csstate;
+       __wsum sum;
+
+       if (WARN_ON_ONCE(i->data_source))
+               return 0;
+       if (unlikely(iov_iter_is_discard(i))) {
+               // can't use csum_memcpy() for that one - data is not copied
+               csstate->csum = csum_block_add(csstate->csum,
+                                              csum_partial(addr, bytes, 0),
+                                              csstate->off);
+               csstate->off += bytes;
+               return bytes;
+       }
+
+       sum = csum_shift(csstate->csum, csstate->off);
+
+       bytes = iterate_and_advance2(i, bytes, (void *)addr, &sum,
+                                    copy_to_user_iter_csum,
+                                    memcpy_to_iter_csum);
+       csstate->csum = csum_shift(sum, csstate->off);
+       csstate->off += bytes;
+       return bytes;
+}
+
 /**
  *     skb_copy_and_csum_datagram - Copy datagram to an iovec iterator
  *          and update a checksum.

diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index 4eaf7ed0d1f44e8305109da2da2835013786a857..5dbdfce2d05f04324d48933ddf474c0c12321131 100644 (file)
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -62,6 +62,7 @@
 #include <linux/if_vlan.h>
 #include <linux/mpls.h>
 #include <linux/kcov.h>
+#include <linux/iov_iter.h>
 
 #include <net/protocol.h>
 #include <net/dst.h>
@@ -6931,3 +6932,35 @@ out:
        return spliced ?: ret;
 }
 EXPORT_SYMBOL(skb_splice_from_iter);
+
+static __always_inline
+size_t memcpy_from_iter_csum(void *iter_from, size_t progress,
+                            size_t len, void *to, void *priv2)
+{
+       __wsum *csum = priv2;
+
+       *csum = csum_and_memcpy(to + progress, iter_from, len, *csum, progress);
+       return 0;
+}
+
+static __always_inline
+size_t copy_from_user_iter_csum(void __user *iter_from, size_t progress,
+                               size_t len, void *to, void *priv2)
+{
+       __wsum next, *csum = priv2;
+
+       next = csum_and_copy_from_user(iter_from, to + progress, len);
+       *csum = csum_block_add(*csum, next, progress);
+       return next ? 0 : len;
+}
+
+size_t csum_and_copy_from_iter(void *addr, size_t bytes, __wsum *csum,
+                              struct iov_iter *i)
+{
+       if (WARN_ON_ONCE(!i->data_source))
+               return 0;
+       return iterate_and_advance2(i, bytes, addr, csum,
+                                   copy_from_user_iter_csum,
+                                   memcpy_from_iter_csum);
+}
+EXPORT_SYMBOL(csum_and_copy_from_iter);