Skip to contentSkip to conversation

overflow: Introduce wrapping helpers

PATCH Superseded Kees Cook 6 participants 14 messages Feb 5, 2024 – Feb 6, 2024

Subsystems (2)

v3 of 7 Superseded Latest is v7 →

lore
Share & tools
lore

Kees Cook

author
#0 lore raw

v3 cover overflow: Introduce wrapping helpers

Hi,

v3:
- reduce patches to just docs and new helpers; we don't need pointer fixes yet.
v2: https://lore.kernel.org/all/[email protected]/
v1: https://lore.kernel.org/lkml/[email protected]/

In preparation for gaining instrumentation for signed[1], unsigned[2], and pointer[3] wrap-around, expand the overflow header to include wrap-around helpers that can be used to annotate arithmetic where wrapped calculations are expected (e.g. atomics).

After spending time getting the unsigned integer wrap-around sanitizer running warning-free on a basic x86_64 boot[4], I think the *_wrap() helpers first argument being the output type makes the most sense (as suggested by Rasmus).

-Kees

Kees Cook (3):
overflow: Adjust check_*_overflow() kern-doc to reflect results
overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()
overflow: Introduce inc_wrap() and dec_wrap()

 include/linux/overflow.h | 100 ++++++++++++++++++++++++++++++++++-----
 lib/overflow_kunit.c     |  65 +++++++++++++++++++++++--
 2 files changed, 149 insertions(+), 16 deletions(-)
Signature · 1 line
2.34.1
author
#1 lore raw

PATCH v3 1/3 overflow: Adjust check_*_overflow() kern-doc to reflect results

The check_*_overflow() helpers will return results with potentially wrapped-around values. These values have always been checked by the selftests, so avoid the confusing language in the kern-doc. The idea of "safe for use" was relative to the expectation of whether or not the caller wants a wrapped value -- the calculation itself will always follow arithmetic wrapping rules.

Cc "Gustavo A. R. Silva" <[email protected]>
---
 include/linux/overflow.h | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)
include/linux/overflow.h +6 -12
index 7b5cf4a5cd19..4e741ebb8005 100644
@@ -57,11 +57,9 @@ static inline bool __must_check __must_check_overflow(bool overflow)
  * @b: second addend
  * @d: pointer to store sum
  *
- * Returns 0 on success.
+ * Returns 0 on success, 1 on wrap-around.
  *
- * *@d holds the results of the attempted addition, but is not considered
- * "safe for use" on a non-zero return value, which indicates that the
- * sum has overflowed or been truncated.
+ * *@d holds the results of the attempted addition, which may wrap-around.
  */
 #define check_add_overflow(a, b, d)	\
 	__must_check_overflow(__builtin_add_overflow(a, b, d))
@@ -72,11 +70,9 @@ static inline bool __must_check __must_check_overflow(bool overflow)
  * @b: subtrahend; value to subtract from @a
  * @d: pointer to store difference
  *
- * Returns 0 on success.
+ * Returns 0 on success, 1 on wrap-around.
  *
- * *@d holds the results of the attempted subtraction, but is not considered
- * "safe for use" on a non-zero return value, which indicates that the
- * difference has underflowed or been truncated.
+ * *@d holds the results of the attempted subtraction, which may wrap-around.
  */
 #define check_sub_overflow(a, b, d)	\
 	__must_check_overflow(__builtin_sub_overflow(a, b, d))
@@ -87,11 +83,9 @@ static inline bool __must_check __must_check_overflow(bool overflow)
  * @b: second factor
  * @d: pointer to store product
  *
- * Returns 0 on success.
+ * Returns 0 on success, 1 on wrap-around.
  *
- * *@d holds the results of the attempted multiplication, but is not
- * considered "safe for use" on a non-zero return value, which indicates
- * that the product has overflowed or been truncated.
+ * *@d holds the results of the attempted multiplication, which may wrap-around.
  */
 #define check_mul_overflow(a, b, d)	\
 	__must_check_overflow(__builtin_mul_overflow(a, b, d))
