bpf: use check_sub_overflow() to check for subtraction overflows

Similar to previous patch that drops signed_add*_overflows() and uses
(compiler) builtin-based check_add_overflow(), do the same for
signed_sub*_overflows() and replace them with the generic
check_sub_overflow() to make future refactoring easier and have the
checks implemented more efficiently.

Unsigned overflow check for subtraction does not use helpers and are
simple enough already, so they're left untouched.

After the change GCC 13.3.0 generates cleaner assembly on x86_64:

	if (check_sub_overflow(*dst_smin, src_reg->smax_value, dst_smin) ||
   139bf:	mov    0x28(%r12),%rax
   139c4:	mov    %edx,0x54(%r12)
   139c9:	sub    %r11,%rax
   139cc:	mov    %rax,0x28(%r12)
   139d1:	jo     14627 <adjust_reg_min_max_vals+0x1237>
	    check_sub_overflow(*dst_smax, src_reg->smin_value, dst_smax)) {
   139d7:	mov    0x30(%r12),%rax
   139dc:	sub    %r9,%rax
   139df:	mov    %rax,0x30(%r12)
	if (check_sub_overflow(*dst_smin, src_reg->smax_value, dst_smin) ||
   139e4:	jo     14627 <adjust_reg_min_max_vals+0x1237>
   ...
		*dst_smin = S64_MIN;
   14627:	movabs $0x8000000000000000,%rax
   14631:	mov    %rax,0x28(%r12)
		*dst_smax = S64_MAX;
   14636:	sub    $0x1,%rax
   1463a:	mov    %rax,0x30(%r12)

Before the change it gives:

	if (signed_sub_overflows(dst_reg->smin_value, smax_val) ||
   13a50:	mov    0x28(%r12),%rdi
   13a55:	mov    %edx,0x54(%r12)
		dst_reg->smax_value = S64_MAX;
   13a5a:	movabs $0x7fffffffffffffff,%rdx
   13a64:	mov    %eax,0x50(%r12)
		dst_reg->smin_value = S64_MIN;
   13a69:	movabs $0x8000000000000000,%rax
	s64 res = (s64)((u64)a - (u64)b);
   13a73:	mov    %rdi,%rsi
   13a76:	sub    %rcx,%rsi
	if (b < 0)
   13a79:	test   %rcx,%rcx
   13a7c:	js     145ea <adjust_reg_min_max_vals+0x119a>
	if (signed_sub_overflows(dst_reg->smin_value, smax_val) ||
   13a82:	cmp    %rsi,%rdi
   13a85:	jl     13ac7 <adjust_reg_min_max_vals+0x677>
	    signed_sub_overflows(dst_reg->smax_value, smin_val)) {
   13a87:	mov    0x30(%r12),%r8
	s64 res = (s64)((u64)a - (u64)b);
   13a8c:	mov    %r8,%rax
   13a8f:	sub    %r9,%rax
	return res > a;
   13a92:	cmp    %rax,%r8
   13a95:	setl   %sil
	if (b < 0)
   13a99:	test   %r9,%r9
   13a9c:	js     147d1 <adjust_reg_min_max_vals+0x1381>
		dst_reg->smax_value = S64_MAX;
   13aa2:	movabs $0x7fffffffffffffff,%rdx
		dst_reg->smin_value = S64_MIN;
   13aac:	movabs $0x8000000000000000,%rax
	if (signed_sub_overflows(dst_reg->smin_value, smax_val) ||
   13ab6:	test   %sil,%sil
   13ab9:	jne    13ac7 <adjust_reg_min_max_vals+0x677>
		dst_reg->smin_value -= smax_val;
   13abb:	mov    %rdi,%rax
		dst_reg->smax_value -= smin_val;
   13abe:	mov    %r8,%rdx
		dst_reg->smin_value -= smax_val;
   13ac1:	sub    %rcx,%rax
		dst_reg->smax_value -= smin_val;
   13ac4:	sub    %r9,%rdx
   13ac7:	mov    %rax,0x28(%r12)
   ...
   13ad1:	mov    %rdx,0x30(%r12)
   ...
	if (signed_sub_overflows(dst_reg->smin_value, smax_val) ||
   145ea:	cmp    %rsi,%rdi
   145ed:	jg     13ac7 <adjust_reg_min_max_vals+0x677>
   145f3:	jmp    13a87 <adjust_reg_min_max_vals+0x637>

Suggested-by: Jiri Olsa <jolsa@kernel.org>
Signed-off-by: Shung-Hsi Yu <shung-hsi.yu@suse.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20240712080127.136608-4-shung-hsi.yu@suse.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index 0126c9c80c58e9e30e645ede0b70e4fa64172cbd..8da132a1ef2818f9e53951e7bc474ce533abad18 100644 (file)
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -12726,26 +12726,6 @@ static int check_kfunc_call(struct bpf_verifier_env *env, struct bpf_insn *insn,
        return 0;
 }
 
-static bool signed_sub_overflows(s64 a, s64 b)
-{
-       /* Do the sub in u64, where overflow is well-defined */
-       s64 res = (s64)((u64)a - (u64)b);
-
-       if (b < 0)
-               return res < a;
-       return res > a;
-}
-
-static bool signed_sub32_overflows(s32 a, s32 b)
-{
-       /* Do the sub in u32, where overflow is well-defined */
-       s32 res = (s32)((u32)a - (u32)b);
-
-       if (b < 0)
-               return res < a;
-       return res > a;
-}
-
 static bool check_reg_sane_offset(struct bpf_verifier_env *env,
                                  const struct bpf_reg_state *reg,
                                  enum bpf_reg_type type)
@@ -13278,14 +13258,11 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env,
                /* A new variable offset is created.  If the subtrahend is known
                 * nonnegative, then any reg->range we had before is still good.
                 */
-               if (signed_sub_overflows(smin_ptr, smax_val) ||
-                   signed_sub_overflows(smax_ptr, smin_val)) {
+               if (check_sub_overflow(smin_ptr, smax_val, &dst_reg->smin_value) ||
+                   check_sub_overflow(smax_ptr, smin_val, &dst_reg->smax_value)) {
                        /* Overflow possible, we know nothing */
                        dst_reg->smin_value = S64_MIN;
                        dst_reg->smax_value = S64_MAX;
-               } else {
-                       dst_reg->smin_value = smin_ptr - smax_val;
-                       dst_reg->smax_value = smax_ptr - smin_val;
                }
                if (umin_ptr < umax_val) {
                        /* Overflow possible, we know nothing */
@@ -13378,19 +13355,16 @@ static void scalar_min_max_add(struct bpf_reg_state *dst_reg,
 static void scalar32_min_max_sub(struct bpf_reg_state *dst_reg,
                                 struct bpf_reg_state *src_reg)
 {
-       s32 smin_val = src_reg->s32_min_value;
-       s32 smax_val = src_reg->s32_max_value;
+       s32 *dst_smin = &dst_reg->s32_min_value;
+       s32 *dst_smax = &dst_reg->s32_max_value;
        u32 umin_val = src_reg->u32_min_value;
        u32 umax_val = src_reg->u32_max_value;
 
-       if (signed_sub32_overflows(dst_reg->s32_min_value, smax_val) ||
-           signed_sub32_overflows(dst_reg->s32_max_value, smin_val)) {
+       if (check_sub_overflow(*dst_smin, src_reg->s32_max_value, dst_smin) ||
+           check_sub_overflow(*dst_smax, src_reg->s32_min_value, dst_smax)) {
                /* Overflow possible, we know nothing */
-               dst_reg->s32_min_value = S32_MIN;
-               dst_reg->s32_max_value = S32_MAX;
-       } else {
-               dst_reg->s32_min_value -= smax_val;
-               dst_reg->s32_max_value -= smin_val;
+               *dst_smin = S32_MIN;
+               *dst_smax = S32_MAX;
        }
        if (dst_reg->u32_min_value < umax_val) {
                /* Overflow possible, we know nothing */
@@ -13406,19 +13380,16 @@ static void scalar32_min_max_sub(struct bpf_reg_state *dst_reg,
 static void scalar_min_max_sub(struct bpf_reg_state *dst_reg,
                               struct bpf_reg_state *src_reg)
 {
-       s64 smin_val = src_reg->smin_value;
-       s64 smax_val = src_reg->smax_value;
+       s64 *dst_smin = &dst_reg->smin_value;
+       s64 *dst_smax = &dst_reg->smax_value;
        u64 umin_val = src_reg->umin_value;
        u64 umax_val = src_reg->umax_value;
 
-       if (signed_sub_overflows(dst_reg->smin_value, smax_val) ||
-           signed_sub_overflows(dst_reg->smax_value, smin_val)) {
+       if (check_sub_overflow(*dst_smin, src_reg->smax_value, dst_smin) ||
+           check_sub_overflow(*dst_smax, src_reg->smin_value, dst_smax)) {
                /* Overflow possible, we know nothing */
-               dst_reg->smin_value = S64_MIN;
-               dst_reg->smax_value = S64_MAX;
-       } else {
-               dst_reg->smin_value -= smax_val;
-               dst_reg->smax_value -= smin_val;
+               *dst_smin = S64_MIN;
+               *dst_smax = S64_MAX;
        }
        if (dst_reg->umin_value < umax_val) {
                /* Overflow possible, we know nothing */