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:1926:
+			 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:1928:
+			 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:1931:
+			 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:1943:
+			       reg->var_off.value | (reg->var_off.mask & S64_MIN)),

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

WARNING: line length of 82 exceeds 80 columns
#329: FILE: kernel/bpf/verifier.c:1953:
+	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:2014:
+				 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:2015:
+				 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:2019:
+					 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:2020:
+					 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:2027:
+					 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:2028:
+					 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:2033:
+					 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:2034:
+					 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:2053:
+				 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:2054:
+				 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:2059:
+				 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:2060:
+				 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:2072:
+				 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:2081:
+				 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:2093:
+			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:2096:
+					 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:2105:
+			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:2107:
+					 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:2232:
+			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:2233:
+			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:2244:
+			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:2245:
+			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:2309:
+	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:2313:
+					      tnum_range(reg_smin(reg), reg_smax(reg)));

WARNING: line length of 81 exceeds 80 columns
#601: FILE: kernel/bpf/verifier.c:2361:
+	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:5623:
+	if ((reg_umin(reg) & ~mask) == (reg_umax(reg) & ~mask)) {
[...]
 	} else {
[...]

WARNING: line length of 82 exceeds 80 columns
#840: FILE: kernel/bpf/verifier.c:5624:
+		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:7007:
+			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:7008:
+				env->prog->aux->max_ctx_offset = reg_umax(reg) + access_size;

WARNING: line length of 92 exceeds 80 columns
#1089: FILE: kernel/bpf/verifier.c:9799:
+		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:9801:
+		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:10383:
+		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:13384:
+		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:13858:
+			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:14276:
+	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:14280:
+	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:14281:
+		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:14283:
+		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:14316:
+	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:14320:
+	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:14321:
+		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:14323:
+		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:14349:
+	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:14355:
+		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:14375:
+	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:14411:
+		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:14458:
+	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:14464:
+		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:14736:
 		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:14737:
+		    && 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:14741:
 		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:14742:
+		    && 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:14871:
+		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:14888:
+		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:15218:
+						no_sext = reg_umax(src_reg) < (1ULL << (insn->off - 1));

WARNING: line length of 109 exceeds 80 columns
#2272: FILE: kernel/bpf/verifier.c:15253:
+						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:15394:
+	 * 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:15759:
+			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:15760:
+					 min(reg_u32_max(reg1), reg_u32_max(reg2)));

WARNING: line length of 89 exceeds 80 columns
#2375: FILE: kernel/bpf/verifier.c:15761:
+			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:15762:
+					 min(reg_s32_max(reg1), reg_s32_max(reg2)));

WARNING: line length of 85 exceeds 80 columns
#2377: FILE: kernel/bpf/verifier.c:15763:
+			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:15764:
+			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:15770:
+			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:15772:
+			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:15802:
+				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:15804:
+				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:15806:
+				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:15808:
+				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:15811:
+				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:15813:
+				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:15815:
+				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:15817:
+				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:15864:
+			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:15865:
+			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:15867:
+			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:15868:
+			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:15873:
+			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:15874:
+			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:15876:
+			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:15877:
+			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:15882:
+			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:15883:
+			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:15885:
+			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:15886:
+			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:15891:
+			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:15892:
+			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:15894:
+			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:15895:
+			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:17401:
+		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:17405:
+		verbose(env, "the sum of R%u umax_value %llu is too big\n", regno, reg_umax(reg));

total: 0 errors, 97 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 bd85feea7438 ("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, 97 warnings, 4 checks, 2381 lines checked