--- /dev/null
+From e19e1b480ac73c3e62ffebbca1174f0f511f43e7 Mon Sep 17 00:00:00 2001
+From: Linus Torvalds <torvalds@linux-foundation.org>
+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 <torvalds@linux-foundation.org>
+
+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 <torvalds@linux-foundation.org>
+Signed-off-by: Eric Biggers <ebiggers@kernel.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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))
--- /dev/null
+From 551d44200152cb26f75d2ef990aeb6185b7e37fd Mon Sep 17 00:00:00 2001
+From: Linus Torvalds <torvalds@linux-foundation.org>
+Date: Mon, 23 Feb 2026 09:33:08 -0800
+Subject: default_gfp(): avoid using the "newfangled" __VA_OPT__ trick
+
+From: Linus Torvalds <torvalds@linux-foundation.org>
+
+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 <ribalda@chromium.org>
+Reported-and-tested-by: Richard Fitzgerald <rf@opensource.cirrus.com>
+Reported-by: Ben Dooks <ben.dooks@codethink.co.uk>
+Fixes: e19e1b480ac7 ("add default_gfp() helper macro and use it in the new *alloc_obj() helpers")
+Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
+Signed-off-by: Eric Biggers <ebiggers@kernel.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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)
--- /dev/null
+From 7ee7f48413c42b90230de4a8e40898b757bc8e82 Mon Sep 17 00:00:00 2001
+From: Florian Fainelli <florian.fainelli@broadcom.com>
+Date: Wed, 13 May 2026 12:23:46 -0700
+Subject: perf trace beauty fcntl: Fix build with older kernel headers
+
+From: Florian Fainelli <florian.fainelli@broadcom.com>
+
+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 <irogers@google.com>
+Signed-off-by: Florian Fainelli <florian.fainelli@broadcom.com>
+Cc: Adrian Hunter <adrian.hunter@intel.com>
+Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
+Cc: Ingo Molnar <mingo@redhat.com>
+Cc: James Clark <james.clark@linaro.org>
+Cc: Jiri Olsa <jolsa@kernel.org>
+Cc: Mark Rutland <mark.rutland@arm.com>
+Cc: Markus Mayer <mmayer@broadcom.com>
+Cc: Namhyung Kim <namhyung@kernel.org>
+Cc: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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 <linux/kernel.h>
+ #include <linux/fcntl.h>
+
++#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") :
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
--- /dev/null
+From e4c8b46b924eb8de66c6f0accc9cdd0c2e8fa23b Mon Sep 17 00:00:00 2001
+From: Kees Cook <kees@kernel.org>
+Date: Wed, 3 Dec 2025 15:30:34 -0800
+Subject: slab: Introduce kmalloc_flex() and family
+
+From: Kees Cook <kees@kernel.org>
+
+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 <vbabka@suse.cz>
+Signed-off-by: Kees Cook <kees@kernel.org>
+[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 <ebiggers@kernel.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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))
--- /dev/null
+From 7b5f5865fb11e60edd03c5e063e2d228b7062317 Mon Sep 17 00:00:00 2001
+From: Randy Dunlap <rdunlap@infradead.org>
+Date: Wed, 17 Jun 2026 09:31:25 -0700
+Subject: slab: recognize @GFP parameter as optional in kernel-doc
+
+From: Randy Dunlap <rdunlap@infradead.org>
+
+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 <rdunlap@infradead.org>
+Acked-by: Harry Yoo (Oracle) <harry@kernel.org>
+Link: https://patch.msgid.link/20260617163125.2716279-1-rdunlap@infradead.org
+Signed-off-by: Vlastimil Babka (SUSE) <vbabka@kernel.org>
+Signed-off-by: Eric Biggers <ebiggers@kernel.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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
projects / thirdparty / kernel / stable-queue.git / commitdiff
