From: Greg Kroah-Hartman Date: Thu, 9 Jul 2026 14:23:55 +0000 (+0200) Subject: 6.18-stable patches X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=2669e8c0a8bab924d1f4ba6085f71909b0073c40;p=thirdparty%2Fkernel%2Fstable-queue.git 6.18-stable patches added patches: add-default_gfp-helper-macro-and-use-it-in-the-new-alloc_obj-helpers.patch default_gfp-avoid-using-the-newfangled-__va_opt__-trick.patch perf-trace-beauty-fcntl-fix-build-with-older-kernel-headers.patch slab-introduce-kmalloc_flex-and-family.patch slab-recognize-gfp-parameter-as-optional-in-kernel-doc.patch --- diff --git a/queue-6.18/add-default_gfp-helper-macro-and-use-it-in-the-new-alloc_obj-helpers.patch b/queue-6.18/add-default_gfp-helper-macro-and-use-it-in-the-new-alloc_obj-helpers.patch new file mode 100644 index 0000000000..79de9a583d --- /dev/null +++ b/queue-6.18/add-default_gfp-helper-macro-and-use-it-in-the-new-alloc_obj-helpers.patch @@ -0,0 +1,131 @@ +From e19e1b480ac73c3e62ffebbca1174f0f511f43e7 Mon Sep 17 00:00:00 2001 +From: Linus Torvalds +Date: Sat, 21 Feb 2026 16:14:11 -0800 +Subject: add default_gfp() helper macro and use it in the new *alloc_obj() helpers + +From: Linus Torvalds + +commit e19e1b480ac73c3e62ffebbca1174f0f511f43e7 upstream. + +Most simple allocations use GFP_KERNEL, and with the new allocation +helpers being introduced, let's just take advantage of that to simplify +that default case. + +It's a numbers game: + + git grep 'alloc_obj(' | + sed 's/.*\(GFP_[_A-Z]*\).*/\1/' | + sort | uniq -c | sort -n | tail + +shows that about 90% of all those new allocator instances just use that +standard GFP_KERNEL. + +Those helpers are already macros, and we can easily just make it be the +default case when the gfp argument is missing. + +And yes, we could do that for all the legacy interfaces too, but let's +keep it to just the new ones at least for now, since those all got +converted recently anyway, so this is not any "extra" noise outside of +that limited conversion. + +And, in fact, I want to do this before doing the -rc1 release, exactly +so that we don't get extra merge conflicts. + +Signed-off-by: Linus Torvalds +Signed-off-by: Eric Biggers +Signed-off-by: Greg Kroah-Hartman +--- + include/linux/gfp.h | 4 ++++ + include/linux/slab.h | 48 ++++++++++++++++++++++++------------------------ + 2 files changed, 28 insertions(+), 24 deletions(-) + +--- a/include/linux/gfp.h ++++ b/include/linux/gfp.h +@@ -13,6 +13,10 @@ + struct vm_area_struct; + struct mempolicy; + ++/* Helper macro to avoid gfp flags if they are the default one */ ++#define __default_gfp(a,...) a ++#define default_gfp(...) __default_gfp(__VA_ARGS__ __VA_OPT__(,) GFP_KERNEL) ++ + /* Convert GFP flags to their corresponding migrate type */ + #define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE) + #define GFP_MOVABLE_SHIFT 3 +--- a/include/linux/slab.h ++++ b/include/linux/slab.h +@@ -1011,8 +1011,8 @@ void *kmalloc_nolock_noprof(size_t size, + * Returns: newly allocated pointer to a @VAR_OR_TYPE on success, or NULL + * on failure. + */ +-#define kmalloc_obj(VAR_OR_TYPE, GFP) \ +- __alloc_objs(kmalloc, GFP, typeof(VAR_OR_TYPE), 1) ++#define kmalloc_obj(VAR_OR_TYPE, ...) \ ++ __alloc_objs(kmalloc, default_gfp(__VA_ARGS__), typeof(VAR_OR_TYPE), 1) + + /** + * kmalloc_objs - Allocate an array of the given type +@@ -1023,8 +1023,8 @@ void *kmalloc_nolock_noprof(size_t size, + * Returns: newly allocated pointer to array of @VAR_OR_TYPE on success, + * or NULL on failure. + */ +-#define kmalloc_objs(VAR_OR_TYPE, COUNT, GFP) \ +- __alloc_objs(kmalloc, GFP, typeof(VAR_OR_TYPE), COUNT) ++#define kmalloc_objs(VAR_OR_TYPE, COUNT, ...) \ ++ __alloc_objs(kmalloc, default_gfp(__VA_ARGS__), typeof(VAR_OR_TYPE), COUNT) + + /** + * kmalloc_flex - Allocate a single instance of the given flexible structure +@@ -1038,32 +1038,32 @@ void *kmalloc_nolock_noprof(size_t size, + * will immediately fail if @COUNT is larger than what the type of the + * struct's counter variable can represent. + */ +-#define kmalloc_flex(VAR_OR_TYPE, FAM, COUNT, GFP) \ +- __alloc_flex(kmalloc, GFP, typeof(VAR_OR_TYPE), FAM, COUNT) ++#define kmalloc_flex(VAR_OR_TYPE, FAM, COUNT, ...) \ ++ __alloc_flex(kmalloc, default_gfp(__VA_ARGS__), typeof(VAR_OR_TYPE), FAM, COUNT) + + /* All kzalloc aliases for kmalloc_(obj|objs|flex). */ +-#define kzalloc_obj(P, GFP) \ +- __alloc_objs(kzalloc, GFP, typeof(P), 1) +-#define kzalloc_objs(P, COUNT, GFP) \ +- __alloc_objs(kzalloc, GFP, typeof(P), COUNT) +-#define kzalloc_flex(P, FAM, COUNT, GFP) \ +- __alloc_flex(kzalloc, GFP, typeof(P), FAM, COUNT) ++#define kzalloc_obj(P, ...) \ ++ __alloc_objs(kzalloc, default_gfp(__VA_ARGS__), typeof(P), 1) ++#define kzalloc_objs(P, COUNT, ...) \ ++ __alloc_objs(kzalloc, default_gfp(__VA_ARGS__), typeof(P), COUNT) ++#define kzalloc_flex(P, FAM, COUNT, ...) \ ++ __alloc_flex(kzalloc, default_gfp(__VA_ARGS__), typeof(P), FAM, COUNT) + + /* All kvmalloc aliases for kmalloc_(obj|objs|flex). */ +-#define kvmalloc_obj(P, GFP) \ +- __alloc_objs(kvmalloc, GFP, typeof(P), 1) +-#define kvmalloc_objs(P, COUNT, GFP) \ +- __alloc_objs(kvmalloc, GFP, typeof(P), COUNT) +-#define kvmalloc_flex(P, FAM, COUNT, GFP) \ +- __alloc_flex(kvmalloc, GFP, typeof(P), FAM, COUNT) ++#define kvmalloc_obj(P, ...) \ ++ __alloc_objs(kvmalloc, default_gfp(__VA_ARGS__), typeof(P), 1) ++#define kvmalloc_objs(P, COUNT, ...) \ ++ __alloc_objs(kvmalloc, default_gfp(__VA_ARGS__), typeof(P), COUNT) ++#define kvmalloc_flex(P, FAM, COUNT, ...) \ ++ __alloc_flex(kvmalloc, default_gfp(__VA_ARGS__), typeof(P), FAM, COUNT) + + /* All kvzalloc aliases for kmalloc_(obj|objs|flex). */ +-#define kvzalloc_obj(P, GFP) \ +- __alloc_objs(kvzalloc, GFP, typeof(P), 1) +-#define kvzalloc_objs(P, COUNT, GFP) \ +- __alloc_objs(kvzalloc, GFP, typeof(P), COUNT) +-#define kvzalloc_flex(P, FAM, COUNT, GFP) \ +- __alloc_flex(kvzalloc, GFP, typeof(P), FAM, COUNT) ++#define kvzalloc_obj(P, ...) \ ++ __alloc_objs(kvzalloc, default_gfp(__VA_ARGS__), typeof(P), 1) ++#define kvzalloc_objs(P, COUNT, ...) \ ++ __alloc_objs(kvzalloc, default_gfp(__VA_ARGS__), typeof(P), COUNT) ++#define kvzalloc_flex(P, FAM, COUNT, ...) \ ++ __alloc_flex(kvzalloc, default_gfp(__VA_ARGS__), typeof(P), FAM, COUNT) + + #define kmem_buckets_alloc(_b, _size, _flags) \ + alloc_hooks(__kmalloc_node_noprof(PASS_BUCKET_PARAMS(_size, _b), _flags, NUMA_NO_NODE)) diff --git a/queue-6.18/default_gfp-avoid-using-the-newfangled-__va_opt__-trick.patch b/queue-6.18/default_gfp-avoid-using-the-newfangled-__va_opt__-trick.patch new file mode 100644 index 0000000000..3b8a4d70cd --- /dev/null +++ b/queue-6.18/default_gfp-avoid-using-the-newfangled-__va_opt__-trick.patch @@ -0,0 +1,47 @@ +From 551d44200152cb26f75d2ef990aeb6185b7e37fd Mon Sep 17 00:00:00 2001 +From: Linus Torvalds +Date: Mon, 23 Feb 2026 09:33:08 -0800 +Subject: default_gfp(): avoid using the "newfangled" __VA_OPT__ trick + +From: Linus Torvalds + +commit 551d44200152cb26f75d2ef990aeb6185b7e37fd upstream. + +The default_gfp() helper that I added is not wrong, but it turns out +that it causes unnecessary headaches for 'sparse' which doesn't support +the use of __VA_OPT__ (introduced in C++20 and C23, and supported by gcc +and clang for a long time). + +We do already use __VA_OPT__ in some other cases in the kernel (drm/xe +and btrfs), but it has been fairly limited. Now it triggers for pretty +much everything, and sparse ends up not working at all. + +We can use the traditional gcc ',##__VA_ARGS__' syntax instead: it may +not be the "C standard" way and is slightly less natural in this +context, but it is the traditional model for this and avoids the sparse +problem. + +Reported-and-tested-by: Ricardo Ribalda +Reported-and-tested-by: Richard Fitzgerald +Reported-by: Ben Dooks +Fixes: e19e1b480ac7 ("add default_gfp() helper macro and use it in the new *alloc_obj() helpers") +Signed-off-by: Linus Torvalds +Signed-off-by: Eric Biggers +Signed-off-by: Greg Kroah-Hartman +--- + include/linux/gfp.h | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +--- a/include/linux/gfp.h ++++ b/include/linux/gfp.h +@@ -14,8 +14,8 @@ struct vm_area_struct; + struct mempolicy; + + /* Helper macro to avoid gfp flags if they are the default one */ +-#define __default_gfp(a,...) a +-#define default_gfp(...) __default_gfp(__VA_ARGS__ __VA_OPT__(,) GFP_KERNEL) ++#define __default_gfp(a,b,...) b ++#define default_gfp(...) __default_gfp(,##__VA_ARGS__,GFP_KERNEL) + + /* Convert GFP flags to their corresponding migrate type */ + #define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE) diff --git a/queue-6.18/perf-trace-beauty-fcntl-fix-build-with-older-kernel-headers.patch b/queue-6.18/perf-trace-beauty-fcntl-fix-build-with-older-kernel-headers.patch new file mode 100644 index 0000000000..20e943b177 --- /dev/null +++ b/queue-6.18/perf-trace-beauty-fcntl-fix-build-with-older-kernel-headers.patch @@ -0,0 +1,60 @@ +From 7ee7f48413c42b90230de4a8e40898b757bc8e82 Mon Sep 17 00:00:00 2001 +From: Florian Fainelli +Date: Wed, 13 May 2026 12:23:46 -0700 +Subject: perf trace beauty fcntl: Fix build with older kernel headers + +From: Florian Fainelli + +commit 7ee7f48413c42b90230de4a8e40898b757bc8e82 upstream. + +Toolchains with older kernel headers that do not include upstream commit +c75b1d9421f80f41 ("fs: add fcntl() interface for setting/getting write +life time hints") will now fail to build perf due to missing definitions +for F_GET_RW_HINT/F_SET_RW_HINT/F_GET_FILE_RW_HINT/F_SET_FILE_RW_HINT. + +Provide a fallback definition for these when they are not already +defined. + +Fixes: 9c47f66748381ecb ("perf trace beauty fcntl: Basic 'arg' beautifier") +Reviewed-by: Ian Rogers +Signed-off-by: Florian Fainelli +Cc: Adrian Hunter +Cc: Alexander Shishkin +Cc: Ingo Molnar +Cc: James Clark +Cc: Jiri Olsa +Cc: Mark Rutland +Cc: Markus Mayer +Cc: Namhyung Kim +Cc: Peter Zijlstra +Signed-off-by: Arnaldo Carvalho de Melo +Signed-off-by: Greg Kroah-Hartman +--- + tools/perf/trace/beauty/fcntl.c | 16 ++++++++++++++++ + 1 file changed, 16 insertions(+) + +--- a/tools/perf/trace/beauty/fcntl.c ++++ b/tools/perf/trace/beauty/fcntl.c +@@ -9,6 +9,22 @@ + #include + #include + ++#ifndef F_GET_RW_HINT ++#define F_GET_RW_HINT (F_LINUX_SPECIFIC_BASE + 11) ++#endif ++ ++#ifndef F_SET_RW_HINT ++#define F_SET_RW_HINT (F_LINUX_SPECIFIC_BASE + 12) ++#endif ++ ++#ifndef F_GET_FILE_RW_HINT ++#define F_GET_FILE_RW_HINT (F_LINUX_SPECIFIC_BASE + 13) ++#endif ++ ++#ifndef F_SET_FILE_RW_HINT ++#define F_SET_FILE_RW_HINT (F_LINUX_SPECIFIC_BASE + 14) ++#endif ++ + static size_t fcntl__scnprintf_getfd(unsigned long val, char *bf, size_t size, bool show_prefix) + { + return val ? scnprintf(bf, size, "%s", "0") : diff --git a/queue-6.18/series b/queue-6.18/series index e4d9370daa..117c60e386 100644 --- a/queue-6.18/series +++ b/queue-6.18/series @@ -22,3 +22,8 @@ net-sched-dualpi2-fix-gso-backlog-accounting.patch nfsd-move-name-lookup-out-of-nfsd4_list_rec_dir.patch nfsd-change-nfs4_client_to_reclaim-to-allocate-data.patch mm-khugepaged-write-all-dirty-file-folios-when-colla.patch +slab-introduce-kmalloc_flex-and-family.patch +add-default_gfp-helper-macro-and-use-it-in-the-new-alloc_obj-helpers.patch +default_gfp-avoid-using-the-newfangled-__va_opt__-trick.patch +slab-recognize-gfp-parameter-as-optional-in-kernel-doc.patch +perf-trace-beauty-fcntl-fix-build-with-older-kernel-headers.patch diff --git a/queue-6.18/slab-introduce-kmalloc_flex-and-family.patch b/queue-6.18/slab-introduce-kmalloc_flex-and-family.patch new file mode 100644 index 0000000000..d15707dda8 --- /dev/null +++ b/queue-6.18/slab-introduce-kmalloc_flex-and-family.patch @@ -0,0 +1,170 @@ +From e4c8b46b924eb8de66c6f0accc9cdd0c2e8fa23b Mon Sep 17 00:00:00 2001 +From: Kees Cook +Date: Wed, 3 Dec 2025 15:30:34 -0800 +Subject: slab: Introduce kmalloc_flex() and family + +From: Kees Cook + +commit e4c8b46b924eb8de66c6f0accc9cdd0c2e8fa23b upstream. + +As done for kmalloc_obj*(), introduce a type-aware allocator for flexible +arrays, which may also have "counted_by" annotations: + + ptr = kmalloc(struct_size(ptr, flex_member, count), gfp); + +becomes: + + ptr = kmalloc_flex(*ptr, flex_member, count, gfp); + +The internal use of __flex_counter() allows for automatically setting +the counter member of a struct's flexible array member when it has +been annotated with __counted_by(), avoiding any missed early size +initializations while __counted_by() annotations are added to the +kernel. Additionally, this also checks for "too large" allocations based +on the type size of the counter variable. For example: + + if (count > type_max(ptr->flex_counter)) + fail...; + size = struct_size(ptr, flex_member, count); + ptr = kmalloc(size, gfp); + if (!ptr) + fail...; + ptr->flex_counter = count; + +becomes (n.b. unchanged from earlier example): + + ptr = kmalloc_flex(*ptr, flex_member, count, gfp); + if (!ptr) + fail...; + ptr->flex_counter = count; + +Note that manual initialization of the flexible array counter is still +required (at some point) after allocation as not all compiler versions +support the __counted_by annotation yet. But doing it internally makes +sure they cannot be missed when __counted_by _is_ available, meaning +that the bounds checker will not trip due to the lack of "early enough" +initializations that used to work before enabling the stricter bounds +checking. For example: + + ptr = kmalloc_flex(*ptr, flex_member, count, gfp); + fill(ptr->flex, count); + ptr->flex_count = count; + +This works correctly before adding a __counted_by annotation (since +nothing is checking ptr->flex accesses against ptr->flex_count). After +adding the annotation, the bounds sanitizer would trip during fill() +because ptr->flex_count wasn't set yet. But with kmalloc_flex() setting +ptr->flex_count internally at allocation time, the existing code works +without needing to move the ptr->flex_count assignment before the call +to fill(). (This has been a stumbling block for __counted_by adoption.) + +Link: https://patch.msgid.link/20251203233036.3212363-4-kees@kernel.org +Acked-by: Vlastimil Babka +Signed-off-by: Kees Cook +[Backport-notes: Removed the actual flex counter handling. That's a new + feature, which isn't necessary for just adding the new allocation APIs + to get backports to apply cleanly. Also, the allocation-time overflow + check in the upstream commit was reverted upstream.] +Signed-off-by: Eric Biggers +Signed-off-by: Greg Kroah-Hartman +--- + Documentation/process/deprecated.rst | 7 +++++ + include/linux/slab.h | 42 +++++++++++++++++++++++++++++++++++ + 2 files changed, 49 insertions(+) + +--- a/Documentation/process/deprecated.rst ++++ b/Documentation/process/deprecated.rst +@@ -387,6 +387,7 @@ allocations. For example, these open cod + ptr = kzalloc(sizeof(*ptr), gfp); + ptr = kmalloc_array(count, sizeof(*ptr), gfp); + ptr = kcalloc(count, sizeof(*ptr), gfp); ++ ptr = kmalloc(struct_size(ptr, flex_member, count), gfp); + ptr = kmalloc(sizeof(struct foo, gfp); + + become, respectively:: +@@ -395,4 +396,10 @@ become, respectively:: + ptr = kzalloc_obj(*ptr, gfp); + ptr = kmalloc_objs(*ptr, count, gfp); + ptr = kzalloc_objs(*ptr, count, gfp); ++ ptr = kmalloc_flex(*ptr, flex_member, count, gfp); + __auto_type ptr = kmalloc_obj(struct foo, gfp); ++ ++If `ptr->flex_member` is annotated with __counted_by(), the allocation ++will automatically fail if `count` is larger than the maximum ++representable value that can be stored in the counter member associated ++with `flex_member`. +--- a/include/linux/slab.h ++++ b/include/linux/slab.h +@@ -983,6 +983,27 @@ void *kmalloc_nolock_noprof(size_t size, + }) + + /** ++ * __alloc_flex - Allocate an object that has a trailing flexible array ++ * @KMALLOC: kmalloc wrapper function to use for allocation. ++ * @GFP: GFP flags for the allocation. ++ * @TYPE: type of structure to allocate space for. ++ * @FAM: The name of the flexible array member of @TYPE structure. ++ * @COUNT: how many @FAM elements to allocate space for. ++ * ++ * Returns: Newly allocated pointer to @TYPE with @COUNT-many trailing ++ * @FAM elements, or NULL on failure or if @COUNT cannot be represented ++ * by the member of @TYPE that counts the @FAM elements (annotated via ++ * __counted_by()). ++ */ ++#define __alloc_flex(KMALLOC, GFP, TYPE, FAM, COUNT) \ ++({ \ ++ const size_t __count = (COUNT); \ ++ const size_t __obj_size = struct_size_t(TYPE, FAM, __count); \ ++ TYPE *__obj_ptr = KMALLOC(__obj_size, GFP); \ ++ __obj_ptr; \ ++}) ++ ++/** + * kmalloc_obj - Allocate a single instance of the given type + * @VAR_OR_TYPE: Variable or type to allocate. + * @GFP: GFP flags for the allocation. +@@ -1005,23 +1026,44 @@ void *kmalloc_nolock_noprof(size_t size, + #define kmalloc_objs(VAR_OR_TYPE, COUNT, GFP) \ + __alloc_objs(kmalloc, GFP, typeof(VAR_OR_TYPE), COUNT) + ++/** ++ * kmalloc_flex - Allocate a single instance of the given flexible structure ++ * @VAR_OR_TYPE: Variable or type to allocate (with its flex array). ++ * @FAM: The name of the flexible array member of the structure. ++ * @COUNT: How many flexible array member elements are desired. ++ * @GFP: GFP flags for the allocation. ++ * ++ * Returns: newly allocated pointer to @VAR_OR_TYPE on success, NULL on ++ * failure. If @FAM has been annotated with __counted_by(), the allocation ++ * will immediately fail if @COUNT is larger than what the type of the ++ * struct's counter variable can represent. ++ */ ++#define kmalloc_flex(VAR_OR_TYPE, FAM, COUNT, GFP) \ ++ __alloc_flex(kmalloc, GFP, typeof(VAR_OR_TYPE), FAM, COUNT) ++ + /* All kzalloc aliases for kmalloc_(obj|objs|flex). */ + #define kzalloc_obj(P, GFP) \ + __alloc_objs(kzalloc, GFP, typeof(P), 1) + #define kzalloc_objs(P, COUNT, GFP) \ + __alloc_objs(kzalloc, GFP, typeof(P), COUNT) ++#define kzalloc_flex(P, FAM, COUNT, GFP) \ ++ __alloc_flex(kzalloc, GFP, typeof(P), FAM, COUNT) + + /* All kvmalloc aliases for kmalloc_(obj|objs|flex). */ + #define kvmalloc_obj(P, GFP) \ + __alloc_objs(kvmalloc, GFP, typeof(P), 1) + #define kvmalloc_objs(P, COUNT, GFP) \ + __alloc_objs(kvmalloc, GFP, typeof(P), COUNT) ++#define kvmalloc_flex(P, FAM, COUNT, GFP) \ ++ __alloc_flex(kvmalloc, GFP, typeof(P), FAM, COUNT) + + /* All kvzalloc aliases for kmalloc_(obj|objs|flex). */ + #define kvzalloc_obj(P, GFP) \ + __alloc_objs(kvzalloc, GFP, typeof(P), 1) + #define kvzalloc_objs(P, COUNT, GFP) \ + __alloc_objs(kvzalloc, GFP, typeof(P), COUNT) ++#define kvzalloc_flex(P, FAM, COUNT, GFP) \ ++ __alloc_flex(kvzalloc, GFP, typeof(P), FAM, COUNT) + + #define kmem_buckets_alloc(_b, _size, _flags) \ + alloc_hooks(__kmalloc_node_noprof(PASS_BUCKET_PARAMS(_size, _b), _flags, NUMA_NO_NODE)) diff --git a/queue-6.18/slab-recognize-gfp-parameter-as-optional-in-kernel-doc.patch b/queue-6.18/slab-recognize-gfp-parameter-as-optional-in-kernel-doc.patch new file mode 100644 index 0000000000..b01e007286 --- /dev/null +++ b/queue-6.18/slab-recognize-gfp-parameter-as-optional-in-kernel-doc.patch @@ -0,0 +1,57 @@ +From 7b5f5865fb11e60edd03c5e063e2d228b7062317 Mon Sep 17 00:00:00 2001 +From: Randy Dunlap +Date: Wed, 17 Jun 2026 09:31:25 -0700 +Subject: slab: recognize @GFP parameter as optional in kernel-doc + +From: Randy Dunlap + +commit 7b5f5865fb11e60edd03c5e063e2d228b7062317 upstream. + +Since the @GFP parameter in kmalloc_obj() etc. is now optional, change +the kernel-doc to indicate that it is optional. This avoids kernel-doc +warnings: + +WARNING: include/linux/slab.h:1101 Excess function parameter 'GFP' description in 'kmalloc_obj' +WARNING: include/linux/slab.h:1113 Excess function parameter 'GFP' description in 'kmalloc_objs' +WARNING: include/linux/slab.h:1128 Excess function parameter 'GFP' description in 'kmalloc_flex' + +Fixes: e19e1b480ac7 ("add default_gfp() helper macro and use it in the new *alloc_obj() helpers") +Signed-off-by: Randy Dunlap +Acked-by: Harry Yoo (Oracle) +Link: https://patch.msgid.link/20260617163125.2716279-1-rdunlap@infradead.org +Signed-off-by: Vlastimil Babka (SUSE) +Signed-off-by: Eric Biggers +Signed-off-by: Greg Kroah-Hartman +--- + include/linux/slab.h | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +--- a/include/linux/slab.h ++++ b/include/linux/slab.h +@@ -1006,7 +1006,7 @@ void *kmalloc_nolock_noprof(size_t size, + /** + * kmalloc_obj - Allocate a single instance of the given type + * @VAR_OR_TYPE: Variable or type to allocate. +- * @GFP: GFP flags for the allocation. ++ * @...: optional GFP flags for the allocation (GFP_KERNEL when not specified). + * + * Returns: newly allocated pointer to a @VAR_OR_TYPE on success, or NULL + * on failure. +@@ -1018,7 +1018,7 @@ void *kmalloc_nolock_noprof(size_t size, + * kmalloc_objs - Allocate an array of the given type + * @VAR_OR_TYPE: Variable or type to allocate an array of. + * @COUNT: How many elements in the array. +- * @GFP: GFP flags for the allocation. ++ * @...: optional GFP flags for the allocation (GFP_KERNEL when not specified). + * + * Returns: newly allocated pointer to array of @VAR_OR_TYPE on success, + * or NULL on failure. +@@ -1031,7 +1031,7 @@ void *kmalloc_nolock_noprof(size_t size, + * @VAR_OR_TYPE: Variable or type to allocate (with its flex array). + * @FAM: The name of the flexible array member of the structure. + * @COUNT: How many flexible array member elements are desired. +- * @GFP: GFP flags for the allocation. ++ * @...: optional GFP flags for the allocation (GFP_KERNEL when not specified). + * + * Returns: newly allocated pointer to @VAR_OR_TYPE on success, NULL on + * failure. If @FAM has been annotated with __counted_by(), the allocation