CHECK: Prefer using the BIT_ULL macro #30: FILE: include/linux/bpf_verifier.h:1208: +#define BPF_MAP_KEY_POISON (1ULL << 63) CHECK: Prefer using the BIT_ULL macro #31: FILE: include/linux/bpf_verifier.h:1209: +#define BPF_MAP_KEY_SEEN (1ULL << 62) WARNING: line length of 104 exceeds 80 columns #87: FILE: include/linux/bpf_verifier.h:1265: +bool bpf_is_reg64(struct bpf_insn *insn, u32 regno, struct bpf_reg_state *reg, enum bpf_reg_arg_type t); WARNING: line length of 96 exceeds 80 columns #102: FILE: include/linux/bpf_verifier.h:1280: +int bpf_opt_subreg_zext_lo32_rnd_hi32(struct bpf_verifier_env *env, const union bpf_attr *attr); WARNING: line length of 88 exceeds 80 columns #214: FILE: kernel/bpf/fixups.c:88: +static int set_kfunc_desc_imm(struct bpf_verifier_env *env, struct bpf_kfunc_desc *desc) WARNING: line length of 86 exceeds 80 columns #224: FILE: kernel/bpf/fixups.c:98: + verbose(env, "address of kernel func_id %u is out of range\n", WARNING: line length of 95 exceeds 80 columns #275: FILE: kernel/bpf/fixups.c:149: + if (verifier_bug_if(subprog < 0, env, "get stack depth: no program at insn %d", start)) WARNING: line length of 81 exceeds 80 columns #314: FILE: kernel/bpf/fixups.c:188: +static void adjust_subprog_starts(struct bpf_verifier_env *env, u32 off, u32 len) WARNING: line length of 91 exceeds 80 columns #339: FILE: kernel/bpf/fixups.c:213: +static void adjust_insn_arrays_after_remove(struct bpf_verifier_env *env, u32 off, u32 len) WARNING: line length of 86 exceeds 80 columns #344: FILE: kernel/bpf/fixups.c:218: + bpf_insn_array_adjust_after_remove(env->insn_array_maps[i], off, len); WARNING: line length of 82 exceeds 80 columns #361: FILE: kernel/bpf/fixups.c:235: +static struct bpf_prog *bpf_patch_insn_data(struct bpf_verifier_env *env, u32 off, WARNING: line length of 82 exceeds 80 columns #362: FILE: kernel/bpf/fixups.c:236: + const struct bpf_insn *patch, u32 len) WARNING: line length of 81 exceeds 80 columns #370: FILE: kernel/bpf/fixups.c:244: + sizeof(struct bpf_insn_aux_data)), WARNING: line length of 83 exceeds 80 columns #410: FILE: kernel/bpf/fixups.c:284: + if ((BPF_CLASS(code) != BPF_JMP && BPF_CLASS(code) != BPF_JMP32) || WARNING: line length of 82 exceeds 80 columns #552: FILE: kernel/bpf/fixups.c:426: + * Clean up dynamically allocated fields of aux data for instructions [start, ...] WARNING: line length of 88 exceeds 80 columns #605: FILE: kernel/bpf/fixups.c:479: +static const struct bpf_insn MAY_GOTO_0 = BPF_RAW_INSN(BPF_JMP | BPF_JCOND, 0, 0, 0, 0); WARNING: line length of 83 exceeds 80 columns #679: FILE: kernel/bpf/fixups.c:553: + is_may_goto_0 = !memcmp(&insn[i], &MAY_GOTO_0, sizeof(MAY_GOTO_0)); WARNING: line length of 81 exceeds 80 columns #689: FILE: kernel/bpf/fixups.c:563: + /* Go back one insn to catch may_goto +1; may_goto +0 sequence */ CHECK: Alignment should match open parenthesis #697: FILE: kernel/bpf/fixups.c:571: +int bpf_opt_subreg_zext_lo32_rnd_hi32(struct bpf_verifier_env *env, + const union bpf_attr *attr) WARNING: line length of 81 exceeds 80 columns #819: FILE: kernel/bpf/fixups.c:693: + -(subprogs[0].stack_depth + 8)); WARNING: line length of 84 exceeds 80 columns #827: FILE: kernel/bpf/fixups.c:701: + insn_buf[cnt++] = BPF_STX_MEM(BPF_DW, BPF_REG_FP, BPF_REG_1, WARNING: line length of 86 exceeds 80 columns #836: FILE: kernel/bpf/fixups.c:710: + ret = add_kfunc_in_insns(env, epilogue_buf, epilogue_cnt - 1); WARNING: line length of 86 exceeds 80 columns #885: FILE: kernel/bpf/fixups.c:759: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); WARNING: line length of 84 exceeds 80 columns #921: FILE: kernel/bpf/fixups.c:795: + env->insn_aux_data[i + delta].ptr_type == PTR_TO_ARENA) { WARNING: line length of 87 exceeds 80 columns #922: FILE: kernel/bpf/fixups.c:796: + insn->code = BPF_STX | BPF_PROBE_ATOMIC | BPF_SIZE(insn->code); WARNING: line length of 81 exceeds 80 columns #930: FILE: kernel/bpf/fixups.c:804: + /* jump back to the earlier generated epilogue */ WARNING: line length of 88 exceeds 80 columns #931: FILE: kernel/bpf/fixups.c:805: + insn_buf[0] = BPF_JMP32_A(epilogue_idx - i - delta - 1); WARNING: line length of 86 exceeds 80 columns #958: FILE: kernel/bpf/fixups.c:832: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); WARNING: line length of 112 exceeds 80 columns #1007: FILE: kernel/bpf/fixups.c:881: + verbose(env, "sign extending loads from arena are not supported yet\n"); WARNING: line length of 110 exceeds 80 columns #1010: FILE: kernel/bpf/fixups.c:884: + insn->code = BPF_CLASS(insn->code) | BPF_PROBE_MEM32SX | BPF_SIZE(insn->code); WARNING: line length of 108 exceeds 80 columns #1012: FILE: kernel/bpf/fixups.c:886: + insn->code = BPF_CLASS(insn->code) | BPF_PROBE_MEM32 | BPF_SIZE(insn->code); WARNING: line length of 85 exceeds 80 columns #1036: FILE: kernel/bpf/fixups.c:910: + verifier_bug(env, "narrow ctx access misconfigured"); WARNING: line length of 90 exceeds 80 columns #1055: FILE: kernel/bpf/fixups.c:929: + verifier_bug(env, "error during ctx access conversion (%d)", cnt); CHECK: Lines should not end with a '(' #1060: FILE: kernel/bpf/fixups.c:934: + u8 shift = bpf_ctx_narrow_access_offset( WARNING: line length of 83 exceeds 80 columns #1063: FILE: kernel/bpf/fixups.c:937: + verifier_bug(env, "narrow ctx load misconfigured"); WARNING: line length of 86 exceeds 80 columns #1069: FILE: kernel/bpf/fixups.c:943: + insn->dst_reg, WARNING: line length of 87 exceeds 80 columns #1071: FILE: kernel/bpf/fixups.c:945: + insn_buf[cnt++] = BPF_ALU32_IMM(BPF_AND, insn->dst_reg, WARNING: line length of 85 exceeds 80 columns #1072: FILE: kernel/bpf/fixups.c:946: + (1 << size * 8) - 1); WARNING: line length of 86 exceeds 80 columns #1076: FILE: kernel/bpf/fixups.c:950: + insn->dst_reg, WARNING: line length of 87 exceeds 80 columns #1078: FILE: kernel/bpf/fixups.c:952: + insn_buf[cnt++] = BPF_ALU32_IMM(BPF_AND, insn->dst_reg, WARNING: line length of 88 exceeds 80 columns #1079: FILE: kernel/bpf/fixups.c:953: + (1ULL << size * 8) - 1); WARNING: line length of 83 exceeds 80 columns #1083: FILE: kernel/bpf/fixups.c:957: + insn_buf[cnt++] = BPF_RAW_INSN(BPF_ALU64 | BPF_MOV | BPF_X, WARNING: line length of 84 exceeds 80 columns #1084: FILE: kernel/bpf/fixups.c:958: + insn->dst_reg, insn->dst_reg, WARNING: line length of 85 exceeds 80 columns #1124: FILE: kernel/bpf/fixups.c:998: + if (verifier_bug_if(subprog < 0, env, "No program to jit at insn %d", WARNING: line length of 81 exceeds 80 columns #1168: FILE: kernel/bpf/fixups.c:1042: + * subprogs don't have IDs and not reachable via prog_get_next_id WARNING: line length of 87 exceeds 80 columns #1185: FILE: kernel/bpf/fixups.c:1059: + func[i]->aux->subprog_start = subprog_start + subprog_start_adjustment; CHECK: Alignment should match open parenthesis #1231: FILE: kernel/bpf/fixups.c:1105: + if (BPF_CLASS(insn->code) == BPF_STX && + BPF_MODE(insn->code) == BPF_PROBE_ATOMIC) WARNING: line length of 93 exceeds 80 columns #1235: FILE: kernel/bpf/fixups.c:1109: + func[i]->aux->tail_call_reachable = env->subprog_info[i].tail_call_reachable; WARNING: line length of 82 exceeds 80 columns #1236: FILE: kernel/bpf/fixups.c:1110: + func[i]->aux->exception_cb = env->subprog_info[i].is_exception_cb; WARNING: line length of 87 exceeds 80 columns #1237: FILE: kernel/bpf/fixups.c:1111: + func[i]->aux->changes_pkt_data = env->subprog_info[i].changes_pkt_data; WARNING: ENOTSUPP is not a SUSV4 error code, prefer EOPNOTSUPP #1251: FILE: kernel/bpf/fixups.c:1125: + err = -ENOTSUPP; WARNING: line length of 81 exceeds 80 columns #1266: FILE: kernel/bpf/fixups.c:1140: + insn[0].imm = (u32)(long)func[subprog]->bpf_func; WARNING: line length of 89 exceeds 80 columns #1267: FILE: kernel/bpf/fixups.c:1141: + insn[1].imm = ((u64)(long)func[subprog]->bpf_func) >> 32; WARNING: line length of 84 exceeds 80 columns #1288: FILE: kernel/bpf/fixups.c:1162: + func[i]->aux->func_cnt = env->subprog_cnt - env->hidden_subprog_cnt; WARNING: ENOTSUPP is not a SUSV4 error code, prefer EOPNOTSUPP #1296: FILE: kernel/bpf/fixups.c:1170: + err = -ENOTSUPP; WARNING: line length of 94 exceeds 80 columns #1350: FILE: kernel/bpf/fixups.c:1224: + prog->aux->bpf_exception_cb = (void *)func[env->exception_callback_subprog]->bpf_func; WARNING: line length of 97 exceeds 80 columns #1408: FILE: kernel/bpf/fixups.c:1282: + verbose(env, "calling kernel functions are not allowed in non-JITed programs\n"); WARNING: line length of 83 exceeds 80 columns #1413: FILE: kernel/bpf/fixups.c:1287: + * have to be rejected, since interpreter doesn't support them yet. WARNING: line length of 105 exceeds 80 columns #1415: FILE: kernel/bpf/fixups.c:1289: + verbose(env, "tail_calls are not allowed in non-JITed programs with bpf-to-bpf calls\n"); WARNING: line length of 91 exceeds 80 columns #1421: FILE: kernel/bpf/fixups.c:1295: + * have to be rejected, since interpreter doesn't support them yet. WARNING: line length of 90 exceeds 80 columns #1423: FILE: kernel/bpf/fixups.c:1297: + verbose(env, "callbacks are not allowed in non-JITed programs\n"); CHECK: Please don't use multiple blank lines #1439: FILE: kernel/bpf/fixups.c:1313: + + WARNING: line length of 86 exceeds 80 columns #1440: FILE: kernel/bpf/fixups.c:1314: +/* The function requires that first instruction in 'patch' is insnsi[prog->len - 1] */ WARNING: line length of 92 exceeds 80 columns #1441: FILE: kernel/bpf/fixups.c:1315: +static int add_hidden_subprog(struct bpf_verifier_env *env, struct bpf_insn *patch, int len) WARNING: line length of 87 exceeds 80 columns #1501: FILE: kernel/bpf/fixups.c:1375: + /* Don't update insn_cnt, as add_hidden_subprog always appends insns */ WARNING: line length of 83 exceeds 80 columns #1507: FILE: kernel/bpf/fixups.c:1381: + if ((insn->off == BPF_ADDR_SPACE_CAST && insn->imm == 1) || WARNING: line length of 106 exceeds 80 columns #1508: FILE: kernel/bpf/fixups.c:1382: + (((struct bpf_map *)env->prog->aux->arena)->map_flags & BPF_F_NO_USER_CONV)) { WARNING: line length of 84 exceeds 80 columns #1509: FILE: kernel/bpf/fixups.c:1383: + /* convert to 32-bit mov that clears upper 32-bit */ WARNING: line length of 96 exceeds 80 columns #1511: FILE: kernel/bpf/fixups.c:1385: + /* clear off and imm, so it's a normal 'wX = wY' from JIT pov */ WARNING: line length of 81 exceeds 80 columns #1514: FILE: kernel/bpf/fixups.c:1388: + } /* cast from as(0) to as(1) should be handled by JIT */ WARNING: line length of 86 exceeds 80 columns #1519: FILE: kernel/bpf/fixups.c:1393: + /* Convert BPF_CLASS(insn->code) == BPF_ALU64 to 32-bit ALU */ WARNING: line length of 88 exceeds 80 columns #1520: FILE: kernel/bpf/fixups.c:1394: + insn->code = BPF_ALU | BPF_OP(insn->code) | BPF_SRC(insn->code); WARNING: line length of 86 exceeds 80 columns #1533: FILE: kernel/bpf/fixups.c:1407: + *patch++ = BPF_RAW_INSN((is64 ? BPF_ALU64 : BPF_ALU) | WARNING: line length of 87 exceeds 80 columns #1534: FILE: kernel/bpf/fixups.c:1408: + BPF_NEG | BPF_K, insn->dst_reg, WARNING: line length of 86 exceeds 80 columns #1541: FILE: kernel/bpf/fixups.c:1415: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #1546: FILE: kernel/bpf/fixups.c:1420: + env->prog = prog = new_prog; WARNING: line length of 88 exceeds 80 columns #1551: FILE: kernel/bpf/fixups.c:1425: + /* Make divide-by-zero and divide-by-minus-one exceptions impossible. */ WARNING: line length of 84 exceeds 80 columns #1567: FILE: kernel/bpf/fixups.c:1441: + *patch++ = BPF_MOV64_REG(BPF_REG_AX, insn->src_reg); WARNING: line length of 86 exceeds 80 columns #1568: FILE: kernel/bpf/fixups.c:1442: + *patch++ = BPF_RAW_INSN((is64 ? BPF_ALU64 : BPF_ALU) | WARNING: line length of 84 exceeds 80 columns #1569: FILE: kernel/bpf/fixups.c:1443: + BPF_ADD | BPF_K, BPF_REG_AX, WARNING: line length of 86 exceeds 80 columns #1571: FILE: kernel/bpf/fixups.c:1445: + *patch++ = BPF_RAW_INSN((is64 ? BPF_JMP : BPF_JMP32) | WARNING: line length of 84 exceeds 80 columns #1572: FILE: kernel/bpf/fixups.c:1446: + BPF_JGT | BPF_K, BPF_REG_AX, WARNING: line length of 86 exceeds 80 columns #1574: FILE: kernel/bpf/fixups.c:1448: + *patch++ = BPF_RAW_INSN((is64 ? BPF_JMP : BPF_JMP32) | WARNING: line length of 84 exceeds 80 columns #1575: FILE: kernel/bpf/fixups.c:1449: + BPF_JEQ | BPF_K, BPF_REG_AX, WARNING: line length of 86 exceeds 80 columns #1577: FILE: kernel/bpf/fixups.c:1451: + *patch++ = BPF_RAW_INSN((is64 ? BPF_ALU64 : BPF_ALU) | WARNING: line length of 87 exceeds 80 columns #1578: FILE: kernel/bpf/fixups.c:1452: + BPF_MOV | BPF_K, insn->dst_reg, WARNING: line length of 83 exceeds 80 columns #1580: FILE: kernel/bpf/fixups.c:1454: + /* BPF_NEG(LLONG_MIN) == -LLONG_MIN == LLONG_MIN */ WARNING: line length of 86 exceeds 80 columns #1581: FILE: kernel/bpf/fixups.c:1455: + *patch++ = BPF_RAW_INSN((is64 ? BPF_ALU64 : BPF_ALU) | WARNING: line length of 87 exceeds 80 columns #1582: FILE: kernel/bpf/fixups.c:1456: + BPF_NEG | BPF_K, insn->dst_reg, WARNING: line length of 84 exceeds 80 columns #1590: FILE: kernel/bpf/fixups.c:1464: + *patch++ = BPF_MOV64_REG(BPF_REG_AX, insn->src_reg); WARNING: line length of 86 exceeds 80 columns #1591: FILE: kernel/bpf/fixups.c:1465: + *patch++ = BPF_RAW_INSN((is64 ? BPF_ALU64 : BPF_ALU) | WARNING: line length of 84 exceeds 80 columns #1592: FILE: kernel/bpf/fixups.c:1466: + BPF_ADD | BPF_K, BPF_REG_AX, WARNING: line length of 86 exceeds 80 columns #1594: FILE: kernel/bpf/fixups.c:1468: + *patch++ = BPF_RAW_INSN((is64 ? BPF_JMP : BPF_JMP32) | WARNING: line length of 84 exceeds 80 columns #1595: FILE: kernel/bpf/fixups.c:1469: + BPF_JGT | BPF_K, BPF_REG_AX, WARNING: line length of 86 exceeds 80 columns #1597: FILE: kernel/bpf/fixups.c:1471: + *patch++ = BPF_RAW_INSN((is64 ? BPF_JMP : BPF_JMP32) | WARNING: line length of 84 exceeds 80 columns #1598: FILE: kernel/bpf/fixups.c:1472: + BPF_JEQ | BPF_K, BPF_REG_AX, WARNING: line length of 82 exceeds 80 columns #1599: FILE: kernel/bpf/fixups.c:1473: + 0, 3 + (is64 ? 0 : 1), 1); WARNING: line length of 95 exceeds 80 columns #1606: FILE: kernel/bpf/fixups.c:1480: + *patch++ = BPF_MOV32_REG(insn->dst_reg, insn->dst_reg); WARNING: line length of 86 exceeds 80 columns #1611: FILE: kernel/bpf/fixups.c:1485: + *patch++ = BPF_RAW_INSN((is64 ? BPF_JMP : BPF_JMP32) | WARNING: line length of 87 exceeds 80 columns #1612: FILE: kernel/bpf/fixups.c:1486: + BPF_JNE | BPF_K, insn->src_reg, WARNING: line length of 96 exceeds 80 columns #1614: FILE: kernel/bpf/fixups.c:1488: + *patch++ = BPF_ALU32_REG(BPF_XOR, insn->dst_reg, insn->dst_reg); WARNING: line length of 86 exceeds 80 columns #1620: FILE: kernel/bpf/fixups.c:1494: + *patch++ = BPF_RAW_INSN((is64 ? BPF_JMP : BPF_JMP32) | WARNING: line length of 87 exceeds 80 columns #1621: FILE: kernel/bpf/fixups.c:1495: + BPF_JEQ | BPF_K, insn->src_reg, WARNING: line length of 82 exceeds 80 columns #1622: FILE: kernel/bpf/fixups.c:1496: + 0, 1 + (is64 ? 0 : 1), 0); WARNING: line length of 95 exceeds 80 columns #1627: FILE: kernel/bpf/fixups.c:1501: + *patch++ = BPF_MOV32_REG(insn->dst_reg, insn->dst_reg); WARNING: line length of 86 exceeds 80 columns #1632: FILE: kernel/bpf/fixups.c:1506: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #1637: FILE: kernel/bpf/fixups.c:1511: + env->prog = prog = new_prog; WARNING: line length of 89 exceeds 80 columns #1654: FILE: kernel/bpf/fixups.c:1528: + *patch++ = BPF_ALU64_IMM(BPF_ADD, BPF_REG_AX, insn->off); WARNING: line length of 93 exceeds 80 columns #1656: FILE: kernel/bpf/fixups.c:1530: + *patch++ = BPF_JMP_IMM(BPF_JLE, BPF_REG_AX, uaddress_limit >> 32, 2); WARNING: line length of 86 exceeds 80 columns #1662: FILE: kernel/bpf/fixups.c:1536: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #1667: FILE: kernel/bpf/fixups.c:1541: + env->prog = prog = new_prog; WARNING: line length of 99 exceeds 80 columns #1672: FILE: kernel/bpf/fixups.c:1546: + /* Implement LD_ABS and LD_IND with a rewrite, if supported by the program type. */ WARNING: line length of 88 exceeds 80 columns #1678: FILE: kernel/bpf/fixups.c:1552: + verifier_bug(env, "%d insns generated for ld_abs", cnt); WARNING: line length of 86 exceeds 80 columns #1682: FILE: kernel/bpf/fixups.c:1556: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #1687: FILE: kernel/bpf/fixups.c:1561: + env->prog = prog = new_prog; WARNING: line length of 81 exceeds 80 columns #1692: FILE: kernel/bpf/fixups.c:1566: + /* Rewrite pointer arithmetic to mitigate speculation attacks. */ WARNING: line length of 85 exceeds 80 columns #1713: FILE: kernel/bpf/fixups.c:1587: + *patch++ = BPF_MOV32_IMM(BPF_REG_AX, aux->alu_limit); WARNING: line length of 87 exceeds 80 columns #1716: FILE: kernel/bpf/fixups.c:1590: + *patch++ = BPF_ALU64_IMM(BPF_MUL, off_reg, -1); WARNING: line length of 85 exceeds 80 columns #1717: FILE: kernel/bpf/fixups.c:1591: + *patch++ = BPF_MOV32_IMM(BPF_REG_AX, aux->alu_limit); WARNING: line length of 87 exceeds 80 columns #1718: FILE: kernel/bpf/fixups.c:1592: + *patch++ = BPF_ALU64_REG(BPF_SUB, BPF_REG_AX, off_reg); WARNING: line length of 86 exceeds 80 columns #1719: FILE: kernel/bpf/fixups.c:1593: + *patch++ = BPF_ALU64_REG(BPF_OR, BPF_REG_AX, off_reg); WARNING: line length of 81 exceeds 80 columns #1720: FILE: kernel/bpf/fixups.c:1594: + *patch++ = BPF_ALU64_IMM(BPF_NEG, BPF_REG_AX, 0); WARNING: line length of 83 exceeds 80 columns #1721: FILE: kernel/bpf/fixups.c:1595: + *patch++ = BPF_ALU64_IMM(BPF_ARSH, BPF_REG_AX, 63); WARNING: line length of 87 exceeds 80 columns #1722: FILE: kernel/bpf/fixups.c:1596: + *patch++ = BPF_ALU64_REG(BPF_AND, BPF_REG_AX, off_reg); WARNING: line length of 87 exceeds 80 columns #1725: FILE: kernel/bpf/fixups.c:1599: + *patch++ = BPF_MOV64_REG(insn->dst_reg, insn->src_reg); WARNING: line length of 86 exceeds 80 columns #1735: FILE: kernel/bpf/fixups.c:1609: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #1740: FILE: kernel/bpf/fixups.c:1614: + env->prog = prog = new_prog; WARNING: line length of 86 exceeds 80 columns #1745: FILE: kernel/bpf/fixups.c:1619: + if (bpf_is_may_goto_insn(insn) && bpf_jit_supports_timed_may_goto()) { WARNING: line length of 97 exceeds 80 columns #1763: FILE: kernel/bpf/fixups.c:1637: + insn_buf[0] = BPF_LDX_MEM(BPF_DW, BPF_REG_AX, BPF_REG_10, stack_off_cnt); WARNING: line length of 97 exceeds 80 columns #1765: FILE: kernel/bpf/fixups.c:1639: + insn_buf[1] = BPF_JMP_IMM(BPF_JEQ, BPF_REG_AX, 0, insn->off + 5); WARNING: line length of 97 exceeds 80 columns #1767: FILE: kernel/bpf/fixups.c:1641: + insn_buf[1] = BPF_JMP_IMM(BPF_JEQ, BPF_REG_AX, 0, insn->off - 1); WARNING: line length of 97 exceeds 80 columns #1777: FILE: kernel/bpf/fixups.c:1651: + insn_buf[6] = BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_AX, stack_off_cnt); WARNING: line length of 86 exceeds 80 columns #1780: FILE: kernel/bpf/fixups.c:1654: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #1785: FILE: kernel/bpf/fixups.c:1659: + env->prog = prog = new_prog; WARNING: line length of 93 exceeds 80 columns #1792: FILE: kernel/bpf/fixups.c:1666: + insn_buf[0] = BPF_LDX_MEM(BPF_DW, BPF_REG_AX, BPF_REG_10, stack_off); WARNING: line length of 97 exceeds 80 columns #1794: FILE: kernel/bpf/fixups.c:1668: + insn_buf[1] = BPF_JMP_IMM(BPF_JEQ, BPF_REG_AX, 0, insn->off + 2); WARNING: line length of 97 exceeds 80 columns #1796: FILE: kernel/bpf/fixups.c:1670: + insn_buf[1] = BPF_JMP_IMM(BPF_JEQ, BPF_REG_AX, 0, insn->off - 1); WARNING: line length of 93 exceeds 80 columns #1798: FILE: kernel/bpf/fixups.c:1672: + insn_buf[3] = BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_AX, stack_off); WARNING: line length of 86 exceeds 80 columns #1801: FILE: kernel/bpf/fixups.c:1675: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #1806: FILE: kernel/bpf/fixups.c:1680: + env->prog = prog = new_prog; WARNING: line length of 89 exceeds 80 columns #1816: FILE: kernel/bpf/fixups.c:1690: + ret = bpf_fixup_kfunc_call(env, insn, insn_buf, i + delta, &cnt); WARNING: line length of 86 exceeds 80 columns #1822: FILE: kernel/bpf/fixups.c:1696: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #1827: FILE: kernel/bpf/fixups.c:1701: + env->prog = prog = new_prog; WARNING: line length of 81 exceeds 80 columns #1854: FILE: kernel/bpf/fixups.c:1728: + * conditional branch in the interpreter for every normal WARNING: line length of 84 exceeds 80 columns #1869: FILE: kernel/bpf/fixups.c:1743: + .tail_call.map = aux->map_ptr_state.map_ptr, WARNING: line length of 84 exceeds 80 columns #1870: FILE: kernel/bpf/fixups.c:1744: + .tail_call.key = bpf_map_key_immediate(aux), WARNING: line length of 98 exceeds 80 columns #1876: FILE: kernel/bpf/fixups.c:1750: + verbose(env, "adding tail call poke descriptor failed\n"); WARNING: line length of 82 exceeds 80 columns #1903: FILE: kernel/bpf/fixups.c:1777: + struct bpf_array, WARNING: line length of 83 exceeds 80 columns #1904: FILE: kernel/bpf/fixups.c:1778: + map)->index_mask); WARNING: line length of 86 exceeds 80 columns #1907: FILE: kernel/bpf/fixups.c:1781: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #1912: FILE: kernel/bpf/fixups.c:1786: + env->prog = prog = new_prog; WARNING: line length of 91 exceeds 80 columns #1918: FILE: kernel/bpf/fixups.c:1792: + /* The verifier will process callback_fn as many times as necessary WARNING: line length of 82 exceeds 80 columns #1919: FILE: kernel/bpf/fixups.c:1793: + * with different maps and the register states prepared by WARNING: line length of 87 exceeds 80 columns #1925: FILE: kernel/bpf/fixups.c:1799: + * prog2 calls bpf_timer_set_callback for some map1 elements. WARNING: line length of 89 exceeds 80 columns #1926: FILE: kernel/bpf/fixups.c:1800: + * Those that were not bpf_timer_init-ed will return -EINVAL. WARNING: line length of 86 exceeds 80 columns #1940: FILE: kernel/bpf/fixups.c:1814: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #1945: FILE: kernel/bpf/fixups.c:1819: + env->prog = prog = new_prog; WARNING: line length of 84 exceeds 80 columns #1952: FILE: kernel/bpf/fixups.c:1826: + /* patch with 'r1 = *(u64 *)(r1 + 0)' since for percpu data, WARNING: line length of 83 exceeds 80 columns #1955: FILE: kernel/bpf/fixups.c:1829: + insn_buf[0] = BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_1, 0); WARNING: line length of 86 exceeds 80 columns #1959: FILE: kernel/bpf/fixups.c:1833: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #1964: FILE: kernel/bpf/fixups.c:1838: + env->prog = prog = new_prog; WARNING: line length of 100 exceeds 80 columns #1995: FILE: kernel/bpf/fixups.c:1869: + verifier_bug(env, "%d insns generated for map lookup", cnt); CHECK: multiple assignments should be avoided #2005: FILE: kernel/bpf/fixups.c:1879: + env->prog = prog = new_prog; WARNING: line length of 87 exceeds 80 columns #2011: FILE: kernel/bpf/fixups.c:1885: + (void *(*)(struct bpf_map *map, void *key))NULL)); CHECK: Alignment should match open parenthesis #2011: FILE: kernel/bpf/fixups.c:1885: + BUILD_BUG_ON(!__same_type(ops->map_lookup_elem, + (void *(*)(struct bpf_map *map, void *key))NULL)); WARNING: line length of 86 exceeds 80 columns #2013: FILE: kernel/bpf/fixups.c:1887: + (long (*)(struct bpf_map *map, void *key))NULL)); CHECK: Alignment should match open parenthesis #2013: FILE: kernel/bpf/fixups.c:1887: + BUILD_BUG_ON(!__same_type(ops->map_delete_elem, + (long (*)(struct bpf_map *map, void *key))NULL)); WARNING: line length of 91 exceeds 80 columns #2015: FILE: kernel/bpf/fixups.c:1889: + (long (*)(struct bpf_map *map, void *key, void *value, CHECK: Alignment should match open parenthesis #2015: FILE: kernel/bpf/fixups.c:1889: + BUILD_BUG_ON(!__same_type(ops->map_update_elem, + (long (*)(struct bpf_map *map, void *key, void *value, CHECK: Alignment should match open parenthesis #2018: FILE: kernel/bpf/fixups.c:1892: + BUILD_BUG_ON(!__same_type(ops->map_push_elem, + (long (*)(struct bpf_map *map, void *value, WARNING: line length of 88 exceeds 80 columns #2021: FILE: kernel/bpf/fixups.c:1895: + (long (*)(struct bpf_map *map, void *value))NULL)); CHECK: Alignment should match open parenthesis #2021: FILE: kernel/bpf/fixups.c:1895: + BUILD_BUG_ON(!__same_type(ops->map_pop_elem, + (long (*)(struct bpf_map *map, void *value))NULL)); WARNING: line length of 88 exceeds 80 columns #2023: FILE: kernel/bpf/fixups.c:1897: + (long (*)(struct bpf_map *map, void *value))NULL)); CHECK: Alignment should match open parenthesis #2023: FILE: kernel/bpf/fixups.c:1897: + BUILD_BUG_ON(!__same_type(ops->map_peek_elem, + (long (*)(struct bpf_map *map, void *value))NULL)); WARNING: line length of 97 exceeds 80 columns #2025: FILE: kernel/bpf/fixups.c:1899: + (long (*)(struct bpf_map *map, u64 index, u64 flags))NULL)); CHECK: Alignment should match open parenthesis #2025: FILE: kernel/bpf/fixups.c:1899: + BUILD_BUG_ON(!__same_type(ops->map_redirect, + (long (*)(struct bpf_map *map, u64 index, u64 flags))NULL)); CHECK: Alignment should match open parenthesis #2027: FILE: kernel/bpf/fixups.c:1901: + BUILD_BUG_ON(!__same_type(ops->map_for_each_callback, + (long (*)(struct bpf_map *map, WARNING: line length of 96 exceeds 80 columns #2032: FILE: kernel/bpf/fixups.c:1906: + (void *(*)(struct bpf_map *map, void *key, u32 cpu))NULL)); CHECK: Alignment should match open parenthesis #2032: FILE: kernel/bpf/fixups.c:1906: + BUILD_BUG_ON(!__same_type(ops->map_lookup_percpu_elem, + (void *(*)(struct bpf_map *map, void *key, u32 cpu))NULL)); WARNING: line length of 85 exceeds 80 columns #2058: FILE: kernel/bpf/fixups.c:1932: + insn->imm = BPF_CALL_IMM(ops->map_for_each_callback); WARNING: line length of 86 exceeds 80 columns #2061: FILE: kernel/bpf/fixups.c:1935: + insn->imm = BPF_CALL_IMM(ops->map_lookup_percpu_elem); CHECK: multiple assignments should be avoided #2088: FILE: kernel/bpf/fixups.c:1962: + env->prog = prog = new_prog; WARNING: line length of 96 exceeds 80 columns #2103: FILE: kernel/bpf/fixups.c:1977: + insn_buf[0] = BPF_MOV64_IMM(BPF_REG_0, (u32)(unsigned long)&cpu_number); WARNING: line length of 81 exceeds 80 columns #2104: FILE: kernel/bpf/fixups.c:1978: + insn_buf[1] = BPF_MOV64_PERCPU_REG(BPF_REG_0, BPF_REG_0); WARNING: line length of 82 exceeds 80 columns #2105: FILE: kernel/bpf/fixups.c:1979: + insn_buf[2] = BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_0, 0); WARNING: line length of 83 exceeds 80 columns #2108: FILE: kernel/bpf/fixups.c:1982: + insn_buf[0] = BPF_ALU32_REG(BPF_XOR, BPF_REG_0, BPF_REG_0); WARNING: line length of 86 exceeds 80 columns #2111: FILE: kernel/bpf/fixups.c:1985: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #2116: FILE: kernel/bpf/fixups.c:1990: + env->prog = prog = new_prog; WARNING: line length of 93 exceeds 80 columns #2121: FILE: kernel/bpf/fixups.c:1995: + /* Implement bpf_get_current_task() and bpf_get_current_task_btf() inline. */ WARNING: line length of 109 exceeds 80 columns #2122: FILE: kernel/bpf/fixups.c:1996: + if ((insn->imm == BPF_FUNC_get_current_task || insn->imm == BPF_FUNC_get_current_task_btf) && WARNING: line length of 98 exceeds 80 columns #2124: FILE: kernel/bpf/fixups.c:1998: + insn_buf[0] = BPF_MOV64_IMM(BPF_REG_0, (u32)(unsigned long)¤t_task); WARNING: line length of 81 exceeds 80 columns #2125: FILE: kernel/bpf/fixups.c:1999: + insn_buf[1] = BPF_MOV64_PERCPU_REG(BPF_REG_0, BPF_REG_0); WARNING: line length of 83 exceeds 80 columns #2126: FILE: kernel/bpf/fixups.c:2000: + insn_buf[2] = BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0); WARNING: line length of 86 exceeds 80 columns #2129: FILE: kernel/bpf/fixups.c:2003: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #2134: FILE: kernel/bpf/fixups.c:2008: + env->prog = prog = new_prog; WARNING: line length of 90 exceeds 80 columns #2143: FILE: kernel/bpf/fixups.c:2017: + int nr_args = btf_type_vlen(prog->aux->attach_func_proto); WARNING: line length of 96 exceeds 80 columns #2145: FILE: kernel/bpf/fixups.c:2019: + /* skip 'void *__data' in btf_trace_##name() and save to reg0 */ WARNING: line length of 84 exceeds 80 columns #2146: FILE: kernel/bpf/fixups.c:2020: + insn_buf[0] = BPF_MOV64_IMM(BPF_REG_0, nr_args - 1); WARNING: line length of 92 exceeds 80 columns #2150: FILE: kernel/bpf/fixups.c:2024: + insn_buf[0] = BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8); WARNING: line length of 86 exceeds 80 columns #2151: FILE: kernel/bpf/fixups.c:2025: + insn_buf[1] = BPF_ALU64_IMM(BPF_AND, BPF_REG_0, 0xFF); WARNING: line length of 90 exceeds 80 columns #2154: FILE: kernel/bpf/fixups.c:2028: + insn_buf[cnt++] = BPF_JMP32_REG(BPF_JGE, BPF_REG_2, BPF_REG_0, 6); WARNING: line length of 87 exceeds 80 columns #2156: FILE: kernel/bpf/fixups.c:2030: + insn_buf[cnt++] = BPF_ALU64_REG(BPF_ADD, BPF_REG_2, BPF_REG_1); WARNING: line length of 87 exceeds 80 columns #2157: FILE: kernel/bpf/fixups.c:2031: + insn_buf[cnt++] = BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_2, 0); WARNING: line length of 87 exceeds 80 columns #2158: FILE: kernel/bpf/fixups.c:2032: + insn_buf[cnt++] = BPF_STX_MEM(BPF_DW, BPF_REG_3, BPF_REG_0, 0); WARNING: line length of 86 exceeds 80 columns #2163: FILE: kernel/bpf/fixups.c:2037: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #2168: FILE: kernel/bpf/fixups.c:2042: + env->prog = prog = new_prog; WARNING: line length of 92 exceeds 80 columns #2180: FILE: kernel/bpf/fixups.c:2054: + insn_buf[0] = BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8); WARNING: line length of 86 exceeds 80 columns #2181: FILE: kernel/bpf/fixups.c:2055: + insn_buf[1] = BPF_ALU64_IMM(BPF_AND, BPF_REG_0, 0xFF); WARNING: line length of 83 exceeds 80 columns #2182: FILE: kernel/bpf/fixups.c:2056: + insn_buf[2] = BPF_ALU64_IMM(BPF_LSH, BPF_REG_0, 3); WARNING: line length of 91 exceeds 80 columns #2183: FILE: kernel/bpf/fixups.c:2057: + insn_buf[3] = BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1); WARNING: line length of 91 exceeds 80 columns #2184: FILE: kernel/bpf/fixups.c:2058: + insn_buf[4] = BPF_LDX_MEM(BPF_DW, BPF_REG_3, BPF_REG_0, 0); WARNING: line length of 91 exceeds 80 columns #2185: FILE: kernel/bpf/fixups.c:2059: + insn_buf[5] = BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_3, 0); WARNING: line length of 84 exceeds 80 columns #2189: FILE: kernel/bpf/fixups.c:2063: + insn_buf[0] = BPF_MOV64_IMM(BPF_REG_0, -EOPNOTSUPP); WARNING: line length of 86 exceeds 80 columns #2193: FILE: kernel/bpf/fixups.c:2067: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #2198: FILE: kernel/bpf/fixups.c:2072: + env->prog = prog = new_prog; WARNING: line length of 90 exceeds 80 columns #2207: FILE: kernel/bpf/fixups.c:2081: + int nr_args = btf_type_vlen(prog->aux->attach_func_proto); WARNING: line length of 96 exceeds 80 columns #2209: FILE: kernel/bpf/fixups.c:2083: + /* skip 'void *__data' in btf_trace_##name() and save to reg0 */ WARNING: line length of 84 exceeds 80 columns #2210: FILE: kernel/bpf/fixups.c:2084: + insn_buf[0] = BPF_MOV64_IMM(BPF_REG_0, nr_args - 1); WARNING: line length of 92 exceeds 80 columns #2214: FILE: kernel/bpf/fixups.c:2088: + insn_buf[0] = BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8); WARNING: line length of 86 exceeds 80 columns #2215: FILE: kernel/bpf/fixups.c:2089: + insn_buf[1] = BPF_ALU64_IMM(BPF_AND, BPF_REG_0, 0xFF); WARNING: line length of 86 exceeds 80 columns #2219: FILE: kernel/bpf/fixups.c:2093: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #2224: FILE: kernel/bpf/fixups.c:2098: + env->prog = prog = new_prog; WARNING: line length of 85 exceeds 80 columns #2233: FILE: kernel/bpf/fixups.c:2107: + insn_buf[0] = BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -16); WARNING: line length of 84 exceeds 80 columns #2235: FILE: kernel/bpf/fixups.c:2109: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, 1); CHECK: multiple assignments should be avoided #2239: FILE: kernel/bpf/fixups.c:2113: + env->prog = prog = new_prog; WARNING: line length of 87 exceeds 80 columns #2249: FILE: kernel/bpf/fixups.c:2123: + * u64 bpf_get_branch_snapshot(void *buf, u32 size, u64 flags); WARNING: line length of 102 exceeds 80 columns #2250: FILE: kernel/bpf/fixups.c:2124: + * int perf_snapshot_branch_stack(struct perf_branch_entry *entries, u32 cnt); WARNING: line length of 83 exceeds 80 columns #2252: FILE: kernel/bpf/fixups.c:2126: + const u32 br_entry_size = sizeof(struct perf_branch_entry); WARNING: line length of 91 exceeds 80 columns #2263: FILE: kernel/bpf/fixups.c:2137: + /* Transform size (bytes) into number of entries (cnt = size / 24). WARNING: line length of 84 exceeds 80 columns #2264: FILE: kernel/bpf/fixups.c:2138: + * But to avoid expensive division instruction, we implement WARNING: line length of 82 exceeds 80 columns #2265: FILE: kernel/bpf/fixups.c:2139: + * divide-by-3 through multiplication, followed by further WARNING: line length of 93 exceeds 80 columns #2267: FILE: kernel/bpf/fixups.c:2141: + * Refer to book "Hacker's Delight, 2nd ed." by Henry S. Warren, Jr., WARNING: line length of 91 exceeds 80 columns #2268: FILE: kernel/bpf/fixups.c:2142: + * p. 227, chapter "Unsigned Division by 3" for details and proofs. WARNING: line length of 89 exceeds 80 columns #2270: FILE: kernel/bpf/fixups.c:2144: + * N / 3 <=> M * N / 2^33, where M = (2^33 + 1) / 3 = 0xaaaaaaab. WARNING: line length of 83 exceeds 80 columns #2273: FILE: kernel/bpf/fixups.c:2147: + insn_buf[2] = BPF_ALU64_REG(BPF_MUL, BPF_REG_2, BPF_REG_0); WARNING: line length of 99 exceeds 80 columns #2277: FILE: kernel/bpf/fixups.c:2151: + insn_buf[4] = BPF_EMIT_CALL(static_call_query(perf_snapshot_branch_stack)); WARNING: line length of 81 exceeds 80 columns #2280: FILE: kernel/bpf/fixups.c:2154: + /* return entry_cnt * sizeof(struct perf_branch_entry) */ WARNING: line length of 87 exceeds 80 columns #2281: FILE: kernel/bpf/fixups.c:2155: + insn_buf[6] = BPF_ALU32_IMM(BPF_MUL, BPF_REG_0, br_entry_size); WARNING: line length of 86 exceeds 80 columns #2290: FILE: kernel/bpf/fixups.c:2164: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #2295: FILE: kernel/bpf/fixups.c:2169: + env->prog = prog = new_prog; WARNING: line length of 95 exceeds 80 columns #2305: FILE: kernel/bpf/fixups.c:2179: + insn_buf[1] = BPF_ATOMIC_OP(BPF_DW, BPF_XCHG, BPF_REG_1, BPF_REG_0, 0); WARNING: line length of 86 exceeds 80 columns #2308: FILE: kernel/bpf/fixups.c:2182: + new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); CHECK: multiple assignments should be avoided #2313: FILE: kernel/bpf/fixups.c:2187: + env->prog = prog = new_prog; WARNING: line length of 82 exceeds 80 columns #2335: FILE: kernel/bpf/fixups.c:2209: + if (stack_depth > MAX_BPF_STACK && !prog->jit_requested) { WARNING: line length of 86 exceeds 80 columns #2336: FILE: kernel/bpf/fixups.c:2210: + verbose(env, "stack size %d(extra %d) is too large\n", WARNING: line length of 86 exceeds 80 columns #2365: FILE: kernel/bpf/fixups.c:2239: + insn_buf[cnt++] = BPF_ST_MEM(BPF_DW, BPF_REG_FP, -stack_depth, WARNING: line length of 94 exceeds 80 columns #2367: FILE: kernel/bpf/fixups.c:2241: + insn_buf[cnt++] = BPF_ST_MEM(BPF_DW, BPF_REG_FP, -stack_depth + 8, 0); WARNING: line length of 81 exceeds 80 columns #2369: FILE: kernel/bpf/fixups.c:2243: + /* Add ST insn to subprog prologue to init extra stack */ WARNING: line length of 86 exceeds 80 columns #2370: FILE: kernel/bpf/fixups.c:2244: + insn_buf[cnt++] = BPF_ST_MEM(BPF_DW, BPF_REG_FP, -stack_depth, WARNING: line length of 82 exceeds 80 columns #2376: FILE: kernel/bpf/fixups.c:2250: + new_prog = bpf_patch_insn_data(env, subprog_start, insn_buf, cnt); CHECK: multiple assignments should be avoided #2379: FILE: kernel/bpf/fixups.c:2253: + env->prog = prog = new_prog; WARNING: line length of 85 exceeds 80 columns #2384: FILE: kernel/bpf/fixups.c:2258: + * Adjustment will succeed because bpf_patch_insn_data() didn't fail. WARNING: line length of 83 exceeds 80 columns #2522: FILE: kernel/bpf/fixups.c:2396: + stack_depth_extra = BPF_REG_SIZE * 3 + stack_depth_roundup; WARNING: line length of 86 exceeds 80 columns #2525: FILE: kernel/bpf/fixups.c:2399: + -(stack_depth + stack_depth_extra), WARNING: line length of 84 exceeds 80 columns #2526: FILE: kernel/bpf/fixups.c:2400: + inline_state->callback_subprogno, WARNING: line length of 85 exceeds 80 columns #2540: FILE: kernel/bpf/fixups.c:2414: + stack_depth_roundup = round_up(stack_depth, 8) - stack_depth; WARNING: line length of 84 exceeds 80 columns #2575: FILE: kernel/bpf/fixups.c:2449: + subprog->stack_depth = -subprog->fastcall_stack_off; CHECK: Alignment should match open parenthesis #2845: FILE: kernel/bpf/verifier.c:3751: +bool bpf_is_reg64(struct bpf_insn *insn, + u32 regno, struct bpf_reg_state *reg, enum bpf_reg_arg_type t) WARNING: line length of 84 exceeds 80 columns #2966: FILE: kernel/bpf/verifier.c:10302: + if (env->subprog_cnt > 1 && !bpf_allow_tail_call_in_subprogs(env)) { WARNING: line length of 83 exceeds 80 columns #2984: FILE: kernel/bpf/verifier.c:18571: + (bpf_verifier_inlines_helper_call(env, call->imm) || WARNING: line length of 100 exceeds 80 columns #5519: FILE: kernel/bpf/verifier.c:23896: +static int specialize_kfunc(struct bpf_verifier_env *env, struct bpf_kfunc_desc *desc, int insn_idx) WARNING: line length of 82 exceeds 80 columns #5559: FILE: kernel/bpf/verifier.c:23936: + addr = (unsigned long)bpf_arena_alloc_pages_non_sleepable; WARNING: line length of 81 exceeds 80 columns #5562: FILE: kernel/bpf/verifier.c:23939: + addr = (unsigned long)bpf_arena_free_pages_non_sleepable; WARNING: line length of 92 exceeds 80 columns #5576: FILE: kernel/bpf/verifier.c:23953: + struct bpf_insn addr[2] = { BPF_LD_IMM64(struct_meta_reg, (long)kptr_struct_meta) }; CHECK: Alignment should match open parenthesis #5586: FILE: kernel/bpf/verifier.c:23963: +int bpf_fixup_kfunc_call(struct bpf_verifier_env *env, struct bpf_insn *insn, + struct bpf_insn *insn_buf, int insn_idx, int *cnt) WARNING: line length of 95 exceeds 80 columns #5592: FILE: kernel/bpf/verifier.c:23969: + verbose(env, "invalid kernel function call not eliminated in verifier pass\n"); WARNING: line length of 88 exceeds 80 columns #5604: FILE: kernel/bpf/verifier.c:23981: + verifier_bug(env, "kernel function descriptor not found for func_id %u", WARNING: line length of 96 exceeds 80 columns #5616: FILE: kernel/bpf/verifier.c:23993: + if (is_bpf_obj_new_kfunc(desc->func_id) || is_bpf_percpu_obj_new_kfunc(desc->func_id)) { WARNING: line length of 105 exceeds 80 columns #5617: FILE: kernel/bpf/verifier.c:23994: + struct btf_struct_meta *kptr_struct_meta = env->insn_aux_data[insn_idx].kptr_struct_meta; WARNING: line length of 94 exceeds 80 columns #5618: FILE: kernel/bpf/verifier.c:23995: + struct bpf_insn addr[2] = { BPF_LD_IMM64(BPF_REG_2, (long)kptr_struct_meta) }; WARNING: line length of 85 exceeds 80 columns #5621: FILE: kernel/bpf/verifier.c:23998: + if (is_bpf_percpu_obj_new_kfunc(desc->func_id) && kptr_struct_meta) { WARNING: line length of 90 exceeds 80 columns #5622: FILE: kernel/bpf/verifier.c:23999: + verifier_bug(env, "NULL kptr_struct_meta expected at insn_idx %d", WARNING: line length of 105 exceeds 80 columns #5635: FILE: kernel/bpf/verifier.c:24012: + struct btf_struct_meta *kptr_struct_meta = env->insn_aux_data[insn_idx].kptr_struct_meta; WARNING: line length of 94 exceeds 80 columns #5636: FILE: kernel/bpf/verifier.c:24013: + struct bpf_insn addr[2] = { BPF_LD_IMM64(BPF_REG_2, (long)kptr_struct_meta) }; WARNING: line length of 86 exceeds 80 columns #5638: FILE: kernel/bpf/verifier.c:24015: + if (is_bpf_percpu_obj_drop_kfunc(desc->func_id) && kptr_struct_meta) { WARNING: line length of 90 exceeds 80 columns #5639: FILE: kernel/bpf/verifier.c:24016: + verifier_bug(env, "NULL kptr_struct_meta expected at insn_idx %d", WARNING: line length of 88 exceeds 80 columns #5644: FILE: kernel/bpf/verifier.c:24021: + if (is_bpf_refcount_acquire_kfunc(desc->func_id) && !kptr_struct_meta) { WARNING: line length of 85 exceeds 80 columns #5645: FILE: kernel/bpf/verifier.c:24022: + verifier_bug(env, "kptr_struct_meta expected at insn_idx %d", WARNING: line length of 105 exceeds 80 columns #5656: FILE: kernel/bpf/verifier.c:24033: + struct btf_struct_meta *kptr_struct_meta = env->insn_aux_data[insn_idx].kptr_struct_meta; WARNING: line length of 88 exceeds 80 columns #5660: FILE: kernel/bpf/verifier.c:24037: + /* rbtree_add has extra 'less' arg, so args-to-fixup are in diff regs */ WARNING: line length of 85 exceeds 80 columns #5667: FILE: kernel/bpf/verifier.c:24044: + verifier_bug(env, "kptr_struct_meta expected at insn_idx %d", WARNING: line length of 95 exceeds 80 columns #5672: FILE: kernel/bpf/verifier.c:24049: + __fixup_collection_insert_kfunc(&env->insn_aux_data[insn_idx], struct_meta_reg, WARNING: line length of 86 exceeds 80 columns #5673: FILE: kernel/bpf/verifier.c:24050: + node_offset_reg, insn, insn_buf, cnt); WARNING: line length of 82 exceeds 80 columns #5674: FILE: kernel/bpf/verifier.c:24051: + } else if (desc->func_id == special_kfunc_list[KF_bpf_cast_to_kern_ctx] || WARNING: line length of 83 exceeds 80 columns #5678: FILE: kernel/bpf/verifier.c:24055: + } else if (desc->func_id == special_kfunc_list[KF_bpf_session_is_return] && WARNING: line length of 84 exceeds 80 columns #5684: FILE: kernel/bpf/verifier.c:24061: + * return (((u64 *)ctx)[-1] >> BPF_TRAMP_IS_RETURN_SHIFT) & 1; WARNING: line length of 91 exceeds 80 columns #5688: FILE: kernel/bpf/verifier.c:24065: + insn_buf[1] = BPF_ALU64_IMM(BPF_RSH, BPF_REG_0, BPF_TRAMP_IS_RETURN_SHIFT); WARNING: line length of 93 exceeds 80 columns #5697: FILE: kernel/bpf/verifier.c:24074: + * u64 off = (((u64 *)ctx)[-1] >> BPF_TRAMP_COOKIE_INDEX_SHIFT) & 0xFF; WARNING: line length of 94 exceeds 80 columns #5702: FILE: kernel/bpf/verifier.c:24079: + insn_buf[1] = BPF_ALU64_IMM(BPF_RSH, BPF_REG_0, BPF_TRAMP_COOKIE_INDEX_SHIFT); WARNING: line length of 92 exceeds 80 columns #5712: FILE: kernel/bpf/verifier.c:24089: + struct bpf_insn ld_addrs[2] = { BPF_LD_IMM64(regno, (long)env->prog->aux) }; total: 0 errors, 251 warnings, 39 checks, 5719 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 2aa6d5ef1685 ("bpf: Split fixup/post-processing logic from verifier.c into fixups.c") 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, 251 warnings, 39 checks, 5719 lines checked