overflow.h: Add flex_array_size() helper
Gustavo A. R. Silva
reviewerPATCH v2 1/1 overflow.h: Add flex_array_size() helper
Add flex_array_size() helper for the calculation of the size, in bytes, of a flexible array member contained within an enclosing structure.
Example of usage:
struct something {
size_t count;
struct foo items[];
};struct something *instance;
instance = kmalloc(struct_size(instance, items, count), GFP_KERNEL); instance->count = count;
memcpy(instance->items, source, flex_array_size(instance, items, instance->count));
The helper returns SIZE_MAX on overflow instead of wrapping around.
(Additionally replace parameter n with count in struct_size() for unification).
---
Changes in v2:
- Add further information to the helper documentation.
- Use same code style as struct_size() for consistency.
include/linux/overflow.h | 25 +++++++++++++++++++++---- 1 file changed, 21 insertions(+), 4 deletions(-)
include/linux/overflow.h +21 -4
@@ -304,16 +304,33 @@ static inline __must_check size_t __ab_c_size(size_t a, size_t b, size_t c)* struct_size() - Calculate size of structure with trailing array. * @p: Pointer to the structure. * @member: Name of the array member. -* @n: Number of elements in the array. +* @count: Number of elements in the array. * * Calculates size of memory needed for structure @p followed by an -* array of @n @member elements. +* array of @count @member elements. * * Return: number of bytes needed or SIZE_MAX on overflow. */ -#define struct_size (p, member, n) \ - __ab_c_size(n, \ +#define struct_size (p, member, count) \ + __ab_c_size(count, \ sizeof(*(p)->member) + __must_be_array((p)->member),\ sizeof(*(p))) +/** +* flex_array_size() - Calculate size, in bytes, of a flexible array member +* within an enclosing structure. Read on for more details. +* +* @p: Pointer to the structure. +* @member: Name of the flexible array member. +* @count: Number of elements in the array. +* +* Calculates size, in bytes, of a flexible array @member of @count elements +* within structure @p. +* +* Return: number of bytes needed or SIZE_MAX on overflow. +*/ +#define flex_array_size (p, member, count) \ + array_size(count, \ + sizeof(*(p)->member) + __must_be_array((p)->member)) +#endif /* __LINUX_OVERFLOW_H */
Signature · 1 line
2.27.0
Quoted 2 lines · Gustavo A. R. Silva
Add
flex_array_size()helper for the calculation of the size, in bytes, of a flexible array member contained within an enclosing structure.
[]
include/linux/overflow.h
Quoted 1 line
include/linux/overflow.h +0
-0
[]
Quoted 3 lines
+/**
+ *flex_array_size()- Calculate size, in bytes, of a flexible array member
+ * within an enclosing structure. Read on for more details.
IMO: "Read on for more details" isn't useful here. Perhaps better would be something like:
* flex_array_size() - size of a flexible array (sizeof(typeof(member)) * count)
Quoted 6 lines
+ *
+ * @p: Pointer to the structure.
+ * @member: Name of the flexible array member.
+ * @count: Number of elements in the array.
+ *
+ * Calculates size, in bytes, of a flexible array @member of @count elements
IMO: "in bytes, " is redundant. size is always bytes.
Quoted 9 lines
+ * within structure @p.
+ *
+ * Return: number of bytes needed orSIZE_MAXon overflow.
+ */include/linux/overflow.h +4
-0+#define flex_array_size (p, member, count) \ + array_size(count, \ + sizeof(*(p)->member) + __must_be_array((p)->member)) +#endif /* __LINUX_OVERFLOW_H */
Quoted 15 lines · Joe Perches
Quoted 2 lines · Gustavo A. R. Silva
Add
flex_array_size()helper for the calculation of the size, in bytes, of a flexible array member contained within an enclosing structure.[]
include/linux/overflow.h
Quoted 1 line
include/linux/overflow.h +0
-0[]
Quoted 3 lines
+/**
+ *flex_array_size()- Calculate size, in bytes, of a flexible array member
+ * within an enclosing structure. Read on for more details.IMO: "Read on for more details" isn't useful here. Perhaps better would be something like:
*
flex_array_size()- size of a flexible array (sizeof(typeof(member)) * count)
Quoted 8 lines
Quoted 6 lines
+ *
+ * @p: Pointer to the structure.
+ * @member: Name of the flexible array member.
+ * @count: Number of elements in the array.
+ *
+ * Calculates size, in bytes, of a flexible array @member of @count elementsIMO: "in bytes, " is redundant. size is always bytes.
While yes, that's the expected unit, I don't mind the clarification given that we want to be distinct from "count" and the size of an individual array element.
Signature · 1 line
Kees Cook
Quoted 44 lines · Gustavo A. R. Silva
Add
flex_array_size()helper for the calculation of the size, in bytes, of a flexible array member contained within an enclosing structure.Example of usage:
struct something { size_t count; struct foo items[]; };struct something *instance;
instance =
kmalloc(struct_size(instance, items, count), GFP_KERNEL);instance->count= count;
memcpy(instance->items, source, flex_array_size(instance, items, instance->count));The helper returns
SIZE_MAXon overflow instead of wrapping around.(Additionally replace parameter n with count in
struct_size()for unification).Signed-off-by Gustavo A. R. Silva <[email protected]>---
Changes in v2:
- Add further information to the helper documentation.
- Use same code style asstruct_size()for consistency.include/linux/overflow.h | 25 +++++++++++++++++++++---- 1 file changed, 21 insertions(+), 4 deletions(-)include/linux/overflow.h +1
-2@@ -304,16 +304,33 @@ static inline __must_check size_t __ab_c_size(size_t a, size_t b, size_t c)* struct_size() - Calculate size of structure with trailing array. * @p: Pointer to the structure. * @member: Name of the array member. -* @n: Number of elements in the array. +* @count: Number of elements in the array. * * Calculates size of memory needed for structure @p followed by an -* array of @n @member elements.
include/linux/overflow.h static inline __must_check size_t __ab_c_size(size_t a, size_t b, size_t c) · line 317
Quoted 10 lines
include/linux/overflow.h +3
-2+* array of @count @member elements. * * Return: number of bytes needed or SIZE_MAX on overflow. */ -#define struct_size (p, member, n) \ - __ab_c_size(n, \ +#define struct_size (p, member, count) \ + __ab_c_size(count, \ sizeof(*(p)->member) + __must_be_array((p)->member),\ sizeof(*(p)))
I like the "count" change -- "n" can be seen as either count or bytes, so I like this being distinctly "count".
Quoted 9 lines
include/linux/overflow.h +8
-0+/** +* flex_array_size() - Calculate size, in bytes, of a flexible array member +* within an enclosing structure. Read on for more details. +* +* @p: Pointer to the structure. +* @member: Name of the flexible array member. +* @count: Number of elements in the array. +*
include/linux/overflow.h static inline __must_check size_t __ab_c_size(size_t a, size_t b, size_t c) · line 336
Quoted 10 lines
include/linux/overflow.h +9
-0+* Calculates size, in bytes, of a flexible array @member of @count elements +* within structure @p. +* +* Return: number of bytes needed or SIZE_MAX on overflow. +*/ +#define flex_array_size (p, member, count) \ + array_size(count, \ + sizeof(*(p)->member) + __must_be_array((p)->member)) +#endif /* __LINUX_OVERFLOW_H */
I like it! You mentioned off-list that maybe this could be named sizeof_flex_array() (like sizeof_field(), etc), and that does seem attractive. As you also mentioned, it begs the question of renaming struct_size() to sizeof_struct().
Looking back through the thread[1], it seems the name came from Linus[2], and was more related to the existing array_size() helper.
So, how about this, as a convention we can use to make a choice:
For things that are strictly constant in size, we can use sizeof_*. For things that have a dynamic component, we'll use *_size(). So, this patch is correct as-is.
(I wonder who's tree this should go via?)
-Kees
[1] https://lore.kernel.org/lkml/[email protected]/
[2] https://lore.kernel.org/lkml/CA+55aFy8DSRoUvtiuu5w+XGOK6tYvtJGBH-i8i-y7aiUD2EGLA@mail.gmail.com/
Signature · 1 line
Kees Cook
Quoted 10 lines · Kees Cook
include/linux/overflow.h static inline __must_check size_t __ab_c_size(size_t a, size_t b, size_t c) · line 317
Quoted 6 lines
include/linux/overflow.h +2
-2-#define struct_size (p, member, n) \ - __ab_c_size(n, \ +#define struct_size (p, member, count) \ + __ab_c_size(count, \ sizeof(*(p)->member) + __must_be_array((p)->member),\ sizeof(*(p)))I like the "count" change -- "n" can be seen as either count or bytes, so I like this being distinctly "count".
Yep. :)
Quoted 25 lines
Quoted 9 lines
include/linux/overflow.h +8
-0+/** +* flex_array_size() - Calculate size, in bytes, of a flexible array member +* within an enclosing structure. Read on for more details. +* +* @p: Pointer to the structure. +* @member: Name of the flexible array member. +* @count: Number of elements in the array. +* include/linux/overflow.h static inline __must_check size_t __ab_c_size(size_t a, size_t b, size_t c) · line 336
Quoted 10 lines
include/linux/overflow.h +9
-0+* Calculates size, in bytes, of a flexible array @member of @count elements +* within structure @p. +* +* Return: number of bytes needed or SIZE_MAX on overflow. +*/ +#define flex_array_size (p, member, count) \ + array_size(count, \ + sizeof(*(p)->member) + __must_be_array((p)->member)) +#endif /* __LINUX_OVERFLOW_H */ I like it! You mentioned off-list that maybe this could be named
sizeof_flex_array()(likesizeof_field(), etc), and that does seem attractive. As you also mentioned, it begs the question of renamingstruct_size()tosizeof_struct().
Quoted 9 lines
Looking back through the thread[1], it seems the name came from Linus[2], and was more related to the existing
array_size()helper.So, how about this, as a convention we can use to make a choice:
For things that are strictly constant in size, we can use sizeof_*. For things that have a dynamic component, we'll use
*_size(). So, this patch is correct as-is.
I like the idea. I haven't thought it in terms of dynamic and constant size, but it sounds sensible.
Quoted 4 lines
Acked-by Kees Cook <[email protected]>(I wonder who's tree this should go via?)
Yours? :)
Quoted 5 lines
-Kees
[1] https://lore.kernel.org/lkml/[email protected]/
[2] https://lore.kernel.org/lkml/CA+55aFy8DSRoUvtiuu5w+XGOK6tYvtJGBH-i8i-y7aiUD2EGLA@mail.gmail.com/
--
Gustavo
Quoted 55 lines · Gustavo A. R. Silva
Quoted 10 lines · Kees Cook
include/linux/overflow.h static inline __must_check size_t __ab_c_size(size_t a, size_t b, size_t c) · line 317
Quoted 6 lines
include/linux/overflow.h +2
-2-#define struct_size (p, member, n) \ - __ab_c_size(n, \ +#define struct_size (p, member, count) \ + __ab_c_size(count, \ sizeof(*(p)->member) + __must_be_array((p)->member),\ sizeof(*(p)))I like the "count" change -- "n" can be seen as either count or bytes, so I like this being distinctly "count".
Yep. :)
Quoted 25 lines
Quoted 9 lines
include/linux/overflow.h +8
-0+/** +* flex_array_size() - Calculate size, in bytes, of a flexible array member +* within an enclosing structure. Read on for more details. +* +* @p: Pointer to the structure. +* @member: Name of the flexible array member. +* @count: Number of elements in the array. +* include/linux/overflow.h static inline __must_check size_t __ab_c_size(size_t a, size_t b, size_t c) · line 336
Quoted 10 lines
include/linux/overflow.h +9
-0+* Calculates size, in bytes, of a flexible array @member of @count elements +* within structure @p. +* +* Return: number of bytes needed or SIZE_MAX on overflow. +*/ +#define flex_array_size (p, member, count) \ + array_size(count, \ + sizeof(*(p)->member) + __must_be_array((p)->member)) +#endif /* __LINUX_OVERFLOW_H */ I like it! You mentioned off-list that maybe this could be named
sizeof_flex_array()(likesizeof_field(), etc), and that does seem attractive. As you also mentioned, it begs the question of renamingstruct_size()tosizeof_struct().Quoted 9 lines
Looking back through the thread[1], it seems the name came from Linus[2], and was more related to the existing
array_size()helper.So, how about this, as a convention we can use to make a choice:
For things that are strictly constant in size, we can use sizeof_*. For things that have a dynamic component, we'll use
*_size(). So, this patch is correct as-is.I like the idea. I haven't thought it in terms of dynamic and constant size, but it sounds sensible.
Quoted 6 lines
Quoted 4 lines
Acked-by Kees Cook <[email protected]>(I wonder who's tree this should go via?)
Yours? :)
Done; I'll see if Linus will take this for -rc2 so you'll be able to use it for v5.9 patches...
Thanks!
Signature · 1 line
Kees Cook