tools/testing/selftests/bpf/verifier/jmp32.c

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