calls.c (68167B)
1{ 2 "calls: invalid kfunc call not eliminated", 3 .insns = { 4 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 5 BPF_MOV64_IMM(BPF_REG_0, 1), 6 BPF_EXIT_INSN(), 7 }, 8 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 9 .result = REJECT, 10 .errstr = "invalid kernel function call not eliminated in verifier pass", 11}, 12{ 13 "calls: invalid kfunc call unreachable", 14 .insns = { 15 BPF_MOV64_IMM(BPF_REG_0, 1), 16 BPF_JMP_IMM(BPF_JGT, BPF_REG_0, 0, 2), 17 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 18 BPF_MOV64_IMM(BPF_REG_0, 1), 19 BPF_EXIT_INSN(), 20 }, 21 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 22 .result = ACCEPT, 23}, 24{ 25 "calls: invalid kfunc call: ptr_to_mem to struct with non-scalar", 26 .insns = { 27 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 28 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 29 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 30 BPF_EXIT_INSN(), 31 }, 32 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 33 .result = REJECT, 34 .errstr = "arg#0 pointer type STRUCT prog_test_fail1 must point to scalar", 35 .fixup_kfunc_btf_id = { 36 { "bpf_kfunc_call_test_fail1", 2 }, 37 }, 38}, 39{ 40 "calls: invalid kfunc call: ptr_to_mem to struct with nesting depth > 4", 41 .insns = { 42 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 43 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 44 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 45 BPF_EXIT_INSN(), 46 }, 47 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 48 .result = REJECT, 49 .errstr = "max struct nesting depth exceeded\narg#0 pointer type STRUCT prog_test_fail2", 50 .fixup_kfunc_btf_id = { 51 { "bpf_kfunc_call_test_fail2", 2 }, 52 }, 53}, 54{ 55 "calls: invalid kfunc call: ptr_to_mem to struct with FAM", 56 .insns = { 57 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 58 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 59 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 60 BPF_EXIT_INSN(), 61 }, 62 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 63 .result = REJECT, 64 .errstr = "arg#0 pointer type STRUCT prog_test_fail3 must point to scalar", 65 .fixup_kfunc_btf_id = { 66 { "bpf_kfunc_call_test_fail3", 2 }, 67 }, 68}, 69{ 70 "calls: invalid kfunc call: reg->type != PTR_TO_CTX", 71 .insns = { 72 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 73 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 74 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 75 BPF_EXIT_INSN(), 76 }, 77 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 78 .result = REJECT, 79 .errstr = "arg#0 expected pointer to ctx, but got PTR", 80 .fixup_kfunc_btf_id = { 81 { "bpf_kfunc_call_test_pass_ctx", 2 }, 82 }, 83}, 84{ 85 "calls: invalid kfunc call: void * not allowed in func proto without mem size arg", 86 .insns = { 87 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 88 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 89 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 90 BPF_EXIT_INSN(), 91 }, 92 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 93 .result = REJECT, 94 .errstr = "arg#0 pointer type UNKNOWN must point to scalar", 95 .fixup_kfunc_btf_id = { 96 { "bpf_kfunc_call_test_mem_len_fail1", 2 }, 97 }, 98}, 99{ 100 "calls: trigger reg2btf_ids[reg->type] for reg->type > __BPF_REG_TYPE_MAX", 101 .insns = { 102 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 103 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 104 BPF_ST_MEM(BPF_DW, BPF_REG_1, 0, 0), 105 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 106 BPF_MOV64_REG(BPF_REG_1, BPF_REG_0), 107 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 108 BPF_EXIT_INSN(), 109 }, 110 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 111 .result = REJECT, 112 .errstr = "arg#0 pointer type STRUCT prog_test_ref_kfunc must point", 113 .fixup_kfunc_btf_id = { 114 { "bpf_kfunc_call_test_acquire", 3 }, 115 { "bpf_kfunc_call_test_release", 5 }, 116 }, 117}, 118{ 119 "calls: invalid kfunc call: reg->off must be zero when passed to release kfunc", 120 .insns = { 121 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 122 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 123 BPF_ST_MEM(BPF_DW, BPF_REG_1, 0, 0), 124 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 125 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), 126 BPF_EXIT_INSN(), 127 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 8), 128 BPF_MOV64_REG(BPF_REG_1, BPF_REG_0), 129 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 130 BPF_MOV64_IMM(BPF_REG_0, 0), 131 BPF_EXIT_INSN(), 132 }, 133 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 134 .result = REJECT, 135 .errstr = "R1 must have zero offset when passed to release func", 136 .fixup_kfunc_btf_id = { 137 { "bpf_kfunc_call_test_acquire", 3 }, 138 { "bpf_kfunc_call_memb_release", 8 }, 139 }, 140}, 141{ 142 "calls: invalid kfunc call: don't match first member type when passed to release kfunc", 143 .insns = { 144 BPF_MOV64_IMM(BPF_REG_0, 0), 145 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 146 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), 147 BPF_EXIT_INSN(), 148 BPF_MOV64_REG(BPF_REG_1, BPF_REG_0), 149 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 150 BPF_MOV64_IMM(BPF_REG_0, 0), 151 BPF_EXIT_INSN(), 152 }, 153 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 154 .result = REJECT, 155 .errstr = "kernel function bpf_kfunc_call_memb1_release args#0 expected pointer", 156 .fixup_kfunc_btf_id = { 157 { "bpf_kfunc_call_memb_acquire", 1 }, 158 { "bpf_kfunc_call_memb1_release", 5 }, 159 }, 160}, 161{ 162 "calls: invalid kfunc call: PTR_TO_BTF_ID with negative offset", 163 .insns = { 164 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 165 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 166 BPF_ST_MEM(BPF_DW, BPF_REG_1, 0, 0), 167 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 168 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), 169 BPF_EXIT_INSN(), 170 BPF_MOV64_REG(BPF_REG_1, BPF_REG_0), 171 BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_1, 16), 172 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -4), 173 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 174 BPF_MOV64_IMM(BPF_REG_0, 0), 175 BPF_EXIT_INSN(), 176 }, 177 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 178 .fixup_kfunc_btf_id = { 179 { "bpf_kfunc_call_test_acquire", 3 }, 180 { "bpf_kfunc_call_test_release", 9 }, 181 }, 182 .result_unpriv = REJECT, 183 .result = REJECT, 184 .errstr = "negative offset ptr_ ptr R1 off=-4 disallowed", 185}, 186{ 187 "calls: invalid kfunc call: PTR_TO_BTF_ID with variable offset", 188 .insns = { 189 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 190 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 191 BPF_ST_MEM(BPF_DW, BPF_REG_1, 0, 0), 192 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 193 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), 194 BPF_EXIT_INSN(), 195 BPF_MOV64_REG(BPF_REG_1, BPF_REG_0), 196 BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_0, 4), 197 BPF_JMP_IMM(BPF_JLE, BPF_REG_2, 4, 3), 198 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 199 BPF_MOV64_IMM(BPF_REG_0, 0), 200 BPF_EXIT_INSN(), 201 BPF_JMP_IMM(BPF_JGE, BPF_REG_2, 0, 3), 202 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 203 BPF_MOV64_IMM(BPF_REG_0, 0), 204 BPF_EXIT_INSN(), 205 BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_2), 206 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, BPF_PSEUDO_KFUNC_CALL, 0, 0), 207 BPF_MOV64_IMM(BPF_REG_0, 0), 208 BPF_EXIT_INSN(), 209 }, 210 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 211 .fixup_kfunc_btf_id = { 212 { "bpf_kfunc_call_test_acquire", 3 }, 213 { "bpf_kfunc_call_test_release", 9 }, 214 { "bpf_kfunc_call_test_release", 13 }, 215 { "bpf_kfunc_call_test_release", 17 }, 216 }, 217 .result_unpriv = REJECT, 218 .result = REJECT, 219 .errstr = "variable ptr_ access var_off=(0x0; 0x7) disallowed", 220}, 221{ 222 "calls: basic sanity", 223 .insns = { 224 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 225 BPF_MOV64_IMM(BPF_REG_0, 1), 226 BPF_EXIT_INSN(), 227 BPF_MOV64_IMM(BPF_REG_0, 2), 228 BPF_EXIT_INSN(), 229 }, 230 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 231 .result = ACCEPT, 232}, 233{ 234 "calls: not on unpriviledged", 235 .insns = { 236 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 237 BPF_MOV64_IMM(BPF_REG_0, 1), 238 BPF_EXIT_INSN(), 239 BPF_MOV64_IMM(BPF_REG_0, 2), 240 BPF_EXIT_INSN(), 241 }, 242 .errstr_unpriv = "loading/calling other bpf or kernel functions are allowed for", 243 .result_unpriv = REJECT, 244 .result = ACCEPT, 245 .retval = 1, 246}, 247{ 248 "calls: div by 0 in subprog", 249 .insns = { 250 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 251 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 8), 252 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), 253 BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_1, 254 offsetof(struct __sk_buff, data_end)), 255 BPF_MOV64_REG(BPF_REG_2, BPF_REG_0), 256 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 8), 257 BPF_JMP_REG(BPF_JGT, BPF_REG_2, BPF_REG_1, 1), 258 BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_0, 0), 259 BPF_MOV64_IMM(BPF_REG_0, 1), 260 BPF_EXIT_INSN(), 261 BPF_MOV32_IMM(BPF_REG_2, 0), 262 BPF_MOV32_IMM(BPF_REG_3, 1), 263 BPF_ALU32_REG(BPF_DIV, BPF_REG_3, BPF_REG_2), 264 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 265 offsetof(struct __sk_buff, data)), 266 BPF_EXIT_INSN(), 267 }, 268 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 269 .result = ACCEPT, 270 .retval = 1, 271}, 272{ 273 "calls: multiple ret types in subprog 1", 274 .insns = { 275 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 276 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 8), 277 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), 278 BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_1, 279 offsetof(struct __sk_buff, data_end)), 280 BPF_MOV64_REG(BPF_REG_2, BPF_REG_0), 281 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 8), 282 BPF_JMP_REG(BPF_JGT, BPF_REG_2, BPF_REG_1, 1), 283 BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_0, 0), 284 BPF_MOV64_IMM(BPF_REG_0, 1), 285 BPF_EXIT_INSN(), 286 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 287 offsetof(struct __sk_buff, data)), 288 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), 289 BPF_MOV32_IMM(BPF_REG_0, 42), 290 BPF_EXIT_INSN(), 291 }, 292 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 293 .result = REJECT, 294 .errstr = "R0 invalid mem access 'scalar'", 295}, 296{ 297 "calls: multiple ret types in subprog 2", 298 .insns = { 299 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 300 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 8), 301 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), 302 BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_1, 303 offsetof(struct __sk_buff, data_end)), 304 BPF_MOV64_REG(BPF_REG_2, BPF_REG_0), 305 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 8), 306 BPF_JMP_REG(BPF_JGT, BPF_REG_2, BPF_REG_1, 1), 307 BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_0, 0), 308 BPF_MOV64_IMM(BPF_REG_0, 1), 309 BPF_EXIT_INSN(), 310 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 311 offsetof(struct __sk_buff, data)), 312 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 313 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 9), 314 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 315 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 316 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 317 BPF_LD_MAP_FD(BPF_REG_1, 0), 318 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 319 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), 320 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_6, 321 offsetof(struct __sk_buff, data)), 322 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 64), 323 BPF_EXIT_INSN(), 324 }, 325 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 326 .fixup_map_hash_8b = { 16 }, 327 .result = REJECT, 328 .errstr = "R0 min value is outside of the allowed memory range", 329}, 330{ 331 "calls: overlapping caller/callee", 332 .insns = { 333 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 0), 334 BPF_MOV64_IMM(BPF_REG_0, 1), 335 BPF_EXIT_INSN(), 336 }, 337 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 338 .errstr = "last insn is not an exit or jmp", 339 .result = REJECT, 340}, 341{ 342 "calls: wrong recursive calls", 343 .insns = { 344 BPF_JMP_IMM(BPF_JA, 0, 0, 4), 345 BPF_JMP_IMM(BPF_JA, 0, 0, 4), 346 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, -2), 347 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, -2), 348 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, -2), 349 BPF_MOV64_IMM(BPF_REG_0, 1), 350 BPF_EXIT_INSN(), 351 }, 352 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 353 .errstr = "jump out of range", 354 .result = REJECT, 355}, 356{ 357 "calls: wrong src reg", 358 .insns = { 359 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 3, 0, 0), 360 BPF_MOV64_IMM(BPF_REG_0, 1), 361 BPF_EXIT_INSN(), 362 }, 363 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 364 .errstr = "BPF_CALL uses reserved fields", 365 .result = REJECT, 366}, 367{ 368 "calls: wrong off value", 369 .insns = { 370 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, -1, 2), 371 BPF_MOV64_IMM(BPF_REG_0, 1), 372 BPF_EXIT_INSN(), 373 BPF_MOV64_IMM(BPF_REG_0, 2), 374 BPF_EXIT_INSN(), 375 }, 376 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 377 .errstr = "BPF_CALL uses reserved fields", 378 .result = REJECT, 379}, 380{ 381 "calls: jump back loop", 382 .insns = { 383 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, -1), 384 BPF_MOV64_IMM(BPF_REG_0, 1), 385 BPF_EXIT_INSN(), 386 }, 387 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 388 .errstr = "back-edge from insn 0 to 0", 389 .result = REJECT, 390}, 391{ 392 "calls: conditional call", 393 .insns = { 394 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 395 offsetof(struct __sk_buff, mark)), 396 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 3), 397 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 398 BPF_MOV64_IMM(BPF_REG_0, 1), 399 BPF_EXIT_INSN(), 400 BPF_MOV64_IMM(BPF_REG_0, 2), 401 BPF_EXIT_INSN(), 402 }, 403 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 404 .errstr = "jump out of range", 405 .result = REJECT, 406}, 407{ 408 "calls: conditional call 2", 409 .insns = { 410 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 411 offsetof(struct __sk_buff, mark)), 412 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 3), 413 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 4), 414 BPF_MOV64_IMM(BPF_REG_0, 1), 415 BPF_EXIT_INSN(), 416 BPF_MOV64_IMM(BPF_REG_0, 2), 417 BPF_EXIT_INSN(), 418 BPF_MOV64_IMM(BPF_REG_0, 3), 419 BPF_EXIT_INSN(), 420 }, 421 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 422 .result = ACCEPT, 423}, 424{ 425 "calls: conditional call 3", 426 .insns = { 427 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 428 offsetof(struct __sk_buff, mark)), 429 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 3), 430 BPF_JMP_IMM(BPF_JA, 0, 0, 4), 431 BPF_MOV64_IMM(BPF_REG_0, 1), 432 BPF_EXIT_INSN(), 433 BPF_MOV64_IMM(BPF_REG_0, 1), 434 BPF_JMP_IMM(BPF_JA, 0, 0, -6), 435 BPF_MOV64_IMM(BPF_REG_0, 3), 436 BPF_JMP_IMM(BPF_JA, 0, 0, -6), 437 }, 438 .prog_type = BPF_PROG_TYPE_SOCKET_FILTER, 439 .errstr_unpriv = "back-edge from insn", 440 .result_unpriv = REJECT, 441 .result = ACCEPT, 442 .retval = 1, 443}, 444{ 445 "calls: conditional call 4", 446 .insns = { 447 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 448 offsetof(struct __sk_buff, mark)), 449 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 3), 450 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 4), 451 BPF_MOV64_IMM(BPF_REG_0, 1), 452 BPF_EXIT_INSN(), 453 BPF_MOV64_IMM(BPF_REG_0, 1), 454 BPF_JMP_IMM(BPF_JA, 0, 0, -5), 455 BPF_MOV64_IMM(BPF_REG_0, 3), 456 BPF_EXIT_INSN(), 457 }, 458 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 459 .result = ACCEPT, 460}, 461{ 462 "calls: conditional call 5", 463 .insns = { 464 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 465 offsetof(struct __sk_buff, mark)), 466 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 3), 467 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 4), 468 BPF_MOV64_IMM(BPF_REG_0, 1), 469 BPF_EXIT_INSN(), 470 BPF_MOV64_IMM(BPF_REG_0, 1), 471 BPF_JMP_IMM(BPF_JA, 0, 0, -6), 472 BPF_MOV64_IMM(BPF_REG_0, 3), 473 BPF_EXIT_INSN(), 474 }, 475 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 476 .result = ACCEPT, 477 .retval = 1, 478}, 479{ 480 "calls: conditional call 6", 481 .insns = { 482 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 483 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), 484 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 485 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, -3), 486 BPF_EXIT_INSN(), 487 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 488 offsetof(struct __sk_buff, mark)), 489 BPF_EXIT_INSN(), 490 }, 491 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 492 .errstr = "infinite loop detected", 493 .result = REJECT, 494}, 495{ 496 "calls: using r0 returned by callee", 497 .insns = { 498 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 499 BPF_EXIT_INSN(), 500 BPF_MOV64_IMM(BPF_REG_0, 2), 501 BPF_EXIT_INSN(), 502 }, 503 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 504 .result = ACCEPT, 505}, 506{ 507 "calls: using uninit r0 from callee", 508 .insns = { 509 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 510 BPF_EXIT_INSN(), 511 BPF_EXIT_INSN(), 512 }, 513 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 514 .errstr = "!read_ok", 515 .result = REJECT, 516}, 517{ 518 "calls: callee is using r1", 519 .insns = { 520 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 521 BPF_EXIT_INSN(), 522 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 523 offsetof(struct __sk_buff, len)), 524 BPF_EXIT_INSN(), 525 }, 526 .prog_type = BPF_PROG_TYPE_SCHED_ACT, 527 .result = ACCEPT, 528 .retval = TEST_DATA_LEN, 529}, 530{ 531 "calls: callee using args1", 532 .insns = { 533 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 534 BPF_EXIT_INSN(), 535 BPF_MOV64_REG(BPF_REG_0, BPF_REG_1), 536 BPF_EXIT_INSN(), 537 }, 538 .errstr_unpriv = "allowed for", 539 .result_unpriv = REJECT, 540 .result = ACCEPT, 541 .retval = POINTER_VALUE, 542}, 543{ 544 "calls: callee using wrong args2", 545 .insns = { 546 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 547 BPF_EXIT_INSN(), 548 BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), 549 BPF_EXIT_INSN(), 550 }, 551 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 552 .errstr = "R2 !read_ok", 553 .result = REJECT, 554}, 555{ 556 "calls: callee using two args", 557 .insns = { 558 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 559 BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_6, 560 offsetof(struct __sk_buff, len)), 561 BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_6, 562 offsetof(struct __sk_buff, len)), 563 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 564 BPF_EXIT_INSN(), 565 BPF_MOV64_REG(BPF_REG_0, BPF_REG_1), 566 BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_2), 567 BPF_EXIT_INSN(), 568 }, 569 .errstr_unpriv = "allowed for", 570 .result_unpriv = REJECT, 571 .result = ACCEPT, 572 .retval = TEST_DATA_LEN + TEST_DATA_LEN - ETH_HLEN - ETH_HLEN, 573}, 574{ 575 "calls: callee changing pkt pointers", 576 .insns = { 577 BPF_LDX_MEM(BPF_W, BPF_REG_6, BPF_REG_1, offsetof(struct xdp_md, data)), 578 BPF_LDX_MEM(BPF_W, BPF_REG_7, BPF_REG_1, 579 offsetof(struct xdp_md, data_end)), 580 BPF_MOV64_REG(BPF_REG_8, BPF_REG_6), 581 BPF_ALU64_IMM(BPF_ADD, BPF_REG_8, 8), 582 BPF_JMP_REG(BPF_JGT, BPF_REG_8, BPF_REG_7, 2), 583 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 584 /* clear_all_pkt_pointers() has to walk all frames 585 * to make sure that pkt pointers in the caller 586 * are cleared when callee is calling a helper that 587 * adjusts packet size 588 */ 589 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_6, 0), 590 BPF_MOV32_IMM(BPF_REG_0, 0), 591 BPF_EXIT_INSN(), 592 BPF_MOV64_IMM(BPF_REG_2, 0), 593 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_xdp_adjust_head), 594 BPF_EXIT_INSN(), 595 }, 596 .result = REJECT, 597 .errstr = "R6 invalid mem access 'scalar'", 598 .prog_type = BPF_PROG_TYPE_XDP, 599 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 600}, 601{ 602 "calls: ptr null check in subprog", 603 .insns = { 604 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 605 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 606 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 607 BPF_LD_MAP_FD(BPF_REG_1, 0), 608 BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem), 609 BPF_MOV64_REG(BPF_REG_1, BPF_REG_0), 610 BPF_MOV64_REG(BPF_REG_6, BPF_REG_0), 611 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 612 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 1), 613 BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_6, 0), 614 BPF_EXIT_INSN(), 615 BPF_MOV64_IMM(BPF_REG_0, 0), 616 BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 1), 617 BPF_MOV64_IMM(BPF_REG_0, 1), 618 BPF_EXIT_INSN(), 619 }, 620 .errstr_unpriv = "loading/calling other bpf or kernel functions are allowed for", 621 .fixup_map_hash_48b = { 3 }, 622 .result_unpriv = REJECT, 623 .result = ACCEPT, 624 .retval = 0, 625}, 626{ 627 "calls: two calls with args", 628 .insns = { 629 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 630 BPF_EXIT_INSN(), 631 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 632 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 6), 633 BPF_MOV64_REG(BPF_REG_7, BPF_REG_0), 634 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), 635 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 636 BPF_ALU64_REG(BPF_ADD, BPF_REG_7, BPF_REG_0), 637 BPF_MOV64_REG(BPF_REG_0, BPF_REG_7), 638 BPF_EXIT_INSN(), 639 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 640 offsetof(struct __sk_buff, len)), 641 BPF_EXIT_INSN(), 642 }, 643 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 644 .result = ACCEPT, 645 .retval = TEST_DATA_LEN + TEST_DATA_LEN, 646}, 647{ 648 "calls: calls with stack arith", 649 .insns = { 650 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 651 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -64), 652 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 653 BPF_EXIT_INSN(), 654 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -64), 655 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 656 BPF_EXIT_INSN(), 657 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -64), 658 BPF_MOV64_IMM(BPF_REG_0, 42), 659 BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_0, 0), 660 BPF_EXIT_INSN(), 661 }, 662 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 663 .result = ACCEPT, 664 .retval = 42, 665}, 666{ 667 "calls: calls with misaligned stack access", 668 .insns = { 669 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 670 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -63), 671 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 672 BPF_EXIT_INSN(), 673 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -61), 674 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 675 BPF_EXIT_INSN(), 676 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -63), 677 BPF_MOV64_IMM(BPF_REG_0, 42), 678 BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_0, 0), 679 BPF_EXIT_INSN(), 680 }, 681 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 682 .flags = F_LOAD_WITH_STRICT_ALIGNMENT, 683 .errstr = "misaligned stack access", 684 .result = REJECT, 685}, 686{ 687 "calls: calls control flow, jump test", 688 .insns = { 689 BPF_MOV64_IMM(BPF_REG_0, 42), 690 BPF_JMP_IMM(BPF_JA, 0, 0, 2), 691 BPF_MOV64_IMM(BPF_REG_0, 43), 692 BPF_JMP_IMM(BPF_JA, 0, 0, 1), 693 BPF_JMP_IMM(BPF_JA, 0, 0, -3), 694 BPF_EXIT_INSN(), 695 }, 696 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 697 .result = ACCEPT, 698 .retval = 43, 699}, 700{ 701 "calls: calls control flow, jump test 2", 702 .insns = { 703 BPF_MOV64_IMM(BPF_REG_0, 42), 704 BPF_JMP_IMM(BPF_JA, 0, 0, 2), 705 BPF_MOV64_IMM(BPF_REG_0, 43), 706 BPF_JMP_IMM(BPF_JA, 0, 0, 1), 707 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, -3), 708 BPF_EXIT_INSN(), 709 }, 710 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 711 .errstr = "jump out of range from insn 1 to 4", 712 .result = REJECT, 713}, 714{ 715 "calls: two calls with bad jump", 716 .insns = { 717 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 718 BPF_EXIT_INSN(), 719 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 720 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 6), 721 BPF_MOV64_REG(BPF_REG_7, BPF_REG_0), 722 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), 723 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 724 BPF_ALU64_REG(BPF_ADD, BPF_REG_7, BPF_REG_0), 725 BPF_MOV64_REG(BPF_REG_0, BPF_REG_7), 726 BPF_EXIT_INSN(), 727 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 728 offsetof(struct __sk_buff, len)), 729 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, -3), 730 BPF_EXIT_INSN(), 731 }, 732 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 733 .errstr = "jump out of range from insn 11 to 9", 734 .result = REJECT, 735}, 736{ 737 "calls: recursive call. test1", 738 .insns = { 739 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 740 BPF_EXIT_INSN(), 741 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, -1), 742 BPF_EXIT_INSN(), 743 }, 744 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 745 .errstr = "back-edge", 746 .result = REJECT, 747}, 748{ 749 "calls: recursive call. test2", 750 .insns = { 751 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 752 BPF_EXIT_INSN(), 753 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, -3), 754 BPF_EXIT_INSN(), 755 }, 756 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 757 .errstr = "back-edge", 758 .result = REJECT, 759}, 760{ 761 "calls: unreachable code", 762 .insns = { 763 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 764 BPF_EXIT_INSN(), 765 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 766 BPF_EXIT_INSN(), 767 BPF_MOV64_IMM(BPF_REG_0, 0), 768 BPF_EXIT_INSN(), 769 BPF_MOV64_IMM(BPF_REG_0, 0), 770 BPF_EXIT_INSN(), 771 }, 772 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 773 .errstr = "unreachable insn 6", 774 .result = REJECT, 775}, 776{ 777 "calls: invalid call", 778 .insns = { 779 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 780 BPF_EXIT_INSN(), 781 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, -4), 782 BPF_EXIT_INSN(), 783 }, 784 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 785 .errstr = "invalid destination", 786 .result = REJECT, 787}, 788{ 789 "calls: invalid call 2", 790 .insns = { 791 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 792 BPF_EXIT_INSN(), 793 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 0x7fffffff), 794 BPF_EXIT_INSN(), 795 }, 796 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 797 .errstr = "invalid destination", 798 .result = REJECT, 799}, 800{ 801 "calls: jumping across function bodies. test1", 802 .insns = { 803 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 804 BPF_MOV64_IMM(BPF_REG_0, 0), 805 BPF_EXIT_INSN(), 806 BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, -3), 807 BPF_EXIT_INSN(), 808 }, 809 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 810 .errstr = "jump out of range", 811 .result = REJECT, 812}, 813{ 814 "calls: jumping across function bodies. test2", 815 .insns = { 816 BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 3), 817 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 818 BPF_MOV64_IMM(BPF_REG_0, 0), 819 BPF_EXIT_INSN(), 820 BPF_EXIT_INSN(), 821 }, 822 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 823 .errstr = "jump out of range", 824 .result = REJECT, 825}, 826{ 827 "calls: call without exit", 828 .insns = { 829 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 830 BPF_EXIT_INSN(), 831 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 832 BPF_EXIT_INSN(), 833 BPF_MOV64_IMM(BPF_REG_0, 0), 834 BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, -2), 835 }, 836 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 837 .errstr = "not an exit", 838 .result = REJECT, 839}, 840{ 841 "calls: call into middle of ld_imm64", 842 .insns = { 843 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 844 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 845 BPF_MOV64_IMM(BPF_REG_0, 0), 846 BPF_EXIT_INSN(), 847 BPF_LD_IMM64(BPF_REG_0, 0), 848 BPF_EXIT_INSN(), 849 }, 850 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 851 .errstr = "last insn", 852 .result = REJECT, 853}, 854{ 855 "calls: call into middle of other call", 856 .insns = { 857 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 858 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 859 BPF_MOV64_IMM(BPF_REG_0, 0), 860 BPF_EXIT_INSN(), 861 BPF_MOV64_IMM(BPF_REG_0, 0), 862 BPF_MOV64_IMM(BPF_REG_0, 0), 863 BPF_EXIT_INSN(), 864 }, 865 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 866 .errstr = "last insn", 867 .result = REJECT, 868}, 869{ 870 "calls: subprog call with ld_abs in main prog", 871 .insns = { 872 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 873 BPF_LD_ABS(BPF_B, 0), 874 BPF_LD_ABS(BPF_H, 0), 875 BPF_LD_ABS(BPF_W, 0), 876 BPF_MOV64_REG(BPF_REG_7, BPF_REG_6), 877 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), 878 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 5), 879 BPF_MOV64_REG(BPF_REG_6, BPF_REG_7), 880 BPF_LD_ABS(BPF_B, 0), 881 BPF_LD_ABS(BPF_H, 0), 882 BPF_LD_ABS(BPF_W, 0), 883 BPF_EXIT_INSN(), 884 BPF_MOV64_IMM(BPF_REG_2, 1), 885 BPF_MOV64_IMM(BPF_REG_3, 2), 886 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_skb_vlan_push), 887 BPF_EXIT_INSN(), 888 }, 889 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 890 .result = ACCEPT, 891}, 892{ 893 "calls: two calls with bad fallthrough", 894 .insns = { 895 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 896 BPF_EXIT_INSN(), 897 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 898 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 6), 899 BPF_MOV64_REG(BPF_REG_7, BPF_REG_0), 900 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), 901 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 902 BPF_ALU64_REG(BPF_ADD, BPF_REG_7, BPF_REG_0), 903 BPF_MOV64_REG(BPF_REG_0, BPF_REG_7), 904 BPF_MOV64_REG(BPF_REG_0, BPF_REG_0), 905 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 906 offsetof(struct __sk_buff, len)), 907 BPF_EXIT_INSN(), 908 }, 909 .prog_type = BPF_PROG_TYPE_TRACEPOINT, 910 .errstr = "not an exit", 911 .result = REJECT, 912}, 913{ 914 "calls: two calls with stack read", 915 .insns = { 916 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 917 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 918 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 919 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 920 BPF_EXIT_INSN(), 921 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 922 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 6), 923 BPF_MOV64_REG(BPF_REG_7, BPF_REG_0), 924 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), 925 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 926 BPF_ALU64_REG(BPF_ADD, BPF_REG_7, BPF_REG_0), 927 BPF_MOV64_REG(BPF_REG_0, BPF_REG_7), 928 BPF_EXIT_INSN(), 929 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 0), 930 BPF_EXIT_INSN(), 931 }, 932 .prog_type = BPF_PROG_TYPE_XDP, 933 .result = ACCEPT, 934}, 935{ 936 "calls: two calls with stack write", 937 .insns = { 938 /* main prog */ 939 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 940 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 941 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 942 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 943 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -16), 944 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 945 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_10, -16), 946 BPF_EXIT_INSN(), 947 948 /* subprog 1 */ 949 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 950 BPF_MOV64_REG(BPF_REG_7, BPF_REG_2), 951 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 7), 952 BPF_MOV64_REG(BPF_REG_8, BPF_REG_0), 953 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), 954 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 4), 955 BPF_ALU64_REG(BPF_ADD, BPF_REG_8, BPF_REG_0), 956 BPF_MOV64_REG(BPF_REG_0, BPF_REG_8), 957 /* write into stack frame of main prog */ 958 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 959 BPF_EXIT_INSN(), 960 961 /* subprog 2 */ 962 /* read from stack frame of main prog */ 963 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 0), 964 BPF_EXIT_INSN(), 965 }, 966 .prog_type = BPF_PROG_TYPE_XDP, 967 .result = ACCEPT, 968}, 969{ 970 "calls: stack overflow using two frames (pre-call access)", 971 .insns = { 972 /* prog 1 */ 973 BPF_ST_MEM(BPF_B, BPF_REG_10, -300, 0), 974 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), 975 BPF_EXIT_INSN(), 976 977 /* prog 2 */ 978 BPF_ST_MEM(BPF_B, BPF_REG_10, -300, 0), 979 BPF_MOV64_IMM(BPF_REG_0, 0), 980 BPF_EXIT_INSN(), 981 }, 982 .prog_type = BPF_PROG_TYPE_XDP, 983 .errstr = "combined stack size", 984 .result = REJECT, 985}, 986{ 987 "calls: stack overflow using two frames (post-call access)", 988 .insns = { 989 /* prog 1 */ 990 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 2), 991 BPF_ST_MEM(BPF_B, BPF_REG_10, -300, 0), 992 BPF_EXIT_INSN(), 993 994 /* prog 2 */ 995 BPF_ST_MEM(BPF_B, BPF_REG_10, -300, 0), 996 BPF_MOV64_IMM(BPF_REG_0, 0), 997 BPF_EXIT_INSN(), 998 }, 999 .prog_type = BPF_PROG_TYPE_XDP, 1000 .errstr = "combined stack size", 1001 .result = REJECT, 1002}, 1003{ 1004 "calls: stack depth check using three frames. test1", 1005 .insns = { 1006 /* main */ 1007 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 4), /* call A */ 1008 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 5), /* call B */ 1009 BPF_ST_MEM(BPF_B, BPF_REG_10, -32, 0), 1010 BPF_MOV64_IMM(BPF_REG_0, 0), 1011 BPF_EXIT_INSN(), 1012 /* A */ 1013 BPF_ST_MEM(BPF_B, BPF_REG_10, -256, 0), 1014 BPF_EXIT_INSN(), 1015 /* B */ 1016 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, -3), /* call A */ 1017 BPF_ST_MEM(BPF_B, BPF_REG_10, -64, 0), 1018 BPF_EXIT_INSN(), 1019 }, 1020 .prog_type = BPF_PROG_TYPE_XDP, 1021 /* stack_main=32, stack_A=256, stack_B=64 1022 * and max(main+A, main+A+B) < 512 1023 */ 1024 .result = ACCEPT, 1025}, 1026{ 1027 "calls: stack depth check using three frames. test2", 1028 .insns = { 1029 /* main */ 1030 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 4), /* call A */ 1031 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 5), /* call B */ 1032 BPF_ST_MEM(BPF_B, BPF_REG_10, -32, 0), 1033 BPF_MOV64_IMM(BPF_REG_0, 0), 1034 BPF_EXIT_INSN(), 1035 /* A */ 1036 BPF_ST_MEM(BPF_B, BPF_REG_10, -64, 0), 1037 BPF_EXIT_INSN(), 1038 /* B */ 1039 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, -3), /* call A */ 1040 BPF_ST_MEM(BPF_B, BPF_REG_10, -256, 0), 1041 BPF_EXIT_INSN(), 1042 }, 1043 .prog_type = BPF_PROG_TYPE_XDP, 1044 /* stack_main=32, stack_A=64, stack_B=256 1045 * and max(main+A, main+A+B) < 512 1046 */ 1047 .result = ACCEPT, 1048}, 1049{ 1050 "calls: stack depth check using three frames. test3", 1051 .insns = { 1052 /* main */ 1053 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 1054 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 6), /* call A */ 1055 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), 1056 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 8), /* call B */ 1057 BPF_JMP_IMM(BPF_JGE, BPF_REG_6, 0, 1), 1058 BPF_ST_MEM(BPF_B, BPF_REG_10, -64, 0), 1059 BPF_MOV64_IMM(BPF_REG_0, 0), 1060 BPF_EXIT_INSN(), 1061 /* A */ 1062 BPF_JMP_IMM(BPF_JLT, BPF_REG_1, 10, 1), 1063 BPF_EXIT_INSN(), 1064 BPF_ST_MEM(BPF_B, BPF_REG_10, -224, 0), 1065 BPF_JMP_IMM(BPF_JA, 0, 0, -3), 1066 /* B */ 1067 BPF_JMP_IMM(BPF_JGT, BPF_REG_1, 2, 1), 1068 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, -6), /* call A */ 1069 BPF_ST_MEM(BPF_B, BPF_REG_10, -256, 0), 1070 BPF_EXIT_INSN(), 1071 }, 1072 .prog_type = BPF_PROG_TYPE_XDP, 1073 /* stack_main=64, stack_A=224, stack_B=256 1074 * and max(main+A, main+A+B) > 512 1075 */ 1076 .errstr = "combined stack", 1077 .result = REJECT, 1078}, 1079{ 1080 "calls: stack depth check using three frames. test4", 1081 /* void main(void) { 1082 * func1(0); 1083 * func1(1); 1084 * func2(1); 1085 * } 1086 * void func1(int alloc_or_recurse) { 1087 * if (alloc_or_recurse) { 1088 * frame_pointer[-300] = 1; 1089 * } else { 1090 * func2(alloc_or_recurse); 1091 * } 1092 * } 1093 * void func2(int alloc_or_recurse) { 1094 * if (alloc_or_recurse) { 1095 * frame_pointer[-300] = 1; 1096 * } 1097 * } 1098 */ 1099 .insns = { 1100 /* main */ 1101 BPF_MOV64_IMM(BPF_REG_1, 0), 1102 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 6), /* call A */ 1103 BPF_MOV64_IMM(BPF_REG_1, 1), 1104 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 4), /* call A */ 1105 BPF_MOV64_IMM(BPF_REG_1, 1), 1106 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 7), /* call B */ 1107 BPF_MOV64_IMM(BPF_REG_0, 0), 1108 BPF_EXIT_INSN(), 1109 /* A */ 1110 BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 2), 1111 BPF_ST_MEM(BPF_B, BPF_REG_10, -300, 0), 1112 BPF_EXIT_INSN(), 1113 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call B */ 1114 BPF_EXIT_INSN(), 1115 /* B */ 1116 BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 1), 1117 BPF_ST_MEM(BPF_B, BPF_REG_10, -300, 0), 1118 BPF_EXIT_INSN(), 1119 }, 1120 .prog_type = BPF_PROG_TYPE_XDP, 1121 .result = REJECT, 1122 .errstr = "combined stack", 1123}, 1124{ 1125 "calls: stack depth check using three frames. test5", 1126 .insns = { 1127 /* main */ 1128 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call A */ 1129 BPF_EXIT_INSN(), 1130 /* A */ 1131 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call B */ 1132 BPF_EXIT_INSN(), 1133 /* B */ 1134 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call C */ 1135 BPF_EXIT_INSN(), 1136 /* C */ 1137 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call D */ 1138 BPF_EXIT_INSN(), 1139 /* D */ 1140 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call E */ 1141 BPF_EXIT_INSN(), 1142 /* E */ 1143 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call F */ 1144 BPF_EXIT_INSN(), 1145 /* F */ 1146 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call G */ 1147 BPF_EXIT_INSN(), 1148 /* G */ 1149 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call H */ 1150 BPF_EXIT_INSN(), 1151 /* H */ 1152 BPF_MOV64_IMM(BPF_REG_0, 0), 1153 BPF_EXIT_INSN(), 1154 }, 1155 .prog_type = BPF_PROG_TYPE_XDP, 1156 .errstr = "call stack", 1157 .result = REJECT, 1158}, 1159{ 1160 "calls: stack depth check in dead code", 1161 .insns = { 1162 /* main */ 1163 BPF_MOV64_IMM(BPF_REG_1, 0), 1164 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call A */ 1165 BPF_EXIT_INSN(), 1166 /* A */ 1167 BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 1), 1168 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 2), /* call B */ 1169 BPF_MOV64_IMM(BPF_REG_0, 0), 1170 BPF_EXIT_INSN(), 1171 /* B */ 1172 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call C */ 1173 BPF_EXIT_INSN(), 1174 /* C */ 1175 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call D */ 1176 BPF_EXIT_INSN(), 1177 /* D */ 1178 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call E */ 1179 BPF_EXIT_INSN(), 1180 /* E */ 1181 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call F */ 1182 BPF_EXIT_INSN(), 1183 /* F */ 1184 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call G */ 1185 BPF_EXIT_INSN(), 1186 /* G */ 1187 BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call H */ 1188 BPF_EXIT_INSN(), 1189 /* H */ 1190 BPF_MOV64_IMM(BPF_REG_0, 0), 1191 BPF_EXIT_INSN(), 1192 }, 1193 .prog_type = BPF_PROG_TYPE_XDP, 1194 .errstr = "call stack", 1195 .result = REJECT, 1196}, 1197{ 1198 "calls: spill into caller stack frame", 1199 .insns = { 1200 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 1201 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 1202 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 1203 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 1204 BPF_EXIT_INSN(), 1205 BPF_STX_MEM(BPF_DW, BPF_REG_1, BPF_REG_1, 0), 1206 BPF_MOV64_IMM(BPF_REG_0, 0), 1207 BPF_EXIT_INSN(), 1208 }, 1209 .prog_type = BPF_PROG_TYPE_XDP, 1210 .errstr = "cannot spill", 1211 .result = REJECT, 1212}, 1213{ 1214 "calls: write into caller stack frame", 1215 .insns = { 1216 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 1217 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 1218 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 1219 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 1220 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_6, 0), 1221 BPF_EXIT_INSN(), 1222 BPF_ST_MEM(BPF_DW, BPF_REG_1, 0, 42), 1223 BPF_MOV64_IMM(BPF_REG_0, 0), 1224 BPF_EXIT_INSN(), 1225 }, 1226 .prog_type = BPF_PROG_TYPE_XDP, 1227 .result = ACCEPT, 1228 .retval = 42, 1229}, 1230{ 1231 "calls: write into callee stack frame", 1232 .insns = { 1233 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 1234 BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 42), 1235 BPF_EXIT_INSN(), 1236 BPF_MOV64_REG(BPF_REG_0, BPF_REG_10), 1237 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, -8), 1238 BPF_EXIT_INSN(), 1239 }, 1240 .prog_type = BPF_PROG_TYPE_XDP, 1241 .errstr = "cannot return stack pointer", 1242 .result = REJECT, 1243}, 1244{ 1245 "calls: two calls with stack write and void return", 1246 .insns = { 1247 /* main prog */ 1248 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 1249 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 1250 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 1251 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1252 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -16), 1253 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 1254 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_10, -16), 1255 BPF_EXIT_INSN(), 1256 1257 /* subprog 1 */ 1258 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 1259 BPF_MOV64_REG(BPF_REG_7, BPF_REG_2), 1260 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 1261 BPF_MOV64_REG(BPF_REG_1, BPF_REG_7), 1262 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 1263 BPF_EXIT_INSN(), 1264 1265 /* subprog 2 */ 1266 /* write into stack frame of main prog */ 1267 BPF_ST_MEM(BPF_DW, BPF_REG_1, 0, 0), 1268 BPF_EXIT_INSN(), /* void return */ 1269 }, 1270 .prog_type = BPF_PROG_TYPE_XDP, 1271 .result = ACCEPT, 1272}, 1273{ 1274 "calls: ambiguous return value", 1275 .insns = { 1276 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 1277 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 5), 1278 BPF_MOV64_REG(BPF_REG_1, BPF_REG_0), 1279 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), 1280 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 1281 BPF_MOV64_REG(BPF_REG_1, BPF_REG_0), 1282 BPF_EXIT_INSN(), 1283 BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 1), 1284 BPF_MOV64_IMM(BPF_REG_0, 0), 1285 BPF_EXIT_INSN(), 1286 }, 1287 .errstr_unpriv = "allowed for", 1288 .result_unpriv = REJECT, 1289 .errstr = "R0 !read_ok", 1290 .result = REJECT, 1291}, 1292{ 1293 "calls: two calls that return map_value", 1294 .insns = { 1295 /* main prog */ 1296 /* pass fp-16, fp-8 into a function */ 1297 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 1298 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 1299 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1300 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -16), 1301 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 8), 1302 1303 /* fetch map_value_ptr from the stack of this function */ 1304 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_10, -8), 1305 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 1), 1306 /* write into map value */ 1307 BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 0), 1308 /* fetch secound map_value_ptr from the stack */ 1309 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_10, -16), 1310 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 1), 1311 /* write into map value */ 1312 BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 0), 1313 BPF_MOV64_IMM(BPF_REG_0, 0), 1314 BPF_EXIT_INSN(), 1315 1316 /* subprog 1 */ 1317 /* call 3rd function twice */ 1318 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 1319 BPF_MOV64_REG(BPF_REG_7, BPF_REG_2), 1320 /* first time with fp-8 */ 1321 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 1322 BPF_MOV64_REG(BPF_REG_1, BPF_REG_7), 1323 /* second time with fp-16 */ 1324 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 1325 BPF_EXIT_INSN(), 1326 1327 /* subprog 2 */ 1328 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 1329 /* lookup from map */ 1330 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 1331 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1332 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 1333 BPF_LD_MAP_FD(BPF_REG_1, 0), 1334 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 1335 /* write map_value_ptr into stack frame of main prog */ 1336 BPF_STX_MEM(BPF_DW, BPF_REG_6, BPF_REG_0, 0), 1337 BPF_MOV64_IMM(BPF_REG_0, 0), 1338 BPF_EXIT_INSN(), /* return 0 */ 1339 }, 1340 .prog_type = BPF_PROG_TYPE_XDP, 1341 .fixup_map_hash_8b = { 23 }, 1342 .result = ACCEPT, 1343}, 1344{ 1345 "calls: two calls that return map_value with bool condition", 1346 .insns = { 1347 /* main prog */ 1348 /* pass fp-16, fp-8 into a function */ 1349 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 1350 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 1351 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1352 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -16), 1353 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 1354 BPF_MOV64_IMM(BPF_REG_0, 0), 1355 BPF_EXIT_INSN(), 1356 1357 /* subprog 1 */ 1358 /* call 3rd function twice */ 1359 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 1360 BPF_MOV64_REG(BPF_REG_7, BPF_REG_2), 1361 /* first time with fp-8 */ 1362 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 9), 1363 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 1, 2), 1364 /* fetch map_value_ptr from the stack of this function */ 1365 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_6, 0), 1366 /* write into map value */ 1367 BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 0), 1368 BPF_MOV64_REG(BPF_REG_1, BPF_REG_7), 1369 /* second time with fp-16 */ 1370 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 4), 1371 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 1, 2), 1372 /* fetch secound map_value_ptr from the stack */ 1373 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_7, 0), 1374 /* write into map value */ 1375 BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 0), 1376 BPF_EXIT_INSN(), 1377 1378 /* subprog 2 */ 1379 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 1380 /* lookup from map */ 1381 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 1382 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1383 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 1384 BPF_LD_MAP_FD(BPF_REG_1, 0), 1385 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 1386 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 2), 1387 BPF_MOV64_IMM(BPF_REG_0, 0), 1388 BPF_EXIT_INSN(), /* return 0 */ 1389 /* write map_value_ptr into stack frame of main prog */ 1390 BPF_STX_MEM(BPF_DW, BPF_REG_6, BPF_REG_0, 0), 1391 BPF_MOV64_IMM(BPF_REG_0, 1), 1392 BPF_EXIT_INSN(), /* return 1 */ 1393 }, 1394 .prog_type = BPF_PROG_TYPE_XDP, 1395 .fixup_map_hash_8b = { 23 }, 1396 .result = ACCEPT, 1397}, 1398{ 1399 "calls: two calls that return map_value with incorrect bool check", 1400 .insns = { 1401 /* main prog */ 1402 /* pass fp-16, fp-8 into a function */ 1403 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 1404 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 1405 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1406 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -16), 1407 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 1408 BPF_MOV64_IMM(BPF_REG_0, 0), 1409 BPF_EXIT_INSN(), 1410 1411 /* subprog 1 */ 1412 /* call 3rd function twice */ 1413 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 1414 BPF_MOV64_REG(BPF_REG_7, BPF_REG_2), 1415 /* first time with fp-8 */ 1416 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 9), 1417 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 1, 2), 1418 /* fetch map_value_ptr from the stack of this function */ 1419 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_6, 0), 1420 /* write into map value */ 1421 BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 0), 1422 BPF_MOV64_REG(BPF_REG_1, BPF_REG_7), 1423 /* second time with fp-16 */ 1424 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 4), 1425 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 2), 1426 /* fetch secound map_value_ptr from the stack */ 1427 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_7, 0), 1428 /* write into map value */ 1429 BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 0), 1430 BPF_EXIT_INSN(), 1431 1432 /* subprog 2 */ 1433 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 1434 /* lookup from map */ 1435 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 1436 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1437 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 1438 BPF_LD_MAP_FD(BPF_REG_1, 0), 1439 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 1440 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 2), 1441 BPF_MOV64_IMM(BPF_REG_0, 0), 1442 BPF_EXIT_INSN(), /* return 0 */ 1443 /* write map_value_ptr into stack frame of main prog */ 1444 BPF_STX_MEM(BPF_DW, BPF_REG_6, BPF_REG_0, 0), 1445 BPF_MOV64_IMM(BPF_REG_0, 1), 1446 BPF_EXIT_INSN(), /* return 1 */ 1447 }, 1448 .prog_type = BPF_PROG_TYPE_XDP, 1449 .fixup_map_hash_8b = { 23 }, 1450 .result = REJECT, 1451 .errstr = "invalid read from stack R7 off=-16 size=8", 1452}, 1453{ 1454 "calls: two calls that receive map_value via arg=ptr_stack_of_caller. test1", 1455 .insns = { 1456 /* main prog */ 1457 /* pass fp-16, fp-8 into a function */ 1458 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 1459 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 1460 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1461 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -16), 1462 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 1463 BPF_MOV64_IMM(BPF_REG_0, 0), 1464 BPF_EXIT_INSN(), 1465 1466 /* subprog 1 */ 1467 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 1468 BPF_MOV64_REG(BPF_REG_7, BPF_REG_2), 1469 /* 1st lookup from map */ 1470 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 1471 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1472 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 1473 BPF_LD_MAP_FD(BPF_REG_1, 0), 1474 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 1475 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 2), 1476 BPF_MOV64_IMM(BPF_REG_8, 0), 1477 BPF_JMP_IMM(BPF_JA, 0, 0, 2), 1478 /* write map_value_ptr into stack frame of main prog at fp-8 */ 1479 BPF_STX_MEM(BPF_DW, BPF_REG_6, BPF_REG_0, 0), 1480 BPF_MOV64_IMM(BPF_REG_8, 1), 1481 1482 /* 2nd lookup from map */ 1483 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /* 20 */ 1484 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 1485 BPF_LD_MAP_FD(BPF_REG_1, 0), 1486 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, /* 24 */ 1487 BPF_FUNC_map_lookup_elem), 1488 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 2), 1489 BPF_MOV64_IMM(BPF_REG_9, 0), 1490 BPF_JMP_IMM(BPF_JA, 0, 0, 2), 1491 /* write map_value_ptr into stack frame of main prog at fp-16 */ 1492 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1493 BPF_MOV64_IMM(BPF_REG_9, 1), 1494 1495 /* call 3rd func with fp-8, 0|1, fp-16, 0|1 */ 1496 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), /* 30 */ 1497 BPF_MOV64_REG(BPF_REG_2, BPF_REG_8), 1498 BPF_MOV64_REG(BPF_REG_3, BPF_REG_7), 1499 BPF_MOV64_REG(BPF_REG_4, BPF_REG_9), 1500 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), /* 34 */ 1501 BPF_EXIT_INSN(), 1502 1503 /* subprog 2 */ 1504 /* if arg2 == 1 do *arg1 = 0 */ 1505 BPF_JMP_IMM(BPF_JNE, BPF_REG_2, 1, 2), 1506 /* fetch map_value_ptr from the stack of this function */ 1507 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, 0), 1508 /* write into map value */ 1509 BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 0), 1510 1511 /* if arg4 == 1 do *arg3 = 0 */ 1512 BPF_JMP_IMM(BPF_JNE, BPF_REG_4, 1, 2), 1513 /* fetch map_value_ptr from the stack of this function */ 1514 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_3, 0), 1515 /* write into map value */ 1516 BPF_ST_MEM(BPF_DW, BPF_REG_0, 2, 0), 1517 BPF_EXIT_INSN(), 1518 }, 1519 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 1520 .fixup_map_hash_8b = { 12, 22 }, 1521 .result = REJECT, 1522 .errstr = "invalid access to map value, value_size=8 off=2 size=8", 1523 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 1524}, 1525{ 1526 "calls: two calls that receive map_value via arg=ptr_stack_of_caller. test2", 1527 .insns = { 1528 /* main prog */ 1529 /* pass fp-16, fp-8 into a function */ 1530 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 1531 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 1532 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1533 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -16), 1534 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 1535 BPF_MOV64_IMM(BPF_REG_0, 0), 1536 BPF_EXIT_INSN(), 1537 1538 /* subprog 1 */ 1539 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 1540 BPF_MOV64_REG(BPF_REG_7, BPF_REG_2), 1541 /* 1st lookup from map */ 1542 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 1543 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1544 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 1545 BPF_LD_MAP_FD(BPF_REG_1, 0), 1546 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 1547 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 2), 1548 BPF_MOV64_IMM(BPF_REG_8, 0), 1549 BPF_JMP_IMM(BPF_JA, 0, 0, 2), 1550 /* write map_value_ptr into stack frame of main prog at fp-8 */ 1551 BPF_STX_MEM(BPF_DW, BPF_REG_6, BPF_REG_0, 0), 1552 BPF_MOV64_IMM(BPF_REG_8, 1), 1553 1554 /* 2nd lookup from map */ 1555 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /* 20 */ 1556 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 1557 BPF_LD_MAP_FD(BPF_REG_1, 0), 1558 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, /* 24 */ 1559 BPF_FUNC_map_lookup_elem), 1560 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 2), 1561 BPF_MOV64_IMM(BPF_REG_9, 0), 1562 BPF_JMP_IMM(BPF_JA, 0, 0, 2), 1563 /* write map_value_ptr into stack frame of main prog at fp-16 */ 1564 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1565 BPF_MOV64_IMM(BPF_REG_9, 1), 1566 1567 /* call 3rd func with fp-8, 0|1, fp-16, 0|1 */ 1568 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), /* 30 */ 1569 BPF_MOV64_REG(BPF_REG_2, BPF_REG_8), 1570 BPF_MOV64_REG(BPF_REG_3, BPF_REG_7), 1571 BPF_MOV64_REG(BPF_REG_4, BPF_REG_9), 1572 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), /* 34 */ 1573 BPF_EXIT_INSN(), 1574 1575 /* subprog 2 */ 1576 /* if arg2 == 1 do *arg1 = 0 */ 1577 BPF_JMP_IMM(BPF_JNE, BPF_REG_2, 1, 2), 1578 /* fetch map_value_ptr from the stack of this function */ 1579 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, 0), 1580 /* write into map value */ 1581 BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 0), 1582 1583 /* if arg4 == 1 do *arg3 = 0 */ 1584 BPF_JMP_IMM(BPF_JNE, BPF_REG_4, 1, 2), 1585 /* fetch map_value_ptr from the stack of this function */ 1586 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_3, 0), 1587 /* write into map value */ 1588 BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 0), 1589 BPF_EXIT_INSN(), 1590 }, 1591 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 1592 .fixup_map_hash_8b = { 12, 22 }, 1593 .result = ACCEPT, 1594}, 1595{ 1596 "calls: two jumps that receive map_value via arg=ptr_stack_of_jumper. test3", 1597 .insns = { 1598 /* main prog */ 1599 /* pass fp-16, fp-8 into a function */ 1600 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 1601 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 1602 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1603 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -16), 1604 BPF_JMP_IMM(BPF_JNE, BPF_REG_1, 0, 2), 1605 BPF_MOV64_IMM(BPF_REG_0, 0), 1606 BPF_EXIT_INSN(), 1607 1608 /* subprog 1 */ 1609 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 1610 BPF_MOV64_REG(BPF_REG_7, BPF_REG_2), 1611 /* 1st lookup from map */ 1612 BPF_ST_MEM(BPF_DW, BPF_REG_10, -24, 0), 1613 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1614 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -24), 1615 BPF_LD_MAP_FD(BPF_REG_1, 0), 1616 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 1617 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 2), 1618 BPF_MOV64_IMM(BPF_REG_8, 0), 1619 BPF_JMP_IMM(BPF_JA, 0, 0, 2), 1620 /* write map_value_ptr into stack frame of main prog at fp-8 */ 1621 BPF_STX_MEM(BPF_DW, BPF_REG_6, BPF_REG_0, 0), 1622 BPF_MOV64_IMM(BPF_REG_8, 1), 1623 1624 /* 2nd lookup from map */ 1625 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1626 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -24), 1627 BPF_LD_MAP_FD(BPF_REG_1, 0), 1628 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 1629 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 2), 1630 BPF_MOV64_IMM(BPF_REG_9, 0), // 26 1631 BPF_JMP_IMM(BPF_JA, 0, 0, 2), 1632 /* write map_value_ptr into stack frame of main prog at fp-16 */ 1633 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1634 BPF_MOV64_IMM(BPF_REG_9, 1), 1635 1636 /* call 3rd func with fp-8, 0|1, fp-16, 0|1 */ 1637 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), // 30 1638 BPF_MOV64_REG(BPF_REG_2, BPF_REG_8), 1639 BPF_MOV64_REG(BPF_REG_3, BPF_REG_7), 1640 BPF_MOV64_REG(BPF_REG_4, BPF_REG_9), 1641 BPF_JMP_IMM(BPF_JNE, BPF_REG_1, 0, 1), // 34 1642 BPF_JMP_IMM(BPF_JA, 0, 0, -30), 1643 1644 /* subprog 2 */ 1645 /* if arg2 == 1 do *arg1 = 0 */ 1646 BPF_JMP_IMM(BPF_JNE, BPF_REG_2, 1, 2), 1647 /* fetch map_value_ptr from the stack of this function */ 1648 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, 0), 1649 /* write into map value */ 1650 BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 0), 1651 1652 /* if arg4 == 1 do *arg3 = 0 */ 1653 BPF_JMP_IMM(BPF_JNE, BPF_REG_4, 1, 2), 1654 /* fetch map_value_ptr from the stack of this function */ 1655 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_3, 0), 1656 /* write into map value */ 1657 BPF_ST_MEM(BPF_DW, BPF_REG_0, 2, 0), 1658 BPF_JMP_IMM(BPF_JA, 0, 0, -8), 1659 }, 1660 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 1661 .fixup_map_hash_8b = { 12, 22 }, 1662 .result = REJECT, 1663 .errstr = "invalid access to map value, value_size=8 off=2 size=8", 1664 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 1665}, 1666{ 1667 "calls: two calls that receive map_value_ptr_or_null via arg. test1", 1668 .insns = { 1669 /* main prog */ 1670 /* pass fp-16, fp-8 into a function */ 1671 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 1672 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 1673 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1674 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -16), 1675 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 1676 BPF_MOV64_IMM(BPF_REG_0, 0), 1677 BPF_EXIT_INSN(), 1678 1679 /* subprog 1 */ 1680 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 1681 BPF_MOV64_REG(BPF_REG_7, BPF_REG_2), 1682 /* 1st lookup from map */ 1683 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 1684 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1685 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 1686 BPF_LD_MAP_FD(BPF_REG_1, 0), 1687 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 1688 /* write map_value_ptr_or_null into stack frame of main prog at fp-8 */ 1689 BPF_STX_MEM(BPF_DW, BPF_REG_6, BPF_REG_0, 0), 1690 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 2), 1691 BPF_MOV64_IMM(BPF_REG_8, 0), 1692 BPF_JMP_IMM(BPF_JA, 0, 0, 1), 1693 BPF_MOV64_IMM(BPF_REG_8, 1), 1694 1695 /* 2nd lookup from map */ 1696 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1697 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 1698 BPF_LD_MAP_FD(BPF_REG_1, 0), 1699 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 1700 /* write map_value_ptr_or_null into stack frame of main prog at fp-16 */ 1701 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1702 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 2), 1703 BPF_MOV64_IMM(BPF_REG_9, 0), 1704 BPF_JMP_IMM(BPF_JA, 0, 0, 1), 1705 BPF_MOV64_IMM(BPF_REG_9, 1), 1706 1707 /* call 3rd func with fp-8, 0|1, fp-16, 0|1 */ 1708 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), 1709 BPF_MOV64_REG(BPF_REG_2, BPF_REG_8), 1710 BPF_MOV64_REG(BPF_REG_3, BPF_REG_7), 1711 BPF_MOV64_REG(BPF_REG_4, BPF_REG_9), 1712 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 1713 BPF_EXIT_INSN(), 1714 1715 /* subprog 2 */ 1716 /* if arg2 == 1 do *arg1 = 0 */ 1717 BPF_JMP_IMM(BPF_JNE, BPF_REG_2, 1, 2), 1718 /* fetch map_value_ptr from the stack of this function */ 1719 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, 0), 1720 /* write into map value */ 1721 BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 0), 1722 1723 /* if arg4 == 1 do *arg3 = 0 */ 1724 BPF_JMP_IMM(BPF_JNE, BPF_REG_4, 1, 2), 1725 /* fetch map_value_ptr from the stack of this function */ 1726 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_3, 0), 1727 /* write into map value */ 1728 BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 0), 1729 BPF_EXIT_INSN(), 1730 }, 1731 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 1732 .fixup_map_hash_8b = { 12, 22 }, 1733 .result = ACCEPT, 1734}, 1735{ 1736 "calls: two calls that receive map_value_ptr_or_null via arg. test2", 1737 .insns = { 1738 /* main prog */ 1739 /* pass fp-16, fp-8 into a function */ 1740 BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), 1741 BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), 1742 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1743 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -16), 1744 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 1745 BPF_MOV64_IMM(BPF_REG_0, 0), 1746 BPF_EXIT_INSN(), 1747 1748 /* subprog 1 */ 1749 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 1750 BPF_MOV64_REG(BPF_REG_7, BPF_REG_2), 1751 /* 1st lookup from map */ 1752 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 1753 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1754 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 1755 BPF_LD_MAP_FD(BPF_REG_1, 0), 1756 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 1757 /* write map_value_ptr_or_null into stack frame of main prog at fp-8 */ 1758 BPF_STX_MEM(BPF_DW, BPF_REG_6, BPF_REG_0, 0), 1759 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 2), 1760 BPF_MOV64_IMM(BPF_REG_8, 0), 1761 BPF_JMP_IMM(BPF_JA, 0, 0, 1), 1762 BPF_MOV64_IMM(BPF_REG_8, 1), 1763 1764 /* 2nd lookup from map */ 1765 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 1766 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 1767 BPF_LD_MAP_FD(BPF_REG_1, 0), 1768 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 1769 /* write map_value_ptr_or_null into stack frame of main prog at fp-16 */ 1770 BPF_STX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0), 1771 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 2), 1772 BPF_MOV64_IMM(BPF_REG_9, 0), 1773 BPF_JMP_IMM(BPF_JA, 0, 0, 1), 1774 BPF_MOV64_IMM(BPF_REG_9, 1), 1775 1776 /* call 3rd func with fp-8, 0|1, fp-16, 0|1 */ 1777 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), 1778 BPF_MOV64_REG(BPF_REG_2, BPF_REG_8), 1779 BPF_MOV64_REG(BPF_REG_3, BPF_REG_7), 1780 BPF_MOV64_REG(BPF_REG_4, BPF_REG_9), 1781 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 1782 BPF_EXIT_INSN(), 1783 1784 /* subprog 2 */ 1785 /* if arg2 == 1 do *arg1 = 0 */ 1786 BPF_JMP_IMM(BPF_JNE, BPF_REG_2, 1, 2), 1787 /* fetch map_value_ptr from the stack of this function */ 1788 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, 0), 1789 /* write into map value */ 1790 BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 0), 1791 1792 /* if arg4 == 0 do *arg3 = 0 */ 1793 BPF_JMP_IMM(BPF_JNE, BPF_REG_4, 0, 2), 1794 /* fetch map_value_ptr from the stack of this function */ 1795 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_3, 0), 1796 /* write into map value */ 1797 BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 0), 1798 BPF_EXIT_INSN(), 1799 }, 1800 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 1801 .fixup_map_hash_8b = { 12, 22 }, 1802 .result = REJECT, 1803 .errstr = "R0 invalid mem access 'scalar'", 1804}, 1805{ 1806 "calls: pkt_ptr spill into caller stack", 1807 .insns = { 1808 BPF_MOV64_REG(BPF_REG_4, BPF_REG_10), 1809 BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, -8), 1810 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 1), 1811 BPF_EXIT_INSN(), 1812 1813 /* subprog 1 */ 1814 BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 1815 offsetof(struct __sk_buff, data)), 1816 BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, 1817 offsetof(struct __sk_buff, data_end)), 1818 BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), 1819 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 8), 1820 /* spill unchecked pkt_ptr into stack of caller */ 1821 BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_2, 0), 1822 BPF_JMP_REG(BPF_JGT, BPF_REG_0, BPF_REG_3, 2), 1823 /* now the pkt range is verified, read pkt_ptr from stack */ 1824 BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_4, 0), 1825 /* write 4 bytes into packet */ 1826 BPF_ST_MEM(BPF_W, BPF_REG_2, 0, 0), 1827 BPF_EXIT_INSN(), 1828 }, 1829 .result = ACCEPT, 1830 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 1831 .retval = POINTER_VALUE, 1832 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 1833}, 1834{ 1835 "calls: pkt_ptr spill into caller stack 2", 1836 .insns = { 1837 BPF_MOV64_REG(BPF_REG_4, BPF_REG_10), 1838 BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, -8), 1839 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 1840 /* Marking is still kept, but not in all cases safe. */ 1841 BPF_LDX_MEM(BPF_DW, BPF_REG_4, BPF_REG_10, -8), 1842 BPF_ST_MEM(BPF_W, BPF_REG_4, 0, 0), 1843 BPF_EXIT_INSN(), 1844 1845 /* subprog 1 */ 1846 BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 1847 offsetof(struct __sk_buff, data)), 1848 BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, 1849 offsetof(struct __sk_buff, data_end)), 1850 BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), 1851 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 8), 1852 /* spill unchecked pkt_ptr into stack of caller */ 1853 BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_2, 0), 1854 BPF_JMP_REG(BPF_JGT, BPF_REG_0, BPF_REG_3, 2), 1855 /* now the pkt range is verified, read pkt_ptr from stack */ 1856 BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_4, 0), 1857 /* write 4 bytes into packet */ 1858 BPF_ST_MEM(BPF_W, BPF_REG_2, 0, 0), 1859 BPF_EXIT_INSN(), 1860 }, 1861 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 1862 .errstr = "invalid access to packet", 1863 .result = REJECT, 1864 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 1865}, 1866{ 1867 "calls: pkt_ptr spill into caller stack 3", 1868 .insns = { 1869 BPF_MOV64_REG(BPF_REG_4, BPF_REG_10), 1870 BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, -8), 1871 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 4), 1872 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2), 1873 /* Marking is still kept and safe here. */ 1874 BPF_LDX_MEM(BPF_DW, BPF_REG_4, BPF_REG_10, -8), 1875 BPF_ST_MEM(BPF_W, BPF_REG_4, 0, 0), 1876 BPF_EXIT_INSN(), 1877 1878 /* subprog 1 */ 1879 BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 1880 offsetof(struct __sk_buff, data)), 1881 BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, 1882 offsetof(struct __sk_buff, data_end)), 1883 BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), 1884 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 8), 1885 /* spill unchecked pkt_ptr into stack of caller */ 1886 BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_2, 0), 1887 BPF_MOV64_IMM(BPF_REG_5, 0), 1888 BPF_JMP_REG(BPF_JGT, BPF_REG_0, BPF_REG_3, 3), 1889 BPF_MOV64_IMM(BPF_REG_5, 1), 1890 /* now the pkt range is verified, read pkt_ptr from stack */ 1891 BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_4, 0), 1892 /* write 4 bytes into packet */ 1893 BPF_ST_MEM(BPF_W, BPF_REG_2, 0, 0), 1894 BPF_MOV64_REG(BPF_REG_0, BPF_REG_5), 1895 BPF_EXIT_INSN(), 1896 }, 1897 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 1898 .result = ACCEPT, 1899 .retval = 1, 1900 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 1901}, 1902{ 1903 "calls: pkt_ptr spill into caller stack 4", 1904 .insns = { 1905 BPF_MOV64_REG(BPF_REG_4, BPF_REG_10), 1906 BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, -8), 1907 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 4), 1908 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2), 1909 /* Check marking propagated. */ 1910 BPF_LDX_MEM(BPF_DW, BPF_REG_4, BPF_REG_10, -8), 1911 BPF_ST_MEM(BPF_W, BPF_REG_4, 0, 0), 1912 BPF_EXIT_INSN(), 1913 1914 /* subprog 1 */ 1915 BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 1916 offsetof(struct __sk_buff, data)), 1917 BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, 1918 offsetof(struct __sk_buff, data_end)), 1919 BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), 1920 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 8), 1921 /* spill unchecked pkt_ptr into stack of caller */ 1922 BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_2, 0), 1923 BPF_MOV64_IMM(BPF_REG_5, 0), 1924 BPF_JMP_REG(BPF_JGT, BPF_REG_0, BPF_REG_3, 2), 1925 BPF_MOV64_IMM(BPF_REG_5, 1), 1926 /* don't read back pkt_ptr from stack here */ 1927 /* write 4 bytes into packet */ 1928 BPF_ST_MEM(BPF_W, BPF_REG_2, 0, 0), 1929 BPF_MOV64_REG(BPF_REG_0, BPF_REG_5), 1930 BPF_EXIT_INSN(), 1931 }, 1932 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 1933 .result = ACCEPT, 1934 .retval = 1, 1935 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 1936}, 1937{ 1938 "calls: pkt_ptr spill into caller stack 5", 1939 .insns = { 1940 BPF_MOV64_REG(BPF_REG_4, BPF_REG_10), 1941 BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, -8), 1942 BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_1, 0), 1943 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 1944 BPF_LDX_MEM(BPF_DW, BPF_REG_4, BPF_REG_10, -8), 1945 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_4, 0), 1946 BPF_EXIT_INSN(), 1947 1948 /* subprog 1 */ 1949 BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 1950 offsetof(struct __sk_buff, data)), 1951 BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, 1952 offsetof(struct __sk_buff, data_end)), 1953 BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), 1954 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 8), 1955 BPF_MOV64_IMM(BPF_REG_5, 0), 1956 BPF_JMP_REG(BPF_JGT, BPF_REG_0, BPF_REG_3, 3), 1957 /* spill checked pkt_ptr into stack of caller */ 1958 BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_2, 0), 1959 BPF_MOV64_IMM(BPF_REG_5, 1), 1960 /* don't read back pkt_ptr from stack here */ 1961 /* write 4 bytes into packet */ 1962 BPF_ST_MEM(BPF_W, BPF_REG_2, 0, 0), 1963 BPF_MOV64_REG(BPF_REG_0, BPF_REG_5), 1964 BPF_EXIT_INSN(), 1965 }, 1966 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 1967 .errstr = "same insn cannot be used with different", 1968 .result = REJECT, 1969 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 1970}, 1971{ 1972 "calls: pkt_ptr spill into caller stack 6", 1973 .insns = { 1974 BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 1975 offsetof(struct __sk_buff, data_end)), 1976 BPF_MOV64_REG(BPF_REG_4, BPF_REG_10), 1977 BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, -8), 1978 BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_2, 0), 1979 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 1980 BPF_LDX_MEM(BPF_DW, BPF_REG_4, BPF_REG_10, -8), 1981 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_4, 0), 1982 BPF_EXIT_INSN(), 1983 1984 /* subprog 1 */ 1985 BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 1986 offsetof(struct __sk_buff, data)), 1987 BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, 1988 offsetof(struct __sk_buff, data_end)), 1989 BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), 1990 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 8), 1991 BPF_MOV64_IMM(BPF_REG_5, 0), 1992 BPF_JMP_REG(BPF_JGT, BPF_REG_0, BPF_REG_3, 3), 1993 /* spill checked pkt_ptr into stack of caller */ 1994 BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_2, 0), 1995 BPF_MOV64_IMM(BPF_REG_5, 1), 1996 /* don't read back pkt_ptr from stack here */ 1997 /* write 4 bytes into packet */ 1998 BPF_ST_MEM(BPF_W, BPF_REG_2, 0, 0), 1999 BPF_MOV64_REG(BPF_REG_0, BPF_REG_5), 2000 BPF_EXIT_INSN(), 2001 }, 2002 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 2003 .errstr = "R4 invalid mem access", 2004 .result = REJECT, 2005 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 2006}, 2007{ 2008 "calls: pkt_ptr spill into caller stack 7", 2009 .insns = { 2010 BPF_MOV64_IMM(BPF_REG_2, 0), 2011 BPF_MOV64_REG(BPF_REG_4, BPF_REG_10), 2012 BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, -8), 2013 BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_2, 0), 2014 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 2015 BPF_LDX_MEM(BPF_DW, BPF_REG_4, BPF_REG_10, -8), 2016 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_4, 0), 2017 BPF_EXIT_INSN(), 2018 2019 /* subprog 1 */ 2020 BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 2021 offsetof(struct __sk_buff, data)), 2022 BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, 2023 offsetof(struct __sk_buff, data_end)), 2024 BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), 2025 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 8), 2026 BPF_MOV64_IMM(BPF_REG_5, 0), 2027 BPF_JMP_REG(BPF_JGT, BPF_REG_0, BPF_REG_3, 3), 2028 /* spill checked pkt_ptr into stack of caller */ 2029 BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_2, 0), 2030 BPF_MOV64_IMM(BPF_REG_5, 1), 2031 /* don't read back pkt_ptr from stack here */ 2032 /* write 4 bytes into packet */ 2033 BPF_ST_MEM(BPF_W, BPF_REG_2, 0, 0), 2034 BPF_MOV64_REG(BPF_REG_0, BPF_REG_5), 2035 BPF_EXIT_INSN(), 2036 }, 2037 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 2038 .errstr = "R4 invalid mem access", 2039 .result = REJECT, 2040 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 2041}, 2042{ 2043 "calls: pkt_ptr spill into caller stack 8", 2044 .insns = { 2045 BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 2046 offsetof(struct __sk_buff, data)), 2047 BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, 2048 offsetof(struct __sk_buff, data_end)), 2049 BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), 2050 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 8), 2051 BPF_JMP_REG(BPF_JLE, BPF_REG_0, BPF_REG_3, 1), 2052 BPF_EXIT_INSN(), 2053 BPF_MOV64_REG(BPF_REG_4, BPF_REG_10), 2054 BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, -8), 2055 BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_2, 0), 2056 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 2057 BPF_LDX_MEM(BPF_DW, BPF_REG_4, BPF_REG_10, -8), 2058 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_4, 0), 2059 BPF_EXIT_INSN(), 2060 2061 /* subprog 1 */ 2062 BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 2063 offsetof(struct __sk_buff, data)), 2064 BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, 2065 offsetof(struct __sk_buff, data_end)), 2066 BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), 2067 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 8), 2068 BPF_MOV64_IMM(BPF_REG_5, 0), 2069 BPF_JMP_REG(BPF_JGT, BPF_REG_0, BPF_REG_3, 3), 2070 /* spill checked pkt_ptr into stack of caller */ 2071 BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_2, 0), 2072 BPF_MOV64_IMM(BPF_REG_5, 1), 2073 /* don't read back pkt_ptr from stack here */ 2074 /* write 4 bytes into packet */ 2075 BPF_ST_MEM(BPF_W, BPF_REG_2, 0, 0), 2076 BPF_MOV64_REG(BPF_REG_0, BPF_REG_5), 2077 BPF_EXIT_INSN(), 2078 }, 2079 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 2080 .result = ACCEPT, 2081 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 2082}, 2083{ 2084 "calls: pkt_ptr spill into caller stack 9", 2085 .insns = { 2086 BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 2087 offsetof(struct __sk_buff, data)), 2088 BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, 2089 offsetof(struct __sk_buff, data_end)), 2090 BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), 2091 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 8), 2092 BPF_JMP_REG(BPF_JLE, BPF_REG_0, BPF_REG_3, 1), 2093 BPF_EXIT_INSN(), 2094 BPF_MOV64_REG(BPF_REG_4, BPF_REG_10), 2095 BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, -8), 2096 BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_2, 0), 2097 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 3), 2098 BPF_LDX_MEM(BPF_DW, BPF_REG_4, BPF_REG_10, -8), 2099 BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_4, 0), 2100 BPF_EXIT_INSN(), 2101 2102 /* subprog 1 */ 2103 BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 2104 offsetof(struct __sk_buff, data)), 2105 BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, 2106 offsetof(struct __sk_buff, data_end)), 2107 BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), 2108 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 8), 2109 BPF_MOV64_IMM(BPF_REG_5, 0), 2110 /* spill unchecked pkt_ptr into stack of caller */ 2111 BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_2, 0), 2112 BPF_JMP_REG(BPF_JGT, BPF_REG_0, BPF_REG_3, 2), 2113 BPF_MOV64_IMM(BPF_REG_5, 1), 2114 /* don't read back pkt_ptr from stack here */ 2115 /* write 4 bytes into packet */ 2116 BPF_ST_MEM(BPF_W, BPF_REG_2, 0, 0), 2117 BPF_MOV64_REG(BPF_REG_0, BPF_REG_5), 2118 BPF_EXIT_INSN(), 2119 }, 2120 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 2121 .errstr = "invalid access to packet", 2122 .result = REJECT, 2123 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 2124}, 2125{ 2126 "calls: caller stack init to zero or map_value_or_null", 2127 .insns = { 2128 BPF_MOV64_IMM(BPF_REG_0, 0), 2129 BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -8), 2130 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 2131 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 2132 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 4), 2133 /* fetch map_value_or_null or const_zero from stack */ 2134 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_10, -8), 2135 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 1), 2136 /* store into map_value */ 2137 BPF_ST_MEM(BPF_W, BPF_REG_0, 0, 0), 2138 BPF_EXIT_INSN(), 2139 2140 /* subprog 1 */ 2141 /* if (ctx == 0) return; */ 2142 BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 8), 2143 /* else bpf_map_lookup() and *(fp - 8) = r0 */ 2144 BPF_MOV64_REG(BPF_REG_6, BPF_REG_2), 2145 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 2146 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 2147 BPF_LD_MAP_FD(BPF_REG_1, 0), 2148 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 2149 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 2150 /* write map_value_ptr_or_null into stack frame of main prog at fp-8 */ 2151 BPF_STX_MEM(BPF_DW, BPF_REG_6, BPF_REG_0, 0), 2152 BPF_EXIT_INSN(), 2153 }, 2154 .fixup_map_hash_8b = { 13 }, 2155 .result = ACCEPT, 2156 .prog_type = BPF_PROG_TYPE_XDP, 2157}, 2158{ 2159 "calls: stack init to zero and pruning", 2160 .insns = { 2161 /* first make allocated_stack 16 byte */ 2162 BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, 0), 2163 /* now fork the execution such that the false branch 2164 * of JGT insn will be verified second and it skisp zero 2165 * init of fp-8 stack slot. If stack liveness marking 2166 * is missing live_read marks from call map_lookup 2167 * processing then pruning will incorrectly assume 2168 * that fp-8 stack slot was unused in the fall-through 2169 * branch and will accept the program incorrectly 2170 */ 2171 BPF_JMP_IMM(BPF_JGT, BPF_REG_1, 2, 2), 2172 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 2173 BPF_JMP_IMM(BPF_JA, 0, 0, 0), 2174 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 2175 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 2176 BPF_LD_MAP_FD(BPF_REG_1, 0), 2177 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 2178 BPF_EXIT_INSN(), 2179 }, 2180 .fixup_map_hash_48b = { 6 }, 2181 .errstr = "invalid indirect read from stack R2 off -8+0 size 8", 2182 .result = REJECT, 2183 .prog_type = BPF_PROG_TYPE_XDP, 2184}, 2185{ 2186 "calls: ctx read at start of subprog", 2187 .insns = { 2188 BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), 2189 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 5), 2190 BPF_JMP_REG(BPF_JSGT, BPF_REG_0, BPF_REG_0, 0), 2191 BPF_MOV64_REG(BPF_REG_1, BPF_REG_6), 2192 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2), 2193 BPF_MOV64_REG(BPF_REG_1, BPF_REG_0), 2194 BPF_EXIT_INSN(), 2195 BPF_LDX_MEM(BPF_B, BPF_REG_9, BPF_REG_1, 0), 2196 BPF_MOV64_IMM(BPF_REG_0, 0), 2197 BPF_EXIT_INSN(), 2198 }, 2199 .prog_type = BPF_PROG_TYPE_SOCKET_FILTER, 2200 .errstr_unpriv = "loading/calling other bpf or kernel functions are allowed for", 2201 .result_unpriv = REJECT, 2202 .result = ACCEPT, 2203}, 2204{ 2205 "calls: cross frame pruning", 2206 .insns = { 2207 /* r8 = !!random(); 2208 * call pruner() 2209 * if (r8) 2210 * do something bad; 2211 */ 2212 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_get_prandom_u32), 2213 BPF_MOV64_IMM(BPF_REG_8, 0), 2214 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), 2215 BPF_MOV64_IMM(BPF_REG_8, 1), 2216 BPF_MOV64_REG(BPF_REG_1, BPF_REG_8), 2217 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 4), 2218 BPF_JMP_IMM(BPF_JEQ, BPF_REG_8, 1, 1), 2219 BPF_LDX_MEM(BPF_B, BPF_REG_9, BPF_REG_1, 0), 2220 BPF_MOV64_IMM(BPF_REG_0, 0), 2221 BPF_EXIT_INSN(), 2222 BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 0), 2223 BPF_EXIT_INSN(), 2224 }, 2225 .prog_type = BPF_PROG_TYPE_SOCKET_FILTER, 2226 .errstr_unpriv = "loading/calling other bpf or kernel functions are allowed for", 2227 .errstr = "!read_ok", 2228 .result = REJECT, 2229}, 2230{ 2231 "calls: cross frame pruning - liveness propagation", 2232 .insns = { 2233 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_get_prandom_u32), 2234 BPF_MOV64_IMM(BPF_REG_8, 0), 2235 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), 2236 BPF_MOV64_IMM(BPF_REG_8, 1), 2237 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_get_prandom_u32), 2238 BPF_MOV64_IMM(BPF_REG_9, 0), 2239 BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1), 2240 BPF_MOV64_IMM(BPF_REG_9, 1), 2241 BPF_MOV64_REG(BPF_REG_1, BPF_REG_0), 2242 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 4), 2243 BPF_JMP_IMM(BPF_JEQ, BPF_REG_8, 1, 1), 2244 BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_2, 0), 2245 BPF_MOV64_IMM(BPF_REG_0, 0), 2246 BPF_EXIT_INSN(), 2247 BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 0), 2248 BPF_EXIT_INSN(), 2249 }, 2250 .prog_type = BPF_PROG_TYPE_SOCKET_FILTER, 2251 .errstr_unpriv = "loading/calling other bpf or kernel functions are allowed for", 2252 .errstr = "!read_ok", 2253 .result = REJECT, 2254},