Signature · 1 line
2.34.1
Reviewed-by on v3 1/3
#2 lore raw

Re: [PATCH v3 1/3] overflow: Adjust check_*_overflow() kern-doc to reflect results

Quoted 10 lines · Kees Cook

The check_*_overflow() helpers will return results with potentially wrapped-around values. These values have always been checked by the selftests, so avoid the confusing language in the kern-doc. The idea of "safe for use" was relative to the expectation of whether or not the caller wants a wrapped value -- the calculation itself will always follow arithmetic wrapping rules.

Cc "Gustavo A. R. Silva" <[email protected]>

Better to be concise and direct. :)

Thanks!

Signature · 1 line
Gustavo
Quoted 50 lines
---
  include/linux/overflow.h | 18 ++++++------------
  1 file changed, 6 insertions(+), 12 deletions(-)
include/linux/overflow.h +6 -12
index 7b5cf4a5cd19..4e741ebb8005 100644
@@ -57,11 +57,9 @@ static inline bool __must_check __must_check_overflow(bool overflow)
   * @b: second addend
   * @d: pointer to store sum
   *
- * Returns 0 on success.
+ * Returns 0 on success, 1 on wrap-around.
   *
- * *@d holds the results of the attempted addition, but is not considered
- * "safe for use" on a non-zero return value, which indicates that the
- * sum has overflowed or been truncated.
+ * *@d holds the results of the attempted addition, which may wrap-around.
   */
  #define check_add_overflow(a, b, d)	\
  	__must_check_overflow(__builtin_add_overflow(a, b, d))
@@ -72,11 +70,9 @@ static inline bool __must_check __must_check_overflow(bool overflow)
   * @b: subtrahend; value to subtract from @a
   * @d: pointer to store difference
   *
- * Returns 0 on success.
+ * Returns 0 on success, 1 on wrap-around.
   *
- * *@d holds the results of the attempted subtraction, but is not considered
- * "safe for use" on a non-zero return value, which indicates that the
- * difference has underflowed or been truncated.
+ * *@d holds the results of the attempted subtraction, which may wrap-around.
   */
  #define check_sub_overflow(a, b, d)	\
  	__must_check_overflow(__builtin_sub_overflow(a, b, d))
@@ -87,11 +83,9 @@ static inline bool __must_check __must_check_overflow(bool overflow)
   * @b: second factor
   * @d: pointer to store product
   *
- * Returns 0 on success.
+ * Returns 0 on success, 1 on wrap-around.
   *
- * *@d holds the results of the attempted multiplication, but is not
- * considered "safe for use" on a non-zero return value, which indicates
- * that the product has overflowed or been truncated.
+ * *@d holds the results of the attempted multiplication, which may wrap-around.
   */
  #define check_mul_overflow(a, b, d)	\
  	__must_check_overflow(__builtin_mul_overflow(a, b, d))
author
#3 lore raw

PATCH v3 2/3 overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()

In reply to Kees Cook

Provide helpers that will perform wrapping addition, subtraction, or multiplication without tripping the arithmetic wrap-around sanitizers. The first argument is the type under which the wrap-around should happen with. In other words, these two calls will get very different results:

	mul_wrap(int, 50, 50) == 2500
	mul_wrap(u8,  50, 50) ==  196

Add to the selftests to validate behavior and lack of side-effects.

Cc Rasmus Villemoes <[email protected]>
Cc Mark Rutland <[email protected]>
---
 include/linux/overflow.h | 54 ++++++++++++++++++++++++++++++++++++++++
 lib/overflow_kunit.c     | 23 ++++++++++++++---
 2 files changed, 73 insertions(+), 4 deletions(-)
include/linux/overflow.h +54 -0
index 4e741ebb8005..9b8c05bdb788 100644
@@ -64,6 +64,24 @@ static inline bool __must_check __must_check_overflow(bool overflow)
 #define check_add_overflow(a, b, d)	\
 	__must_check_overflow(__builtin_add_overflow(a, b, d))
 
