GCC and Clang can use the "alloc_size" attribute to better inform the results of __builtin_object_size() (for compile-time constant values). Clang can additionally use alloc_size to inform the results of __builtin_dynamic_object_size() (for run-time values). Because GCC sees the frequent use of struct_size() as an allocator size argument, and notices it can return SIZE_MAX (the overflow indication), it complains about these call sites overflowing (since SIZE_MAX is greater than the default -Walloc-size-larger-than=PTRDIFF_MAX). This isn't helpful since we already know a SIZE_MAX will be caught at run-time (this was an intentional design). To deal with this, we must disable this check as it is both a false positive and redundant. (Clang does not have this warning option.) Unfortunately, just checking the -Wno-alloc-size-larger-than is not sufficient to make the __alloc_size attribute behave correctly under older GCC versions. The attribute itself must be disabled in those situations too, as there appears to be no way to reliably silence the SIZE_MAX constant expression cases for GCC versions less than 9.1: In file included from ./include/linux/resource_ext.h:11, from ./include/linux/pci.h:40, from drivers/net/ethernet/intel/ixgbe/ixgbe.h:9, from drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c:4: In function 'kmalloc_node', inlined from 'ixgbe_alloc_q_vector' at ./include/linux/slab.h:743:9: ./include/linux/slab.h:618:9: error: argument 1 value '18446744073709551615' exceeds maximum object size 9223372036854775807 [-Werror=alloc-size-larger-than=] return __kmalloc_node(size, flags, node); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ./include/linux/slab.h: In function 'ixgbe_alloc_q_vector': ./include/linux/slab.h:455:7: note: in a call to allocation function '__kmalloc_node' declared here void *__kmalloc_node(size_t size, gfp_t flags, int node) __assume_slab_alignment __malloc; ^~~~~~~~~~~~~~ Specifically: '-Wno-alloc-size-larger-than' is not correctly handled by GCC < 9.1 https://godbolt.org/z/hqsfG7q84 (doesn't disable) https://godbolt.org/z/P9jdrPTYh (doesn't admit to not knowing about option) https://godbolt.org/z/465TPMWKb (only warns when other warnings appear) '-Walloc-size-larger-than=18446744073709551615' is not handled by GCC < 8.2 https://godbolt.org/z/73hh1EPxz (ignores numeric value) Since anything marked with __alloc_size would also qualify for marking with __malloc, just include __malloc along with it to avoid redundant markings. (Suggested by Linus Torvalds.) Finally, make sure checkpatch.pl doesn't get confused about finding the __alloc_size attribute on functions. (Thanks to Joe Perches.)
Unified · Split
| @@ -1008,6 +1008,21 @@ ifdef CONFIG_CC_IS_GCC · 1007 unmodified lines | ||
| 1008 | 1008 | KBUILD_CFLAGS += -Wno-maybe-uninitialized |
| 1009 | 1009 | endif |
| 1010 | 1010 | |
| 1011 | +ifdef CONFIG_CC_IS_GCC | |
| 1012 | +# The allocators already balk at large sizes, so silence the compiler | |
| 1013 | +# warnings for bounds checks involving those possible values. While | |
| 1014 | +# -Wno-alloc-size-larger-than would normally be used here, earlier versions | |
| 1015 | +# of gcc (<9.1) weirdly don't handle the option correctly when _other_ | |
| 1016 | +# warnings are produced (?!). Using -Walloc-size-larger-than=SIZE_MAX | |
| 1017 | +# doesn't work (as it is documented to), silently resolving to "0" prior to | |
| 1018 | +# version 9.1 (and producing an error more recently). Numeric values larger | |
| 1019 | +# than PTRDIFF_MAX also don't work prior to version 9.1, which are silently | |
| 1020 | +# ignored, continuing to default to PTRDIFF_MAX. So, left with no other | |
| 1021 | +# choice, we must perform a versioned check to disable this warning. | |
| 1022 | +# https://lore.kernel.org/lkml/20210824115859.187f272f@canb.auug.org.au | |
| 1023 | +KBUILD_CFLAGS += $(call cc-ifversion, -ge, 0901, -Wno-alloc-size-larger-than) | |
| 1024 | +endif | |
| 1025 | + | |
| 1011 | 1026 | # disable invalid "can't wrap" optimizations for signed / pointers |
| 1012 | 1027 | KBUILD_CFLAGS += -fno-strict-overflow |
| 1013 | 1028 | |
| @@ -144,3 +144,11 @@ · 143 unmodified lines | ||
| 144 | 144 | #else |
| 145 | 145 | #define __diag_GCC_8(s) |
| 146 | 146 | #endif |
| 147 | + | |
| 148 | +/* | |
| 149 | + * Prior to 9.1, -Wno-alloc-size-larger-than (and therefore the "alloc_size" | |
| 150 | + * attribute) do not work, and must be disabled. | |
| 151 | + */ | |
| 152 | +#if GCC_VERSION < 90100 | |
| 153 | +#undef __alloc_size__ | |
| 154 | +#endif | |
| @@ -33,6 +33,15 @@ · 32 unmodified lines | ||
| 33 | 33 | #define __aligned(x) __attribute__((__aligned__(x))) |
| 34 | 34 | #define __aligned_largest __attribute__((__aligned__)) |
| 35 | 35 | |
| 36 | +/* | |
| 37 | + * Note: do not use this directly. Instead, use __alloc_size() since it is conditionally | |
| 38 | + * available and includes other attributes. | |
| 39 | + * | |
| 40 | + * gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-alloc_005fsize-function-attribute | |
| 41 | + * clang: https://clang.llvm.org/docs/AttributeReference.html#alloc-size | |
| 42 | + */ | |
| 43 | +#define __alloc_size__(x, ...) __attribute__((__alloc_size__(x, ## __VA_ARGS__))) | |
| 44 | + | |
| 36 | 45 | /* |
| 37 | 46 | * Note: users of __always_inline currently do not write "inline" themselves, |
| 38 | 47 | * which seems to be required by gcc to apply the attribute according |
| @@ -153,6 +162,7 @@ · 114 unmodified lines | ||
| 153 | 162 | |
| 154 | 163 | /* |
| 155 | 164 | * gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-malloc-function-attribute |
| 165 | + * clang: https://clang.llvm.org/docs/AttributeReference.html#malloc | |
| 156 | 166 | */ |
| 157 | 167 | #define __malloc __attribute__((__malloc__)) |
| 158 | 168 | |
| @@ -250,6 +250,18 @@ struct ftrace_likely_data { · 249 unmodified lines | ||
| 250 | 250 | # define __cficanonical |
| 251 | 251 | #endif |
| 252 | 252 | |
| 253 | +/* | |
| 254 | + * Any place that could be marked with the "alloc_size" attribute is also | |
| 255 | + * a place to be marked with the "malloc" attribute. Do this as part of the | |
| 256 | + * __alloc_size macro to avoid redundant attributes and to avoid missing a | |
| 257 | + * __malloc marking. | |
| 258 | + */ | |
| 259 | +#ifdef __alloc_size__ | |
| 260 | +# define __alloc_size(x, ...) __alloc_size__(x, ## __VA_ARGS__) __malloc | |
| 261 | +#else | |
| 262 | +# define __alloc_size(x, ...) __malloc | |
| 263 | +#endif | |
| 264 | + | |
| 253 | 265 | #ifndef asm_volatile_goto |
| 254 | 266 | #define asm_volatile_goto(x...) asm goto(x) |
| 255 | 267 | #endif |
| @@ -489,7 +489,8 @@ our $Attribute = qr{ · 488 unmodified lines | ||
| 489 | 489 | ____cacheline_aligned| |
| 490 | 490 | ____cacheline_aligned_in_smp| |
| 491 | 491 | ____cacheline_internodealigned_in_smp| |
| 492 | − __weak | |
| 492 | + __weak| | |
| 493 | + __alloc_size\s*\(\s*\d+\s*(?:,\s*\d+\s*)?\) | |
| 493 | 494 | }x; |
| 494 | 495 | our $Modifier; |
| 495 | 496 | our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__}; |