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