WARNING: line length of 82 exceeds 80 columns
#88: FILE: include/linux/bpf_verifier.h:252:
+static inline void reg_set_srange32(struct bpf_reg_state *reg, s32 smin, s32 smax)

WARNING: line length of 82 exceeds 80 columns
#94: FILE: include/linux/bpf_verifier.h:258:
+static inline void reg_set_urange32(struct bpf_reg_state *reg, u32 umin, u32 umax)

WARNING: line length of 82 exceeds 80 columns
#100: FILE: include/linux/bpf_verifier.h:264:
+static inline void reg_set_srange64(struct bpf_reg_state *reg, s64 smin, s64 smax)

WARNING: line length of 82 exceeds 80 columns
#106: FILE: include/linux/bpf_verifier.h:270:
+static inline void reg_set_urange64(struct bpf_reg_state *reg, u64 umin, u64 umax)

WARNING: line length of 100 exceeds 80 columns
#294: FILE: kernel/bpf/verifier.c:1972:
+			 max_t(s32, reg_s32_min(reg), var32_off.value | (var32_off.mask & S32_MIN)),

WARNING: line length of 101 exceeds 80 columns
#296: FILE: kernel/bpf/verifier.c:1974:
+			 min_t(s32, reg_s32_max(reg), var32_off.value | (var32_off.mask & S32_MAX)));

WARNING: line length of 89 exceeds 80 columns
#299: FILE: kernel/bpf/verifier.c:1977:
+			 min(reg_u32_max(reg), (u32)(var32_off.value | var32_off.mask)));

WARNING: line length of 83 exceeds 80 columns
#317: FILE: kernel/bpf/verifier.c:1989:
+			       reg->var_off.value | (reg->var_off.mask & S64_MIN)),

WARNING: line length of 84 exceeds 80 columns
#319: FILE: kernel/bpf/verifier.c:1991:
+			       reg->var_off.value | (reg->var_off.mask & S64_MAX)));

WARNING: line length of 82 exceeds 80 columns
#329: FILE: kernel/bpf/verifier.c:1999:
+	umin_in_tnum = (reg_umin(reg) & ~reg->var_off.mask) == reg->var_off.value;

WARNING: line length of 82 exceeds 80 columns
#365: FILE: kernel/bpf/verifier.c:2060:
+				 max_t(u32, reg_u32_min(reg), (u32)reg_umin(reg)),

WARNING: line length of 83 exceeds 80 columns
#366: FILE: kernel/bpf/verifier.c:2061:
+				 min_t(u32, reg_u32_max(reg), (u32)reg_umax(reg)));

WARNING: line length of 90 exceeds 80 columns
#373: FILE: kernel/bpf/verifier.c:2065:
+					 max_t(s32, reg_s32_min(reg), (s32)reg_umin(reg)),

WARNING: line length of 91 exceeds 80 columns
#374: FILE: kernel/bpf/verifier.c:2066:
+					 min_t(s32, reg_s32_max(reg), (s32)reg_umax(reg)));

WARNING: line length of 90 exceeds 80 columns
#385: FILE: kernel/bpf/verifier.c:2073:
+					 max_t(u32, reg_u32_min(reg), (u32)reg_smin(reg)),

WARNING: line length of 91 exceeds 80 columns
#386: FILE: kernel/bpf/verifier.c:2074:
+					 min_t(u32, reg_u32_max(reg), (u32)reg_smax(reg)));

WARNING: line length of 90 exceeds 80 columns
#394: FILE: kernel/bpf/verifier.c:2079:
+					 max_t(s32, reg_s32_min(reg), (s32)reg_smin(reg)),

WARNING: line length of 91 exceeds 80 columns
#395: FILE: kernel/bpf/verifier.c:2080:
+					 min_t(s32, reg_s32_max(reg), (s32)reg_smax(reg)));

WARNING: line length of 82 exceeds 80 columns
#410: FILE: kernel/bpf/verifier.c:2099:
+				 max_t(s32, reg_s32_min(reg), (s32)reg_umin(reg)),

