overflow: Introduce wrapping helpers
Subsystems (2)
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
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.
--- include/linux/overflow.h | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-)
include/linux/overflow.h +6 -12
@@ -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
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]>Signed-off-by Kees Cook <[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@@ -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))
PATCH v3 2/3 overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()
In reply to Kees CookProvide 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.
--- include/linux/overflow.h | 54 ++++++++++++++++++++++++++++++++++++++++ lib/overflow_kunit.c | 23 ++++++++++++++--- 2 files changed, 73 insertions(+), 4 deletions(-)
include/linux/overflow.h +54 -0
@@ -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
@@ -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
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) == 196Add to the selftests to validate behavior and lack of side-effects.
Cc Rasmus Villemoes <[email protected]>Cc Mark Rutland <[email protected]>Signed-off-by Kees Cook <[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@@ -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).
Gustavo A. R. Silva
Reviewed-byRe: [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) == 196Add to the selftests to validate behavior and lack of side-effects.
Cc Rasmus Villemoes <[email protected]>Cc Mark Rutland <[email protected]>Signed-off-by Kees Cook <[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@@ -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 thecheck_add_overflowindirection? 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_overflowwill 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
Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()
In reply to Marco ElverQuoted 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) == 196Add to the selftests to validate behavior and lack of side-effects.
Cc Rasmus Villemoes <[email protected]>Cc Mark Rutland <[email protected]>Signed-off-by Kees Cook <[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@@ -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 thecheck_add_overflowindirection? 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_overflowwill be outlined with enough instrumentation (maybe it should have been__always_inline).
I could change that separately, yeah.
Signature · 1 line
Kees Cook
Re: [PATCH v3 2/3] overflow: Introduce add_wrap(), sub_wrap(), and mul_wrap()
In reply to Kees CookQuoted 1 line · Kees Cook
Subject: Re: [PATCH v3 2/3] overflow: Introduce
add_wrap(),sub_wrap(), andmul_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
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(), andmul_wrap()Maybe these should be called
wrapping_add,wrapping_sub, andwrapping_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
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(), andmul_wrap()Maybe these should be called
wrapping_add,wrapping_sub, andwrapping_mul? Those names are more grammatically correct, and Rust chose those names too.Sure, that works for me. What bout the
inc_wrap()anddec_wrap()names? I assumewrapping_inc()andwrapping_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
Kees Cook
maintainerRe: [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(), andmul_wrap()Maybe these should be called
wrapping_add,wrapping_sub, andwrapping_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()anddec_wrap()names? I assumewrapping_inc()andwrapping_dec()?Yes, though I'm not sure those should exist at all. Maybe a += b should just become a =
wrapping_add(a, b), instead ofwrapping_inc(a, b)?wrapping_inc(a, b)isn't as self-explanatory. Likewise forwrapping_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
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(), andmul_wrap()Maybe these should be called
wrapping_add,wrapping_sub, andwrapping_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()anddec_wrap()names? I assumewrapping_inc()andwrapping_dec()?Yes, though I'm not sure those should exist at all. Maybe a += b should just become a =
wrapping_add(a, b), instead ofwrapping_inc(a, b)?wrapping_inc(a, b)isn't as self-explanatory. Likewise forwrapping_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
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(), andmul_wrap()Maybe these should be called
wrapping_add,wrapping_sub, andwrapping_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()anddec_wrap()names? I assumewrapping_inc()andwrapping_dec()?Yes, though I'm not sure those should exist at all. Maybe a += b should just become a =
wrapping_add(a, b), instead ofwrapping_inc(a, b)?wrapping_inc(a, b)isn't as self-explanatory. Likewise forwrapping_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
_incand_dechelpers 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
PATCH v3 3/3 overflow: Introduce inc_wrap() and dec_wrap()
In reply to Kees CookThis 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.
--- include/linux/overflow.h | 28 +++++++++++++++++++++++++++ lib/overflow_kunit.c | 42 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 70 insertions(+)
include/linux/overflow.h +28 -0
@@ -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