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         .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 'inv'",
 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 'inv'",
 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 'inv'",
 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 'inv'",
 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 'inv'",
 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 'inv'",
 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 'inv'",
 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 'inv'",
 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 },