WARNING: line length of 83 exceeds 80 columns
#411: FILE: kernel/bpf/verifier.c:2100:
+				 min_t(s32, reg_s32_max(reg), (s32)reg_umax(reg)));

WARNING: line length of 82 exceeds 80 columns
#420: FILE: kernel/bpf/verifier.c:2105:
+				 max_t(s32, reg_s32_min(reg), (s32)reg_smin(reg)),

WARNING: line length of 83 exceeds 80 columns
#421: FILE: kernel/bpf/verifier.c:2106:
+				 min_t(s32, reg_s32_max(reg), (s32)reg_smax(reg)));

WARNING: line length of 81 exceeds 80 columns
#435: FILE: kernel/bpf/verifier.c:2118:
+				 min_t(s32, reg_s32_max(reg), reg_u32_max(reg)));

WARNING: line length of 81 exceeds 80 columns
#447: FILE: kernel/bpf/verifier.c:2127:
+				 min_t(u32, reg_s32_max(reg), reg_u32_max(reg)));

WARNING: line length of 87 exceeds 80 columns
#461: FILE: kernel/bpf/verifier.c:2139:
+			reg_set_srange32(reg, (s32)reg_u32_min(reg), reg_s32_max(reg));

WARNING: line length of 89 exceeds 80 columns
#464: FILE: kernel/bpf/verifier.c:2142:
+					 min_t(u32, reg_u32_max(reg), reg_s32_max(reg)));

WARNING: line length of 87 exceeds 80 columns
#475: FILE: kernel/bpf/verifier.c:2151:
+			reg_set_srange32(reg, reg_s32_min(reg), (s32)reg_u32_max(reg));

WARNING: line length of 88 exceeds 80 columns
#477: FILE: kernel/bpf/verifier.c:2153:
+					 max_t(u32, reg_u32_min(reg), reg_s32_min(reg)),

WARNING: line length of 81 exceeds 80 columns
#517: FILE: kernel/bpf/verifier.c:2278:
+			reg_set_srange64(reg, (s64)reg_umin(reg), reg_smax(reg));

WARNING: line length of 103 exceeds 80 columns
#518: FILE: kernel/bpf/verifier.c:2279:
+			reg_set_urange64(reg, reg_umin(reg), min_t(u64, reg_umax(reg), reg_smax(reg)));

WARNING: line length of 81 exceeds 80 columns
#529: FILE: kernel/bpf/verifier.c:2290:
+			reg_set_srange64(reg, reg_smin(reg), (s64)reg_umax(reg));

WARNING: line length of 103 exceeds 80 columns
#530: FILE: kernel/bpf/verifier.c:2291:
+			reg_set_urange64(reg, max_t(u64, reg_umin(reg), reg_smin(reg)), reg_umax(reg));

WARNING: line length of 92 exceeds 80 columns
#569: FILE: kernel/bpf/verifier.c:2355:
+	if (reg_s32_min(reg) >= 0 && reg_smin(reg) >= S32_MIN && reg_smax(reg) <= S32_MAX) {

WARNING: line length of 88 exceeds 80 columns
#574: FILE: kernel/bpf/verifier.c:2359:
+					      tnum_range(reg_smin(reg), reg_smax(reg)));

