Skip to contentSkip to conversation

overflow.h: Add flex_array_size() helper

PATCH In review Gustavo A. R. Silva 4 participants 6 messages Jun 9, 2020 – Jun 17, 2020 Kernel hardening (not covered by other areas)

lore
Share & tools
lore

Gustavo A. R. Silva

author reviewer
#0 lore raw

PATCH 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
index 659045046468f..d2329a914304c 100644
@@ -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
#1 lore raw
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 or SIZE_MAX on 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 */
#2 lore raw
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 elements

IMO: "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
Acked-by on v2 1/1
#3 lore raw
In reply to Gustavo A. R. Silva
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_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 +1 -2
index 659045046468f..d2329a914304c 100644
@@ -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
#4 lore raw
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() (like sizeof_field(), etc), and that does seem attractive. As you also mentioned, it begs the question of renaming struct_size() to sizeof_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

(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

#5 lore raw
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() (like sizeof_field(), etc), and that does seem attractive. As you also mentioned, it begs the question of renaming struct_size() to sizeof_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

(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