+/**
+ * add_wrap() - Intentionally perform a wrapping addition
+ * @type: type for result of calculation
+ * @a: first addend
+ * @b: second addend
+ *
+ * Return the potentially wrapped-around addition without
+ * tripping any wrap-around sanitizers that may be enabled.
+ */
+#define add_wrap(type, a, b)				\
+	({						\
+		type __val;				\
+		if (check_add_overflow(a, b, &__val)) {	\
+			/* do nothing */		\
+		}					\
+		__val;					\
+	})
+
 /**
  * check_sub_overflow() - Calculate subtraction with overflow checking
  * @a: minuend; value to subtract from
@@ -77,6 +95,24 @@ static inline bool __must_check __must_check_overflow(bool overflow)
 #define check_sub_overflow(a, b, d)	\
 	__must_check_overflow(__builtin_sub_overflow(a, b, d))
 
+/**
+ * sub_wrap() - Intentionally perform a wrapping subtraction
+ * @type: type for result of calculation
+ * @a: minuend; value to subtract from
+ * @b: subtrahend; value to subtract from @a
+ *
+ * Return the potentially wrapped-around subtraction without
+ * tripping any wrap-around sanitizers that may be enabled.
+ */
+#define sub_wrap(type, a, b)				\
+	({						\
+		type __val;				\
+		if (check_sub_overflow(a, b, &__val)) {	\
+			/* do nothing */		\
+		}					\
+		__val;					\
+	})
+
 /**
  * check_mul_overflow() - Calculate multiplication with overflow checking
  * @a: first factor
@@ -90,6 +126,24 @@ static inline bool __must_check __must_check_overflow(bool overflow)
 #define check_mul_overflow(a, b, d)	\
 	__must_check_overflow(__builtin_mul_overflow(a, b, d))
 
+/**
+ * mul_wrap() - Intentionally perform a wrapping multiplication
+ * @type: type for result of calculation
+ * @a: first factor
+ * @b: second factor
+ *
+ * Return the potentially wrapped-around multiplication without
+ * tripping any wrap-around sanitizers that may be enabled.
+ */
+#define mul_wrap(type, a, b)				\
+	({						\
+		type __val;				\
+		if (check_mul_overflow(a, b, &__val)) {	\
+			/* do nothing */		\
+		}					\
+		__val;					\
+	})
+
 /**
  * check_shl_overflow() - Calculate a left-shifted value and check overflow
  * @a: Value to be shifted
lib/overflow_kunit.c +19 -4
index c527f6b75789..064dccd973ad 100644
@@ -258,15 +258,30 @@ DEFINE_TEST_ARRAY(s64) = {
 									\
 	_of = check_ ## op ## _overflow(a, b, &_r);			\
 	KUNIT_EXPECT_EQ_MSG(test, _of, of,				\
-		"expected "fmt" "sym" "fmt" to%s overflow (type %s)\n",	\
+		"expected check "fmt" "sym" "fmt" to%s overflow (type %s)\n",	\
 		a, b, of ? "" : " not", #t);				\
 	KUNIT_EXPECT_EQ_MSG(test, _r, r,				\
-		"expected "fmt" "sym" "fmt" == "fmt", got "fmt" (type %s)\n", \
+		"expected check "fmt" "sym" "fmt" == "fmt", got "fmt" (type %s)\n", \
 		a, b, r, _r, #t);					\
 	/* Check for internal macro side-effects. */			\
 	_of = check_ ## op ## _overflow(_a_orig++, _b_orig++, &_r);	\
