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