skbuff: Proactively round up to kmalloc bucket size

commit 12d6c1d3a2ad0c199ec57c201cdc71e8e157a232 upstream.

Instead of discovering the kmalloc bucket size _after_ allocation, round
up proactively so the allocation is explicitly made for the full size,
allowing the compiler to correctly reason about the resulting size of
the buffer through the existing __alloc_size() hint.

This will allow for kernels built with CONFIG_UBSAN_BOUNDS or the
coming dynamic bounds checking under CONFIG_FORTIFY_SOURCE to gain
back the __alloc_size() hints that were temporarily reverted in commit
77fb98704cd0 ("slab: remove __alloc_size attribute from __kmalloc_track_caller")

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: netdev@vger.kernel.org
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Nick Desaulniers <ndesaulniers@google.com>
Cc: David Rientjes <rientjes@google.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Link: https://patchwork.kernel.org/project/netdevbpf/patch/20221021234713.you.031-kees@kernel.org/
Signed-off-by: Kees Cook <keescook@chromium.org>
Link: https://lore.kernel.org/r/20221025223811.up.360-kees@kernel.org
Signed-off-by: Paolo Abeni <pabeni@redhat.com>
Cc: Daniel Díaz <daniel.diaz@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index 47660002cadaf1a0bcbac9c7d1a7b0ccf55d09eb..e37830ef2a4b96bd5a681da18941a7332cc0b0cd 100644 (file)
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -506,14 +506,14 @@ struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,
         */
        size = SKB_DATA_ALIGN(size);
        size += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
-       data = kmalloc_reserve(size, gfp_mask, node, &pfmemalloc);
+       osize = kmalloc_size_roundup(size);
+       data = kmalloc_reserve(osize, gfp_mask, node, &pfmemalloc);
        if (unlikely(!data))
                goto nodata;
-       /* kmalloc(size) might give us more room than requested.
+       /* kmalloc_size_roundup() might give us more room than requested.
         * Put skb_shared_info exactly at the end of allocated zone,
         * to allow max possible filling before reallocation.
         */
-       osize = ksize(data);
        size = SKB_WITH_OVERHEAD(osize);
        prefetchw(data + size);
 
@@ -1822,10 +1822,11 @@ EXPORT_SYMBOL(__pskb_copy_fclone);
 int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail,
                     gfp_t gfp_mask)
 {
-       int i, osize = skb_end_offset(skb);
-       int size = osize + nhead + ntail;
+       unsigned int osize = skb_end_offset(skb);
+       unsigned int size = osize + nhead + ntail;
        long off;
        u8 *data;
+       int i;
 
        BUG_ON(nhead < 0);
 
@@ -1833,15 +1834,16 @@ int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail,
 
        skb_zcopy_downgrade_managed(skb);
 
-       size = SKB_DATA_ALIGN(size);
-
        if (skb_pfmemalloc(skb))
                gfp_mask |= __GFP_MEMALLOC;
-       data = kmalloc_reserve(size + SKB_DATA_ALIGN(sizeof(struct skb_shared_info)),
-                              gfp_mask, NUMA_NO_NODE, NULL);
+
+       size = SKB_DATA_ALIGN(size);
+       size += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
+       size = kmalloc_size_roundup(size);
+       data = kmalloc_reserve(size, gfp_mask, NUMA_NO_NODE, NULL);
        if (!data)
                goto nodata;
-       size = SKB_WITH_OVERHEAD(ksize(data));
+       size = SKB_WITH_OVERHEAD(size);
 
        /* Copy only real data... and, alas, header. This should be
         * optimized for the cases when header is void.
@@ -6182,21 +6184,20 @@ static int pskb_carve_inside_header(struct sk_buff *skb, const u32 off,
                                    const int headlen, gfp_t gfp_mask)
 {
        int i;
-       int size = skb_end_offset(skb);
+       unsigned int size = skb_end_offset(skb);
        int new_hlen = headlen - off;
        u8 *data;
 
-       size = SKB_DATA_ALIGN(size);
-
        if (skb_pfmemalloc(skb))
                gfp_mask |= __GFP_MEMALLOC;
-       data = kmalloc_reserve(size +
-                              SKB_DATA_ALIGN(sizeof(struct skb_shared_info)),
-                              gfp_mask, NUMA_NO_NODE, NULL);
+
+       size = SKB_DATA_ALIGN(size);
+       size += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
+       size = kmalloc_size_roundup(size);
+       data = kmalloc_reserve(size, gfp_mask, NUMA_NO_NODE, NULL);
        if (!data)
                return -ENOMEM;
-
-       size = SKB_WITH_OVERHEAD(ksize(data));
+       size = SKB_WITH_OVERHEAD(size);
 
        /* Copy real data, and all frags */
        skb_copy_from_linear_data_offset(skb, off, data, new_hlen);
@@ -6301,22 +6302,21 @@ static int pskb_carve_inside_nonlinear(struct sk_buff *skb, const u32 off,
                                       int pos, gfp_t gfp_mask)
 {
        int i, k = 0;
-       int size = skb_end_offset(skb);
+       unsigned int size = skb_end_offset(skb);
        u8 *data;
        const int nfrags = skb_shinfo(skb)->nr_frags;
        struct skb_shared_info *shinfo;
 
-       size = SKB_DATA_ALIGN(size);
-
        if (skb_pfmemalloc(skb))
                gfp_mask |= __GFP_MEMALLOC;
-       data = kmalloc_reserve(size +
-                              SKB_DATA_ALIGN(sizeof(struct skb_shared_info)),
-                              gfp_mask, NUMA_NO_NODE, NULL);
+
+       size = SKB_DATA_ALIGN(size);
+       size += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
+       size = kmalloc_size_roundup(size);
+       data = kmalloc_reserve(size, gfp_mask, NUMA_NO_NODE, NULL);
        if (!data)
                return -ENOMEM;
-
-       size = SKB_WITH_OVERHEAD(ksize(data));
+       size = SKB_WITH_OVERHEAD(size);
 
        memcpy((struct skb_shared_info *)(data + size),
               skb_shinfo(skb), offsetof(struct skb_shared_info, frags[0]));