WARNING: line length of 81 exceeds 80 columns
#601: FILE: kernel/bpf/verifier.c:2407:
+	return (reg_umin(reg) > reg_umax(reg) || reg_smin(reg) > reg_smax(reg) ||

WARNING: braces {} are not necessary for any arm of this statement
#839: FILE: kernel/bpf/verifier.c:5654:
+	if ((reg_umin(reg) & ~mask) == (reg_umax(reg) & ~mask)) {
[...]
 	} else {
[...]

WARNING: line length of 82 exceeds 80 columns
#840: FILE: kernel/bpf/verifier.c:5655:
+		reg_set_urange64(reg, reg_umin(reg) & mask, reg_umax(reg) & mask);

WARNING: line length of 89 exceeds 80 columns
#1040: FILE: kernel/bpf/verifier.c:7037:
+			if (env->prog->aux->max_ctx_offset < reg_umax(reg) + access_size)

WARNING: line length of 93 exceeds 80 columns
#1041: FILE: kernel/bpf/verifier.c:7038:
+				env->prog->aux->max_ctx_offset = reg_umax(reg) + access_size;

WARNING: line length of 95 exceeds 80 columns
#1069: FILE: kernel/bpf/verifier.c:7095:
+			reg_arg_name(env, size_argno), reg_umin(size_reg), reg_umax(size_reg));

WARNING: line length of 82 exceeds 80 columns
#1080: FILE: kernel/bpf/verifier.c:7104:
+	err = check_helper_mem_access(env, mem_reg, mem_argno, reg_umax(size_reg),

WARNING: line length of 92 exceeds 80 columns
#1089: FILE: kernel/bpf/verifier.c:9837:
+		return range.minval <= reg_s32_min(reg) && reg_s32_max(reg) <= range.maxval;

WARNING: line length of 86 exceeds 80 columns
#1092: FILE: kernel/bpf/verifier.c:9839:
+		return range.minval <= reg_smin(reg) && reg_smax(reg) <= range.maxval;

WARNING: line length of 81 exceeds 80 columns
#1129: FILE: kernel/bpf/verifier.c:10421:
+		if (cur_func(env)->callback_depth < reg_umax(&regs[BPF_REG_1])) {

WARNING: line length of 81 exceeds 80 columns
#1156: FILE: kernel/bpf/verifier.c:13457:
+		ptr_limit = mask_to_left ? reg_smin(ptr_reg) : reg_umax(ptr_reg);

WARNING: line length of 92 exceeds 80 columns
#1252: FILE: kernel/bpf/verifier.c:13931:
+			reg_set_urange64(dst_reg, umin_ptr - umax_val, umax_ptr - umin_val);

WARNING: line length of 88 exceeds 80 columns
#1754: FILE: kernel/bpf/verifier.c:14349:
+	if (reg_s32_min(dst_reg) >= -res_max_abs && reg_s32_max(dst_reg) <= res_max_abs)

WARNING: braces {} are not necessary for any arm of this statement
#1764: FILE: kernel/bpf/verifier.c:14353:
+	if (reg_s32_min(dst_reg) >= 0) {
[...]
+	} else if (reg_s32_max(dst_reg) <= 0) {
[...]
 	} else {
[...]

WARNING: line length of 85 exceeds 80 columns
#1765: FILE: kernel/bpf/verifier.c:14354:
+		reg_set_srange32(dst_reg, 0, min(reg_s32_max(dst_reg), res_max_abs));

WARNING: line length of 86 exceeds 80 columns
#1767: FILE: kernel/bpf/verifier.c:14356:
+		reg_set_srange32(dst_reg, max(reg_s32_min(dst_reg), -res_max_abs), 0);

WARNING: line length of 82 exceeds 80 columns
#1796: FILE: kernel/bpf/verifier.c:14389:
+	if (reg_smin(dst_reg) >= -res_max_abs && reg_smax(dst_reg) <= res_max_abs)

WARNING: braces {} are not necessary for any arm of this statement
#1806: FILE: kernel/bpf/verifier.c:14393:
+	if (reg_smin(dst_reg) >= 0) {
[...]
+	} else if (reg_smax(dst_reg) <= 0) {
[...]
 	} else {
[...]

WARNING: line length of 82 exceeds 80 columns
#1807: FILE: kernel/bpf/verifier.c:14394:
+		reg_set_srange64(dst_reg, 0, min(reg_smax(dst_reg), res_max_abs));

WARNING: line length of 83 exceeds 80 columns
#1809: FILE: kernel/bpf/verifier.c:14396:
+		reg_set_srange64(dst_reg, max(reg_smin(dst_reg), -res_max_abs), 0);

WARNING: line length of 88 exceeds 80 columns
#1838: FILE: kernel/bpf/verifier.c:14422:
+	reg_set_urange32(dst_reg, var32_off.value, min(reg_u32_max(dst_reg), umax_val));

WARNING: line length of 86 exceeds 80 columns
#1851: FILE: kernel/bpf/verifier.c:14428:
+		reg_set_srange32(dst_reg, reg_u32_min(dst_reg), reg_u32_max(dst_reg));

WARNING: line length of 92 exceeds 80 columns
#1872: FILE: kernel/bpf/verifier.c:14448:
+	reg_set_urange64(dst_reg, dst_reg->var_off.value, min(reg_umax(dst_reg), umax_val));

WARNING: line length of 86 exceeds 80 columns
#1920: FILE: kernel/bpf/verifier.c:14484:
+		reg_set_srange32(dst_reg, reg_u32_min(dst_reg), reg_u32_max(dst_reg));

WARNING: line length of 85 exceeds 80 columns
#1967: FILE: kernel/bpf/verifier.c:14531:
+	reg_set_urange32(dst_reg, var32_off.value, var32_off.value | var32_off.mask);

WARNING: line length of 86 exceeds 80 columns
#1980: FILE: kernel/bpf/verifier.c:14537:
+		reg_set_srange32(dst_reg, reg_u32_min(dst_reg), reg_u32_max(dst_reg));

CHECK: Logical continuations should be on the previous line
#2198: FILE: kernel/bpf/verifier.c:14809:
 		if (tnum_subreg_is_const(src_reg->var_off)
+		    && reg_s32_min(src_reg) == reg_s32_max(src_reg)

CHECK: Logical continuations should be on the previous line
#2199: FILE: kernel/bpf/verifier.c:14810:
+		    && reg_s32_min(src_reg) == reg_s32_max(src_reg)
+		    && reg_u32_min(src_reg) == reg_u32_max(src_reg))

CHECK: Logical continuations should be on the previous line
#2205: FILE: kernel/bpf/verifier.c:14814:
 		if (tnum_is_const(src_reg->var_off)
+		    && reg_smin(src_reg) == reg_smax(src_reg)

CHECK: Logical continuations should be on the previous line
#2206: FILE: kernel/bpf/verifier.c:14815:
+		    && reg_smin(src_reg) == reg_smax(src_reg)
+		    && reg_umin(src_reg) == reg_umax(src_reg))

WARNING: line length of 99 exceeds 80 columns
#2236: FILE: kernel/bpf/verifier.c:14944:
+		if ((alu32 && reg_u32_min(&src_reg) == 0) || (!alu32 && reg_umin(&src_reg) == 0)) {

WARNING: line length of 97 exceeds 80 columns
#2245: FILE: kernel/bpf/verifier.c:14961:
+		if ((alu32 && reg_u32_min(&src_reg) == 0) || (!alu32 && reg_umin(&src_reg) == 0))

WARNING: line length of 104 exceeds 80 columns
#2263: FILE: kernel/bpf/verifier.c:15291:
+						no_sext = reg_umax(src_reg) < (1ULL << (insn->off - 1));

WARNING: line length of 109 exceeds 80 columns
#2272: FILE: kernel/bpf/verifier.c:15326:
+						bool no_sext = reg_umax(src_reg) < (1ULL << (insn->off - 1));

WARNING: line length of 83 exceeds 80 columns
#2302: FILE: kernel/bpf/verifier.c:15467:
+	 * reg_umax(dst_reg) is known < MAX_PACKET_OFF, therefore it fits in a u16.

WARNING: line length of 89 exceeds 80 columns
#2373: FILE: kernel/bpf/verifier.c:15832:
+			reg_set_urange32(reg1, max(reg_u32_min(reg1), reg_u32_min(reg2)),

WARNING: line length of 84 exceeds 80 columns
#2374: FILE: kernel/bpf/verifier.c:15833:
+					 min(reg_u32_max(reg1), reg_u32_max(reg2)));

WARNING: line length of 89 exceeds 80 columns
#2375: FILE: kernel/bpf/verifier.c:15834:
+			reg_set_srange32(reg1, max(reg_s32_min(reg1), reg_s32_min(reg2)),

WARNING: line length of 84 exceeds 80 columns
#2376: FILE: kernel/bpf/verifier.c:15835:
+					 min(reg_s32_max(reg1), reg_s32_max(reg2)));

WARNING: line length of 85 exceeds 80 columns
#2377: FILE: kernel/bpf/verifier.c:15836:
+			reg_set_urange32(reg2, reg_u32_min(reg1), reg_u32_max(reg1));

WARNING: line length of 85 exceeds 80 columns
#2378: FILE: kernel/bpf/verifier.c:15837:
+			reg_set_srange32(reg2, reg_s32_min(reg1), reg_s32_max(reg1));

WARNING: line length of 83 exceeds 80 columns
#2392: FILE: kernel/bpf/verifier.c:15843:
+			reg_set_urange64(reg1, max(reg_umin(reg1), reg_umin(reg2)),

WARNING: line length of 83 exceeds 80 columns
#2394: FILE: kernel/bpf/verifier.c:15845:
+			reg_set_srange64(reg1, max(reg_smin(reg1), reg_smin(reg2)),

WARNING: line length of 97 exceeds 80 columns
#2425: FILE: kernel/bpf/verifier.c:15875:
+				reg_set_urange32(reg1, reg_u32_min(reg1) + 1, reg_u32_max(reg1));

WARNING: line length of 97 exceeds 80 columns
#2427: FILE: kernel/bpf/verifier.c:15877:
+				reg_set_urange32(reg1, reg_u32_min(reg1), reg_u32_max(reg1) - 1);

WARNING: line length of 97 exceeds 80 columns
#2429: FILE: kernel/bpf/verifier.c:15879:
+				reg_set_srange32(reg1, reg_s32_min(reg1) + 1, reg_s32_max(reg1));

WARNING: line length of 97 exceeds 80 columns
#2431: FILE: kernel/bpf/verifier.c:15881:
+				reg_set_srange32(reg1, reg_s32_min(reg1), reg_s32_max(reg1) - 1);

WARNING: line length of 91 exceeds 80 columns
#2442: FILE: kernel/bpf/verifier.c:15884:
+				reg_set_urange64(reg1, reg_umin(reg1) + 1, reg_umax(reg1));

WARNING: line length of 91 exceeds 80 columns
#2444: FILE: kernel/bpf/verifier.c:15886:
+				reg_set_urange64(reg1, reg_umin(reg1), reg_umax(reg1) - 1);

WARNING: line length of 91 exceeds 80 columns
#2446: FILE: kernel/bpf/verifier.c:15888:
+				reg_set_srange64(reg1, reg_smin(reg1) + 1, reg_smax(reg1));

WARNING: line length of 91 exceeds 80 columns
#2448: FILE: kernel/bpf/verifier.c:15890:
+				reg_set_srange64(reg1, reg_smin(reg1), reg_smax(reg1) - 1);

WARNING: line length of 109 exceeds 80 columns
#2458: FILE: kernel/bpf/verifier.c:15937:
+			reg_set_urange32(reg1, reg_u32_min(reg1), min(reg_u32_max(reg1), reg_u32_max(reg2)));

WARNING: line length of 109 exceeds 80 columns
#2459: FILE: kernel/bpf/verifier.c:15938:
+			reg_set_urange32(reg2, max(reg_u32_min(reg1), reg_u32_min(reg2)), reg_u32_max(reg2));

WARNING: line length of 100 exceeds 80 columns
#2463: FILE: kernel/bpf/verifier.c:15940:
+			reg_set_urange64(reg1, reg_umin(reg1), min(reg_umax(reg1), reg_umax(reg2)));

WARNING: line length of 100 exceeds 80 columns
#2464: FILE: kernel/bpf/verifier.c:15941:
+			reg_set_urange64(reg2, max(reg_umin(reg1), reg_umin(reg2)), reg_umax(reg2));

WARNING: line length of 113 exceeds 80 columns
#2471: FILE: kernel/bpf/verifier.c:15946:
+			reg_set_urange32(reg1, reg_u32_min(reg1), min(reg_u32_max(reg1), reg_u32_max(reg2) - 1));

WARNING: line length of 113 exceeds 80 columns
#2472: FILE: kernel/bpf/verifier.c:15947:
+			reg_set_urange32(reg2, max(reg_u32_min(reg1) + 1, reg_u32_min(reg2)), reg_u32_max(reg2));

WARNING: line length of 104 exceeds 80 columns
#2476: FILE: kernel/bpf/verifier.c:15949:
+			reg_set_urange64(reg1, reg_umin(reg1), min(reg_umax(reg1), reg_umax(reg2) - 1));

WARNING: line length of 104 exceeds 80 columns
#2477: FILE: kernel/bpf/verifier.c:15950:
+			reg_set_urange64(reg2, max(reg_umin(reg1) + 1, reg_umin(reg2)), reg_umax(reg2));

WARNING: line length of 109 exceeds 80 columns
#2484: FILE: kernel/bpf/verifier.c:15955:
+			reg_set_srange32(reg1, reg_s32_min(reg1), min(reg_s32_max(reg1), reg_s32_max(reg2)));

WARNING: line length of 109 exceeds 80 columns
#2485: FILE: kernel/bpf/verifier.c:15956:
+			reg_set_srange32(reg2, max(reg_s32_min(reg1), reg_s32_min(reg2)), reg_s32_max(reg2));

WARNING: line length of 100 exceeds 80 columns
#2489: FILE: kernel/bpf/verifier.c:15958:
+			reg_set_srange64(reg1, reg_smin(reg1), min(reg_smax(reg1), reg_smax(reg2)));

WARNING: line length of 100 exceeds 80 columns
#2490: FILE: kernel/bpf/verifier.c:15959:
+			reg_set_srange64(reg2, max(reg_smin(reg1), reg_smin(reg2)), reg_smax(reg2));

WARNING: line length of 113 exceeds 80 columns
#2497: FILE: kernel/bpf/verifier.c:15964:
+			reg_set_srange32(reg1, reg_s32_min(reg1), min(reg_s32_max(reg1), reg_s32_max(reg2) - 1));

WARNING: line length of 113 exceeds 80 columns
#2498: FILE: kernel/bpf/verifier.c:15965:
+			reg_set_srange32(reg2, max(reg_s32_min(reg1) + 1, reg_s32_min(reg2)), reg_s32_max(reg2));

WARNING: line length of 104 exceeds 80 columns
#2502: FILE: kernel/bpf/verifier.c:15967:
+			reg_set_srange64(reg1, reg_smin(reg1), min(reg_smax(reg1), reg_smax(reg2) - 1));

WARNING: line length of 104 exceeds 80 columns
#2503: FILE: kernel/bpf/verifier.c:15968:
+			reg_set_srange64(reg2, max(reg_smin(reg1) + 1, reg_smin(reg2)), reg_smax(reg2));

WARNING: line length of 98 exceeds 80 columns
#2519: FILE: kernel/bpf/verifier.c:17474:
+		verbose(env, "the sum of R%u umin_value %llu is too big\n", regno, reg_umin(reg));

WARNING: line length of 98 exceeds 80 columns
#2524: FILE: kernel/bpf/verifier.c:17478:
+		verbose(env, "the sum of R%u umax_value %llu is too big\n", regno, reg_umax(reg));

total: 0 errors, 99 warnings, 4 checks, 2381 lines checked

NOTE: For some of the reported defects, checkpatch may be able to
      mechanically convert to the typical style using --fix or --fix-inplace.

Commit c835eee1e9d1 ("bpf: use accessor functions for bpf_reg_state min/max fields") has style problems, please review.

NOTE: Ignored message types: ALLOC_SIZEOF_STRUCT BAD_REPORTED_BY_LINK CAMELCASE COMMIT_LOG_LONG_LINE FILE_PATH_CHANGES GIT_COMMIT_ID MACRO_ARG_REUSE NO_AUTHOR_SIGN_OFF

NOTE: If any of the errors are false positives, please report
      them to the maintainer, see CHECKPATCH in MAINTAINERS.
total: 0 errors, 99 warnings, 4 checks, 2381 lines checked