-	KUNIT_EXPECT_EQ_MSG(test, _a_orig, _a_bump, "Unexpected " #op " macro side-effect!\n"); \
-	KUNIT_EXPECT_EQ_MSG(test, _b_orig, _b_bump, "Unexpected " #op " macro side-effect!\n"); \
+	KUNIT_EXPECT_EQ_MSG(test, _a_orig, _a_bump,			\
+		"Unexpected check " #op " macro side-effect!\n");	\
+	KUNIT_EXPECT_EQ_MSG(test, _b_orig, _b_bump,			\
+		"Unexpected check " #op " macro side-effect!\n");	\
+									\
+	_r = op ## _wrap(t, a, b);					\
+	KUNIT_EXPECT_TRUE_MSG(test, _r == r,				\
+		"expected wrap "fmt" "sym" "fmt" == "fmt", got "fmt" (type %s)\n", \
+		a, b, r, _r, #t);					\
+	/* Check for internal macro side-effects. */			\
+	_a_orig = a;							\
+	_b_orig = b;							\
+	_r = op ## _wrap(t, _a_orig++, _b_orig++);			\
+	KUNIT_EXPECT_EQ_MSG(test, _a_orig, _a_bump,			\
+		"Unexpected wrap " #op " macro side-effect!\n");	\
+	KUNIT_EXPECT_EQ_MSG(test, _b_orig, _b_bump,			\
+		"Unexpected wrap " #op " macro side-effect!\n");	\
 } while (0)
 
 #define DEFINE_TEST_FUNC_TYPED(n, t, fmt)				\
Signature · 1 line
2.34.1
#4 lore raw

Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()

Quoted 32 lines · Kees Cook

Provide helpers that will perform wrapping addition, subtraction, or multiplication without tripping the arithmetic wrap-around sanitizers. The first argument is the type under which the wrap-around should happen with. In other words, these two calls will get very different results:

        mul_wrap(int, 50, 50) == 2500
        mul_wrap(u8,  50, 50) ==  196

Add to the selftests to validate behavior and lack of side-effects.

Cc Rasmus Villemoes <[email protected]>
Cc Mark Rutland <[email protected]>
---
 include/linux/overflow.h | 54 ++++++++++++++++++++++++++++++++++++++++
 lib/overflow_kunit.c     | 23 ++++++++++++++---
 2 files changed, 73 insertions(+), 4 deletions(-)
include/linux/overflow.h +4 -0
index 4e741ebb8005..9b8c05bdb788 100644
@@ -64,6 +64,24 @@ static inline bool __must_check __must_check_overflow(bool overflow)
 #define check_add_overflow(a, b, d)    \
        __must_check_overflow(__builtin_add_overflow(a, b, d))
 
+/**
+ * add_wrap() - Intentionally perform a wrapping addition
+ * @type: type for result of calculation
+ * @a: first addend

include/linux/overflow.h static inline bool __must_check __must_check_overflow(bool overflow) · line 80

Quoted 10 lines
include/linux/overflow.h +10 -0
+ * @b: second addend
+ *
+ * Return the potentially wrapped-around addition without
+ * tripping any wrap-around sanitizers that may be enabled.
+ */
+#define add_wrap(type, a, b)                           \
+       ({                                              \
+               type __val;                             \
+               if (check_add_overflow(a, b, &__val)) { \
+                       /* do nothing */                \

The whole reason check_*_overflow() exists is to wrap the builtin in a function with __must_check. Here the result is explicitly ignored, so do we have to go through the check_add_overflow indirection? Why not just use the builtin directly? It might make sense to make the compiler's job a little easier, because I predict that __must_check_overflow will be outlined with enough instrumentation (maybe it should have been __always_inline).

#5 lore raw

Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()

Quoted 44 lines · Marco Elver
Quoted 32 lines · Kees Cook

Provide helpers that will perform wrapping addition, subtraction, or multiplication without tripping the arithmetic wrap-around sanitizers. The first argument is the type under which the wrap-around should happen with. In other words, these two calls will get very different results:

         mul_wrap(int, 50, 50) == 2500
         mul_wrap(u8,  50, 50) ==  196

Add to the selftests to validate behavior and lack of side-effects.

Cc Rasmus Villemoes <[email protected]>
Cc Mark Rutland <[email protected]>
---
  include/linux/overflow.h | 54 ++++++++++++++++++++++++++++++++++++++++
  lib/overflow_kunit.c     | 23 ++++++++++++++---
  2 files changed, 73 insertions(+), 4 deletions(-)
include/linux/overflow.h +4 -0
index 4e741ebb8005..9b8c05bdb788 100644
@@ -64,6 +64,24 @@ static inline bool __must_check __must_check_overflow(bool overflow)
  #define check_add_overflow(a, b, d)    \
         __must_check_overflow(__builtin_add_overflow(a, b, d))
 
+/**
+ * add_wrap() - Intentionally perform a wrapping addition
+ * @type: type for result of calculation
+ * @a: first addend

include/linux/overflow.h static inline bool __must_check __must_check_overflow(bool overflow) · line 80

Quoted 10 lines
include/linux/overflow.h +10 -0
+ * @b: second addend
+ *
+ * Return the potentially wrapped-around addition without
+ * tripping any wrap-around sanitizers that may be enabled.
+ */
+#define add_wrap(type, a, b)                           \
+       ({                                              \
+               type __val;                             \
+               if (check_add_overflow(a, b, &__val)) { \
+                       /* do nothing */                \
Quoted 7 lines

The whole reason check_*_overflow() exists is to wrap the builtin in a function with __must_check. Here the result is explicitly ignored, so do we have to go through the check_add_overflow indirection? Why not just use the builtin directly? It might make sense to make the compiler's job a little easier, because I predict that __must_check_overflow will be outlined with enough instrumentation (maybe it should have been __always_inline).

Yeah; I think that directly calling __builtin_*_overflow() is a bit cleaner.

I wonder if there is any particular reason for not doing that.

In any case, this version of the add_wrap() helper with the type as parameter looks much better than the v1 that relied on typeof(a). :)

So,

Thanks!
--
Gustavo

author
#6 lore raw

Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()

In reply to Marco Elver
Quoted 40 lines · Marco Elver
Quoted 39 lines · Kees Cook

Provide helpers that will perform wrapping addition, subtraction, or multiplication without tripping the arithmetic wrap-around sanitizers. The first argument is the type under which the wrap-around should happen with. In other words, these two calls will get very different results:

        mul_wrap(int, 50, 50) == 2500
        mul_wrap(u8,  50, 50) ==  196

Add to the selftests to validate behavior and lack of side-effects.

Cc Rasmus Villemoes <[email protected]>
Cc Mark Rutland <[email protected]>
---
 include/linux/overflow.h | 54 ++++++++++++++++++++++++++++++++++++++++
 lib/overflow_kunit.c     | 23 ++++++++++++++---
 2 files changed, 73 insertions(+), 4 deletions(-)
include/linux/overflow.h +11 -0
index 4e741ebb8005..9b8c05bdb788 100644
@@ -64,6 +64,24 @@ static inline bool __must_check __must_check_overflow(bool overflow)
 #define check_add_overflow(a, b, d)    \
        __must_check_overflow(__builtin_add_overflow(a, b, d))
 
+/**
+ * add_wrap() - Intentionally perform a wrapping addition
+ * @type: type for result of calculation
+ * @a: first addend
+ * @b: second addend
+ *
+ * Return the potentially wrapped-around addition without
+ * tripping any wrap-around sanitizers that may be enabled.
+ */
+#define add_wrap(type, a, b)                           \
+       ({                                              \
Quoted 8 lines

include/linux/overflow.h static inline bool __must_check __must_check_overflow(bool overflow) · line 80

Quoted 3 lines
include/linux/overflow.h +3 -0
+               type __val;                             \
+               if (check_add_overflow(a, b, &__val)) { \
+                       /* do nothing */                \

The whole reason check_*_overflow() exists is to wrap the builtin in a function with __must_check. Here the result is explicitly ignored, so do we have to go through the check_add_overflow indirection? Why not just use the builtin directly? It might make sense to make the

Yes, this follows now. This is a leftover from extending the helpers to work with pointers, which I don't have any current use for now. I'll fix this.

Quoted 3 lines

compiler's job a little easier, because I predict that __must_check_overflow will be outlined with enough instrumentation (maybe it should have been __always_inline).

I could change that separately, yeah.

Signature · 1 line
Kees Cook
#7 lore raw

Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()

In reply to Kees Cook
Quoted 1 line · Kees Cook

Subject: Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()

Maybe these should be called wrapping_add, wrapping_sub, and wrapping_mul? Those names are more grammatically correct, and Rust chose those names too.

- Eric

author
#8 lore raw

Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()

Quoted 5 lines · Eric Biggers
Quoted 1 line · Kees Cook

Subject: Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()

Maybe these should be called wrapping_add, wrapping_sub, and wrapping_mul? Those names are more grammatically correct, and Rust chose those names too.

Sure, that works for me. What bout the inc_wrap() and dec_wrap() names? I assume wrapping_inc() and wrapping_dec() ?

Signature · 1 line
Kees Cook
#9 lore raw

Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()

Quoted 10 lines · Kees Cook
Quoted 5 lines · Eric Biggers
Quoted 1 line · Kees Cook

Subject: Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()

Maybe these should be called wrapping_add, wrapping_sub, and wrapping_mul? Those names are more grammatically correct, and Rust chose those names too.

Sure, that works for me. What bout the inc_wrap() and dec_wrap() names? I assume wrapping_inc() and wrapping_dec() ?

Yes, though I'm not sure those should exist at all. Maybe a += b should just become a = wrapping_add(a, b), instead of wrapping_inc(a, b)? wrapping_inc(a, b) isn't as self-explanatory. Likewise for wrapping_dec.

- Eric

maintainer
#10 lore raw

Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()

Quoted 8 lines · Eric Biggers
Quoted 7 lines · Kees Cook
Quoted 5 lines · Eric Biggers
Quoted 1 line · Kees Cook

Subject: Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()

Maybe these should be called wrapping_add, wrapping_sub, and wrapping_mul? Those names are more grammatically correct, and Rust chose those names too.

Quoted 7 lines
Quoted 3 lines

Sure, that works for me. What bout the inc_wrap() and dec_wrap() names? I assume wrapping_inc() and wrapping_dec() ?

Yes, though I'm not sure those should exist at all. Maybe a += b should just become a = wrapping_add(a, b), instead of wrapping_inc(a, b)? wrapping_inc(a, b) isn't as self-explanatory. Likewise for wrapping_dec.

It was to avoid repeating type information, as it would go from:

var_a += var_b;

to:

var_a = wrapping_add(typeof(var_a), var_a, var_b);

Which repeats "var_a" 3 times. :|

Signature · 1 line
Kees Cook
#11 lore raw

Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()

Quoted 21 lines · Kees Cook
Quoted 8 lines · Eric Biggers
Quoted 7 lines · Kees Cook
Quoted 5 lines · Eric Biggers
Quoted 1 line · Kees Cook

Subject: Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()

Maybe these should be called wrapping_add, wrapping_sub, and wrapping_mul? Those names are more grammatically correct, and Rust chose those names too.

Quoted 7 lines
Quoted 3 lines

Sure, that works for me. What bout the inc_wrap() and dec_wrap() names? I assume wrapping_inc() and wrapping_dec() ?

Yes, though I'm not sure those should exist at all. Maybe a += b should just become a = wrapping_add(a, b), instead of wrapping_inc(a, b)? wrapping_inc(a, b) isn't as self-explanatory. Likewise for wrapping_dec.

It was to avoid repeating type information, as it would go from:

Quoted 7 lines

var_a += var_b;

to:

var_a = wrapping_add(typeof(var_a), var_a, var_b);

Which repeats "var_a" 3 times. :|

Yeah, I think that's a reasonable rationale. I'm fine with the wrapping_* naming, and then the _inc and _dec helpers should follow.

However, I now wonder if those should really also return the new value. Yes, that corresponds to the value of the expression (a += b), but nobody would ever write c = (a += b) or otherwise make use of that value, and the naming doesn't immediately imply whether one should think of ++a or a++.

Rasmus

author
#12 lore raw

Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()

Quoted 24 lines · Rasmus Villemoes
Quoted 23 lines · Kees Cook
Quoted 8 lines · Eric Biggers
Quoted 7 lines · Kees Cook
Quoted 5 lines · Eric Biggers
Quoted 1 line · Kees Cook

Subject: Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()

Maybe these should be called wrapping_add, wrapping_sub, and wrapping_mul? Those names are more grammatically correct, and Rust chose those names too.

Quoted 7 lines
Quoted 3 lines

Sure, that works for me. What bout the inc_wrap() and dec_wrap() names? I assume wrapping_inc() and wrapping_dec() ?

Yes, though I'm not sure those should exist at all. Maybe a += b should just become a = wrapping_add(a, b), instead of wrapping_inc(a, b)? wrapping_inc(a, b) isn't as self-explanatory. Likewise for wrapping_dec.

It was to avoid repeating type information, as it would go from:

var_a += var_b;

Quoted 8 lines
Quoted 5 lines

to:

var_a = wrapping_add(typeof(var_a), var_a, var_b);

Which repeats "var_a" 3 times. :|

Yeah, I think that's a reasonable rationale. I'm fine with the wrapping_* naming, and then the _inc and _dec helpers should follow.

Sounds good.

Quoted 5 lines

However, I now wonder if those should really also return the new value. Yes, that corresponds to the value of the expression (a += b), but nobody would ever write c = (a += b) or otherwise make use of that value, and the naming doesn't immediately imply whether one should think of ++a or a++.

They were designed to return the new value, and the selftests validate that. I've updated the kern-doc to reflect this.

Signature · 1 line
Kees Cook
author
#13 lore raw

PATCH v3 3/3 overflow: Introduce inc_wrap() and dec_wrap()

In reply to Kees Cook

This allows replacements of the idioms "var += offset" and "var -= offset" with the inc_wrap() and dec_wrap() helpers respectively. They will avoid wrap-around sanitizer instrumentation.

Add to the selftests to validate behavior and lack of side-effects.

Cc Rasmus Villemoes <[email protected]>
Cc Mark Rutland <[email protected]>
Cc "Gustavo A. R. Silva" <[email protected]>
---
 include/linux/overflow.h | 28 +++++++++++++++++++++++++++
 lib/overflow_kunit.c     | 42 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 70 insertions(+)
include/linux/overflow.h +28 -0
index 9b8c05bdb788..6a4c18544ab1 100644
@@ -82,6 +82,20 @@ static inline bool __must_check __must_check_overflow(bool overflow)
 		__val;					\
 	})
 
+/**
+ * inc_wrap() - Intentionally perform a wrapping increment
+ * @var: variable to be incremented
+ * @offset: amount to add
+ *
+ * Increments @var by @offset with wrap-around. Returns the resulting
+ * value of @var. Will not trip any wrap-around sanitizers.
+ */
+#define inc_wrap(var, offset)					\
+	({							\
+		typeof(var) *__ptr = &(var);			\
+		*__ptr = add_wrap(typeof(var), *__ptr, offset);	\
+	})
+
 /**
  * check_sub_overflow() - Calculate subtraction with overflow checking
  * @a: minuend; value to subtract from
@@ -113,6 +127,20 @@ static inline bool __must_check __must_check_overflow(bool overflow)
 		__val;					\
 	})
 
+/**
+ * dec_wrap() - Intentionally perform a wrapping decrement
+ * @var: variable to be decremented
+ * @offset: amount to subtract
+ *
+ * Decrements @var by @offset with wrap-around. Returns the resulting
+ * value of @var. Will not trip any wrap-around sanitizers.
+ */
+#define dec_wrap(var, offset)					\
+	({							\
+		typeof(var) *__ptr = &(var);			\
+		*__ptr = sub_wrap(typeof(var), *__ptr, offset);	\
+	})
+
 /**
  * check_mul_overflow() - Calculate multiplication with overflow checking
  * @a: first factor
lib/overflow_kunit.c +42 -0

56 lines not on this page · raw message

Signature · 1 line
2.34.1