1 { 2 "jset32: BPF_K", 3 .insns = { 4 BPF_DIRECT_PKT_R2, 5 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 6 /* reg, high bits shouldn't be tested */ 7 BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, -2, 1), 8 BPF_JMP_IMM(BPF_JA, 0, 0, 1), 9 BPF_EXIT_INSN(), 10 11 BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, 1, 1), 12 BPF_EXIT_INSN(), 13 BPF_MOV64_IMM(BPF_REG_0, 2), 14 BPF_EXIT_INSN(), 15 }, 16 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 17 .result = ACCEPT, 18 .runs = 3, 19 .retvals = { 20 { .retval = 0, 21 .data64 = { 1ULL << 63, } 22 }, 23 { .retval = 2, 24 .data64 = { 1, } 25 }, 26 { .retval = 2, 27 .data64 = { 1ULL << 63 | 1, } 28 }, 29 }, 30 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 31 }, 32 { 33 "jset32: BPF_X", 34 .insns = { 35 BPF_DIRECT_PKT_R2, 36 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 37 BPF_LD_IMM64(BPF_REG_8, 0x8000000000000000), 38 BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1), 39 BPF_JMP_IMM(BPF_JA, 0, 0, 1), 40 BPF_EXIT_INSN(), 41 42 BPF_LD_IMM64(BPF_REG_8, 0x8000000000000001), 43 BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1), 44 BPF_EXIT_INSN(), 45 BPF_MOV64_IMM(BPF_REG_0, 2), 46 BPF_EXIT_INSN(), 47 }, 48 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 49 .result = ACCEPT, 50 .runs = 3, 51 .retvals = { 52 { .retval = 0, 53 .data64 = { 1ULL << 63, } 54 }, 55 { .retval = 2, 56 .data64 = { 1, } 57 }, 58 { .retval = 2, 59 .data64 = { 1ULL << 63 | 1, } 60 }, 61 }, 62 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 63 }, 64 { 65 "jset32: ignores upper bits", 66 .insns = { 67 BPF_MOV64_IMM(BPF_REG_0, 0), 68 BPF_LD_IMM64(BPF_REG_7, 0x8000000000000000), 69 BPF_LD_IMM64(BPF_REG_8, 0x8000000000000000), 70 BPF_JMP_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1), 71 BPF_EXIT_INSN(), 72 BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1), 73 BPF_MOV64_IMM(BPF_REG_0, 2), 74 BPF_EXIT_INSN(), 75 }, 76 .result = ACCEPT, 77 .retval = 2, 78 }, 79 { 80 "jset32: min/max deduction", 81 .insns = { 82 BPF_RAND_UEXT_R7, 83 BPF_MOV64_IMM(BPF_REG_0, 0), 84 BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, 0x10, 1), 85 BPF_EXIT_INSN(), 86 BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, 0x10, 1), 87 /* unpriv: nospec (inserted to prevent "R9 !read_ok") */ 88 BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0), 89 BPF_EXIT_INSN(), 90 }, 91 .result = ACCEPT, 92 }, 93 { 94 "jeq32: BPF_K", 95 .insns = { 96 BPF_DIRECT_PKT_R2, 97 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 98 BPF_JMP32_IMM(BPF_JEQ, BPF_REG_7, -1, 1), 99 BPF_EXIT_INSN(), 100 BPF_MOV64_IMM(BPF_REG_0, 2), 101 BPF_EXIT_INSN(), 102 }, 103 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 104 .result = ACCEPT, 105 .runs = 2, 106 .retvals = { 107 { .retval = 0, 108 .data64 = { -2, } 109 }, 110 { .retval = 2, 111 .data64 = { -1, } 112 }, 113 }, 114 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 115 }, 116 { 117 "jeq32: BPF_X", 118 .insns = { 119 BPF_DIRECT_PKT_R2, 120 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 121 BPF_LD_IMM64(BPF_REG_8, 0x7000000000000001), 122 BPF_JMP32_REG(BPF_JEQ, BPF_REG_7, BPF_REG_8, 1), 123 BPF_EXIT_INSN(), 124 BPF_MOV64_IMM(BPF_REG_0, 2), 125 BPF_EXIT_INSN(), 126 }, 127 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 128 .result = ACCEPT, 129 .runs = 3, 130 .retvals = { 131 { .retval = 0, 132 .data64 = { 2, } 133 }, 134 { .retval = 2, 135 .data64 = { 1, } 136 }, 137 { .retval = 2, 138 .data64 = { 1ULL << 63 | 1, } 139 }, 140 }, 141 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 142 }, 143 { 144 "jeq32: min/max deduction", 145 .insns = { 146 BPF_RAND_UEXT_R7, 147 BPF_MOV64_IMM(BPF_REG_0, 0), 148 BPF_JMP32_IMM(BPF_JEQ, BPF_REG_7, 0x10, 1), 149 BPF_EXIT_INSN(), 150 BPF_JMP32_IMM(BPF_JSGE, BPF_REG_7, 0xf, 1), 151 /* unpriv: nospec (inserted to prevent "R9 !read_ok") */ 152 BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0), 153 BPF_EXIT_INSN(), 154 }, 155 .result = ACCEPT, 156 }, 157 { 158 "jne32: BPF_K", 159 .insns = { 160 BPF_DIRECT_PKT_R2, 161 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 162 BPF_JMP32_IMM(BPF_JNE, BPF_REG_7, -1, 1), 163 BPF_EXIT_INSN(), 164 BPF_MOV64_IMM(BPF_REG_0, 2), 165 BPF_EXIT_INSN(), 166 }, 167 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 168 .result = ACCEPT, 169 .runs = 2, 170 .retvals = { 171 { .retval = 2, 172 .data64 = { 1, } 173 }, 174 { .retval = 0, 175 .data64 = { -1, } 176 }, 177 }, 178 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 179 }, 180 { 181 "jne32: BPF_X", 182 .insns = { 183 BPF_DIRECT_PKT_R2, 184 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 185 BPF_LD_IMM64(BPF_REG_8, 0x8000000000000001), 186 BPF_JMP32_REG(BPF_JNE, BPF_REG_7, BPF_REG_8, 1), 187 BPF_EXIT_INSN(), 188 BPF_MOV64_IMM(BPF_REG_0, 2), 189 BPF_EXIT_INSN(), 190 }, 191 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 192 .result = ACCEPT, 193 .runs = 3, 194 .retvals = { 195 { .retval = 0, 196 .data64 = { 1, } 197 }, 198 { .retval = 2, 199 .data64 = { 2, } 200 }, 201 { .retval = 2, 202 .data64 = { 1ULL << 63 | 2, } 203 }, 204 }, 205 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 206 }, 207 { 208 "jne32: min/max deduction", 209 .insns = { 210 BPF_RAND_UEXT_R7, 211 BPF_MOV64_IMM(BPF_REG_0, 0), 212 BPF_JMP32_IMM(BPF_JNE, BPF_REG_7, 0x10, 1), 213 BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 0x10, 1), 214 BPF_EXIT_INSN(), 215 /* unpriv: nospec (inserted to prevent "R9 !read_ok") */ 216 BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0), 217 BPF_EXIT_INSN(), 218 }, 219 .result = ACCEPT, 220 }, 221 { 222 "jge32: BPF_K", 223 .insns = { 224 BPF_DIRECT_PKT_R2, 225 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 226 BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, UINT_MAX - 1, 1), 227 BPF_EXIT_INSN(), 228 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 229 BPF_EXIT_INSN(), 230 }, 231 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 232 .result = ACCEPT, 233 .runs = 3, 234 .retvals = { 235 { .retval = 2, 236 .data64 = { UINT_MAX, } 237 }, 238 { .retval = 2, 239 .data64 = { UINT_MAX - 1, } 240 }, 241 { .retval = 0, 242 .data64 = { 0, } 243 }, 244 }, 245 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 246 }, 247 { 248 "jge32: BPF_X", 249 .insns = { 250 BPF_DIRECT_PKT_R2, 251 BPF_LD_IMM64(BPF_REG_8, UINT_MAX | 1ULL << 32), 252 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 253 BPF_JMP32_REG(BPF_JGE, BPF_REG_7, BPF_REG_8, 1), 254 BPF_EXIT_INSN(), 255 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 256 BPF_EXIT_INSN(), 257 }, 258 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 259 .result = ACCEPT, 260 .runs = 3, 261 .retvals = { 262 { .retval = 2, 263 .data64 = { UINT_MAX, } 264 }, 265 { .retval = 0, 266 .data64 = { INT_MAX, } 267 }, 268 { .retval = 0, 269 .data64 = { (UINT_MAX - 1) | 2ULL << 32, } 270 }, 271 }, 272 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 273 }, 274 { 275 "jge32: min/max deduction", 276 .insns = { 277 BPF_RAND_UEXT_R7, 278 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 279 BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32), 280 BPF_JMP32_REG(BPF_JGE, BPF_REG_7, BPF_REG_8, 1), 281 BPF_EXIT_INSN(), 282 BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, 0x7ffffff0, 1), 283 /* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */ 284 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0), 285 BPF_EXIT_INSN(), 286 }, 287 .result = ACCEPT, 288 .retval = 2, 289 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 290 }, 291 { 292 "jgt32: BPF_K", 293 .insns = { 294 BPF_DIRECT_PKT_R2, 295 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 296 BPF_JMP32_IMM(BPF_JGT, BPF_REG_7, UINT_MAX - 1, 1), 297 BPF_EXIT_INSN(), 298 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 299 BPF_EXIT_INSN(), 300 }, 301 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 302 .result = ACCEPT, 303 .runs = 3, 304 .retvals = { 305 { .retval = 2, 306 .data64 = { UINT_MAX, } 307 }, 308 { .retval = 0, 309 .data64 = { UINT_MAX - 1, } 310 }, 311 { .retval = 0, 312 .data64 = { 0, } 313 }, 314 }, 315 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 316 }, 317 { 318 "jgt32: BPF_X", 319 .insns = { 320 BPF_DIRECT_PKT_R2, 321 BPF_LD_IMM64(BPF_REG_8, (UINT_MAX - 1) | 1ULL << 32), 322 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 323 BPF_JMP32_REG(BPF_JGT, BPF_REG_7, BPF_REG_8, 1), 324 BPF_EXIT_INSN(), 325 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 326 BPF_EXIT_INSN(), 327 }, 328 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 329 .result = ACCEPT, 330 .runs = 3, 331 .retvals = { 332 { .retval = 2, 333 .data64 = { UINT_MAX, } 334 }, 335 { .retval = 0, 336 .data64 = { UINT_MAX - 1, } 337 }, 338 { .retval = 0, 339 .data64 = { (UINT_MAX - 1) | 2ULL << 32, } 340 }, 341 }, 342 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 343 }, 344 { 345 "jgt32: min/max deduction", 346 .insns = { 347 BPF_RAND_UEXT_R7, 348 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 349 BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32), 350 BPF_JMP32_REG(BPF_JGT, BPF_REG_7, BPF_REG_8, 1), 351 BPF_EXIT_INSN(), 352 BPF_JMP_IMM(BPF_JGT, BPF_REG_7, 0x7ffffff0, 1), 353 /* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */ 354 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0), 355 BPF_EXIT_INSN(), 356 }, 357 .result = ACCEPT, 358 .retval = 2, 359 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 360 }, 361 { 362 "jle32: BPF_K", 363 .insns = { 364 BPF_DIRECT_PKT_R2, 365 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 366 BPF_JMP32_IMM(BPF_JLE, BPF_REG_7, INT_MAX, 1), 367 BPF_EXIT_INSN(), 368 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 369 BPF_EXIT_INSN(), 370 }, 371 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 372 .result = ACCEPT, 373 .runs = 3, 374 .retvals = { 375 { .retval = 2, 376 .data64 = { INT_MAX - 1, } 377 }, 378 { .retval = 0, 379 .data64 = { UINT_MAX, } 380 }, 381 { .retval = 2, 382 .data64 = { INT_MAX, } 383 }, 384 }, 385 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 386 }, 387 { 388 "jle32: BPF_X", 389 .insns = { 390 BPF_DIRECT_PKT_R2, 391 BPF_LD_IMM64(BPF_REG_8, (INT_MAX - 1) | 2ULL << 32), 392 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 393 BPF_JMP32_REG(BPF_JLE, BPF_REG_7, BPF_REG_8, 1), 394 BPF_EXIT_INSN(), 395 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 396 BPF_EXIT_INSN(), 397 }, 398 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 399 .result = ACCEPT, 400 .runs = 3, 401 .retvals = { 402 { .retval = 0, 403 .data64 = { INT_MAX | 1ULL << 32, } 404 }, 405 { .retval = 2, 406 .data64 = { INT_MAX - 2, } 407 }, 408 { .retval = 0, 409 .data64 = { UINT_MAX, } 410 }, 411 }, 412 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 413 }, 414 { 415 "jle32: min/max deduction", 416 .insns = { 417 BPF_RAND_UEXT_R7, 418 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 419 BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32), 420 BPF_JMP32_REG(BPF_JLE, BPF_REG_7, BPF_REG_8, 1), 421 BPF_EXIT_INSN(), 422 BPF_JMP32_IMM(BPF_JLE, BPF_REG_7, 0x7ffffff0, 1), 423 /* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */ 424 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0), 425 BPF_EXIT_INSN(), 426 }, 427 .result = ACCEPT, 428 .retval = 2, 429 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 430 }, 431 { 432 "jlt32: BPF_K", 433 .insns = { 434 BPF_DIRECT_PKT_R2, 435 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 436 BPF_JMP32_IMM(BPF_JLT, BPF_REG_7, INT_MAX, 1), 437 BPF_EXIT_INSN(), 438 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 439 BPF_EXIT_INSN(), 440 }, 441 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 442 .result = ACCEPT, 443 .runs = 3, 444 .retvals = { 445 { .retval = 0, 446 .data64 = { INT_MAX, } 447 }, 448 { .retval = 0, 449 .data64 = { UINT_MAX, } 450 }, 451 { .retval = 2, 452 .data64 = { INT_MAX - 1, } 453 }, 454 }, 455 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 456 }, 457 { 458 "jlt32: BPF_X", 459 .insns = { 460 BPF_DIRECT_PKT_R2, 461 BPF_LD_IMM64(BPF_REG_8, INT_MAX | 2ULL << 32), 462 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 463 BPF_JMP32_REG(BPF_JLT, BPF_REG_7, BPF_REG_8, 1), 464 BPF_EXIT_INSN(), 465 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 466 BPF_EXIT_INSN(), 467 }, 468 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 469 .result = ACCEPT, 470 .runs = 3, 471 .retvals = { 472 { .retval = 0, 473 .data64 = { INT_MAX | 1ULL << 32, } 474 }, 475 { .retval = 0, 476 .data64 = { UINT_MAX, } 477 }, 478 { .retval = 2, 479 .data64 = { (INT_MAX - 1) | 3ULL << 32, } 480 }, 481 }, 482 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 483 }, 484 { 485 "jlt32: min/max deduction", 486 .insns = { 487 BPF_RAND_UEXT_R7, 488 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 489 BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32), 490 BPF_JMP32_REG(BPF_JLT, BPF_REG_7, BPF_REG_8, 1), 491 BPF_EXIT_INSN(), 492 BPF_JMP_IMM(BPF_JSLT, BPF_REG_7, 0x7ffffff0, 1), 493 /* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */ 494 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0), 495 BPF_EXIT_INSN(), 496 }, 497 .result = ACCEPT, 498 .retval = 2, 499 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 500 }, 501 { 502 "jsge32: BPF_K", 503 .insns = { 504 BPF_DIRECT_PKT_R2, 505 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 506 BPF_JMP32_IMM(BPF_JSGE, BPF_REG_7, -1, 1), 507 BPF_EXIT_INSN(), 508 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 509 BPF_EXIT_INSN(), 510 }, 511 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 512 .result = ACCEPT, 513 .runs = 3, 514 .retvals = { 515 { .retval = 2, 516 .data64 = { 0, } 517 }, 518 { .retval = 2, 519 .data64 = { -1, } 520 }, 521 { .retval = 0, 522 .data64 = { -2, } 523 }, 524 }, 525 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 526 }, 527 { 528 "jsge32: BPF_X", 529 .insns = { 530 BPF_DIRECT_PKT_R2, 531 BPF_LD_IMM64(BPF_REG_8, (__u32)-1 | 2ULL << 32), 532 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 533 BPF_JMP32_REG(BPF_JSGE, BPF_REG_7, BPF_REG_8, 1), 534 BPF_EXIT_INSN(), 535 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 536 BPF_EXIT_INSN(), 537 }, 538 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 539 .result = ACCEPT, 540 .runs = 3, 541 .retvals = { 542 { .retval = 2, 543 .data64 = { -1, } 544 }, 545 { .retval = 2, 546 .data64 = { 0x7fffffff | 1ULL << 32, } 547 }, 548 { .retval = 0, 549 .data64 = { -2, } 550 }, 551 }, 552 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 553 }, 554 { 555 "jsge32: min/max deduction", 556 .insns = { 557 BPF_RAND_UEXT_R7, 558 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 559 BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32), 560 BPF_JMP32_REG(BPF_JSGE, BPF_REG_7, BPF_REG_8, 1), 561 BPF_EXIT_INSN(), 562 BPF_JMP_IMM(BPF_JSGE, BPF_REG_7, 0x7ffffff0, 1), 563 /* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */ 564 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0), 565 BPF_EXIT_INSN(), 566 }, 567 .result = ACCEPT, 568 .retval = 2, 569 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 570 }, 571 { 572 "jsgt32: BPF_K", 573 .insns = { 574 BPF_DIRECT_PKT_R2, 575 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 576 BPF_JMP32_IMM(BPF_JSGT, BPF_REG_7, -1, 1), 577 BPF_EXIT_INSN(), 578 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 579 BPF_EXIT_INSN(), 580 }, 581 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 582 .result = ACCEPT, 583 .runs = 3, 584 .retvals = { 585 { .retval = 0, 586 .data64 = { (__u32)-2, } 587 }, 588 { .retval = 0, 589 .data64 = { -1, } 590 }, 591 { .retval = 2, 592 .data64 = { 1, } 593 }, 594 }, 595 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 596 }, 597 { 598 "jsgt32: BPF_X", 599 .insns = { 600 BPF_DIRECT_PKT_R2, 601 BPF_LD_IMM64(BPF_REG_8, 0x7ffffffe | 1ULL << 32), 602 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 603 BPF_JMP32_REG(BPF_JSGT, BPF_REG_7, BPF_REG_8, 1), 604 BPF_EXIT_INSN(), 605 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 606 BPF_EXIT_INSN(), 607 }, 608 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 609 .result = ACCEPT, 610 .runs = 3, 611 .retvals = { 612 { .retval = 0, 613 .data64 = { 0x7ffffffe, } 614 }, 615 { .retval = 0, 616 .data64 = { 0x1ffffffffULL, } 617 }, 618 { .retval = 2, 619 .data64 = { 0x7fffffff, } 620 }, 621 }, 622 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 623 }, 624 { 625 "jsgt32: min/max deduction", 626 .insns = { 627 BPF_RAND_SEXT_R7, 628 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 629 BPF_LD_IMM64(BPF_REG_8, (__u32)(-2) | 1ULL << 32), 630 BPF_JMP32_REG(BPF_JSGT, BPF_REG_7, BPF_REG_8, 1), 631 BPF_EXIT_INSN(), 632 BPF_JMP_IMM(BPF_JSGT, BPF_REG_7, -2, 1), 633 /* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */ 634 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0), 635 BPF_EXIT_INSN(), 636 }, 637 .result = ACCEPT, 638 .retval = 2, 639 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 640 }, 641 { 642 "jsle32: BPF_K", 643 .insns = { 644 BPF_DIRECT_PKT_R2, 645 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 646 BPF_JMP32_IMM(BPF_JSLE, BPF_REG_7, -1, 1), 647 BPF_EXIT_INSN(), 648 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 649 BPF_EXIT_INSN(), 650 }, 651 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 652 .result = ACCEPT, 653 .runs = 3, 654 .retvals = { 655 { .retval = 2, 656 .data64 = { (__u32)-2, } 657 }, 658 { .retval = 2, 659 .data64 = { -1, } 660 }, 661 { .retval = 0, 662 .data64 = { 1, } 663 }, 664 }, 665 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 666 }, 667 { 668 "jsle32: BPF_X", 669 .insns = { 670 BPF_DIRECT_PKT_R2, 671 BPF_LD_IMM64(BPF_REG_8, 0x7ffffffe | 1ULL << 32), 672 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 673 BPF_JMP32_REG(BPF_JSLE, BPF_REG_7, BPF_REG_8, 1), 674 BPF_EXIT_INSN(), 675 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 676 BPF_EXIT_INSN(), 677 }, 678 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 679 .result = ACCEPT, 680 .runs = 3, 681 .retvals = { 682 { .retval = 2, 683 .data64 = { 0x7ffffffe, } 684 }, 685 { .retval = 2, 686 .data64 = { (__u32)-1, } 687 }, 688 { .retval = 0, 689 .data64 = { 0x7fffffff | 2ULL << 32, } 690 }, 691 }, 692 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 693 }, 694 { 695 "jsle32: min/max deduction", 696 .insns = { 697 BPF_RAND_UEXT_R7, 698 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 699 BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32), 700 BPF_JMP32_REG(BPF_JSLE, BPF_REG_7, BPF_REG_8, 1), 701 BPF_EXIT_INSN(), 702 BPF_JMP_IMM(BPF_JSLE, BPF_REG_7, 0x7ffffff0, 1), 703 /* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */ 704 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0), 705 BPF_EXIT_INSN(), 706 }, 707 .result = ACCEPT, 708 .retval = 2, 709 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 710 }, 711 { 712 "jslt32: BPF_K", 713 .insns = { 714 BPF_DIRECT_PKT_R2, 715 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 716 BPF_JMP32_IMM(BPF_JSLT, BPF_REG_7, -1, 1), 717 BPF_EXIT_INSN(), 718 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 719 BPF_EXIT_INSN(), 720 }, 721 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 722 .result = ACCEPT, 723 .runs = 3, 724 .retvals = { 725 { .retval = 2, 726 .data64 = { (__u32)-2, } 727 }, 728 { .retval = 0, 729 .data64 = { -1, } 730 }, 731 { .retval = 0, 732 .data64 = { 1, } 733 }, 734 }, 735 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 736 }, 737 { 738 "jslt32: BPF_X", 739 .insns = { 740 BPF_DIRECT_PKT_R2, 741 BPF_LD_IMM64(BPF_REG_8, 0x7fffffff | 1ULL << 32), 742 BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0), 743 BPF_JMP32_REG(BPF_JSLT, BPF_REG_7, BPF_REG_8, 1), 744 BPF_EXIT_INSN(), 745 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 746 BPF_EXIT_INSN(), 747 }, 748 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 749 .result = ACCEPT, 750 .runs = 3, 751 .retvals = { 752 { .retval = 2, 753 .data64 = { 0x7ffffffe, } 754 }, 755 { .retval = 2, 756 .data64 = { 0xffffffff, } 757 }, 758 { .retval = 0, 759 .data64 = { 0x7fffffff | 2ULL << 32, } 760 }, 761 }, 762 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 763 }, 764 { 765 "jslt32: min/max deduction", 766 .insns = { 767 BPF_RAND_SEXT_R7, 768 BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2), 769 BPF_LD_IMM64(BPF_REG_8, (__u32)(-1) | 1ULL << 32), 770 BPF_JMP32_REG(BPF_JSLT, BPF_REG_7, BPF_REG_8, 1), 771 BPF_EXIT_INSN(), 772 BPF_JMP32_IMM(BPF_JSLT, BPF_REG_7, -1, 1), 773 /* unpriv: nospec (inserted to prevent "R0 invalid mem access 'scalar'") */ 774 BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0), 775 BPF_EXIT_INSN(), 776 }, 777 .result = ACCEPT, 778 .retval = 2, 779 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 780 }, 781 { 782 "jgt32: range bound deduction, reg op imm", 783 .insns = { 784 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 785 BPF_MOV64_REG(BPF_REG_8, BPF_REG_1), 786 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 787 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 788 BPF_LD_MAP_FD(BPF_REG_1, 0), 789 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 790 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9), 791 BPF_MOV64_REG(BPF_REG_1, BPF_REG_8), 792 BPF_MOV64_REG(BPF_REG_8, BPF_REG_0), 793 BPF_EMIT_CALL(BPF_FUNC_get_cgroup_classid), 794 BPF_JMP32_IMM(BPF_JGT, BPF_REG_0, 1, 5), 795 BPF_MOV32_REG(BPF_REG_6, BPF_REG_0), 796 BPF_ALU64_IMM(BPF_LSH, BPF_REG_6, 32), 797 BPF_ALU64_IMM(BPF_RSH, BPF_REG_6, 32), 798 BPF_ALU64_REG(BPF_ADD, BPF_REG_8, BPF_REG_6), 799 BPF_ST_MEM(BPF_B, BPF_REG_8, 0, 0), 800 BPF_MOV32_IMM(BPF_REG_0, 0), 801 BPF_EXIT_INSN(), 802 }, 803 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 804 .fixup_map_hash_48b = { 4 }, 805 .result = ACCEPT, 806 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 807 }, 808 { 809 "jgt32: range bound deduction, reg1 op reg2, reg1 unknown", 810 .insns = { 811 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 812 BPF_MOV64_REG(BPF_REG_8, BPF_REG_1), 813 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 814 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 815 BPF_LD_MAP_FD(BPF_REG_1, 0), 816 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 817 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 10), 818 BPF_MOV64_REG(BPF_REG_1, BPF_REG_8), 819 BPF_MOV64_REG(BPF_REG_8, BPF_REG_0), 820 BPF_EMIT_CALL(BPF_FUNC_get_cgroup_classid), 821 BPF_MOV32_IMM(BPF_REG_2, 1), 822 BPF_JMP32_REG(BPF_JGT, BPF_REG_0, BPF_REG_2, 5), 823 BPF_MOV32_REG(BPF_REG_6, BPF_REG_0), 824 BPF_ALU64_IMM(BPF_LSH, BPF_REG_6, 32), 825 BPF_ALU64_IMM(BPF_RSH, BPF_REG_6, 32), 826 BPF_ALU64_REG(BPF_ADD, BPF_REG_8, BPF_REG_6), 827 BPF_ST_MEM(BPF_B, BPF_REG_8, 0, 0), 828 BPF_MOV32_IMM(BPF_REG_0, 0), 829 BPF_EXIT_INSN(), 830 }, 831 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 832 .fixup_map_hash_48b = { 4 }, 833 .result = ACCEPT, 834 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 835 }, 836 { 837 "jle32: range bound deduction, reg1 op reg2, reg2 unknown", 838 .insns = { 839 BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0), 840 BPF_MOV64_REG(BPF_REG_8, BPF_REG_1), 841 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), 842 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8), 843 BPF_LD_MAP_FD(BPF_REG_1, 0), 844 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), 845 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 10), 846 BPF_MOV64_REG(BPF_REG_1, BPF_REG_8), 847 BPF_MOV64_REG(BPF_REG_8, BPF_REG_0), 848 BPF_EMIT_CALL(BPF_FUNC_get_cgroup_classid), 849 BPF_MOV32_IMM(BPF_REG_2, 1), 850 BPF_JMP32_REG(BPF_JLE, BPF_REG_2, BPF_REG_0, 5), 851 BPF_MOV32_REG(BPF_REG_6, BPF_REG_0), 852 BPF_ALU64_IMM(BPF_LSH, BPF_REG_6, 32), 853 BPF_ALU64_IMM(BPF_RSH, BPF_REG_6, 32), 854 BPF_ALU64_REG(BPF_ADD, BPF_REG_8, BPF_REG_6), 855 BPF_ST_MEM(BPF_B, BPF_REG_8, 0, 0), 856 BPF_MOV32_IMM(BPF_REG_0, 0), 857 BPF_EXIT_INSN(), 858 }, 859 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 860 .fixup_map_hash_48b = { 4 }, 861 .result = ACCEPT, 862 .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS, 863 }, 864 { 865 "jeq32/jne32: bounds checking", 866 .insns = { 867 BPF_MOV64_IMM(BPF_REG_6, 563), 868 BPF_MOV64_IMM(BPF_REG_2, 0), 869 BPF_ALU64_IMM(BPF_NEG, BPF_REG_2, 0), 870 BPF_ALU64_IMM(BPF_NEG, BPF_REG_2, 0), 871 BPF_ALU32_REG(BPF_OR, BPF_REG_2, BPF_REG_6), 872 BPF_JMP32_IMM(BPF_JNE, BPF_REG_2, 8, 5), 873 BPF_JMP_IMM(BPF_JSGE, BPF_REG_2, 500, 2), 874 BPF_MOV64_IMM(BPF_REG_0, 2), 875 BPF_EXIT_INSN(), 876 BPF_MOV64_REG(BPF_REG_0, BPF_REG_4), 877 BPF_EXIT_INSN(), 878 BPF_MOV64_IMM(BPF_REG_0, 1), 879 BPF_EXIT_INSN(), 880 }, 881 .prog_type = BPF_PROG_TYPE_SCHED_CLS, 882 .result = ACCEPT, 883 .retval = 1, 884 }, 885