Back to home page

OSCL-LXR
 
 

     

0001 {
0002     "jset32: BPF_K",
0003     .insns = {
0004     BPF_DIRECT_PKT_R2,
0005     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0006     /* reg, high bits shouldn't be tested */
0007     BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, -2, 1),
0008     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0009     BPF_EXIT_INSN(),
0010 
0011     BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, 1, 1),
0012     BPF_EXIT_INSN(),
0013     BPF_MOV64_IMM(BPF_REG_0, 2),
0014     BPF_EXIT_INSN(),
0015     },
0016     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0017     .result = ACCEPT,
0018     .runs = 3,
0019     .retvals = {
0020         { .retval = 0,
0021           .data64 = { 1ULL << 63, }
0022         },
0023         { .retval = 2,
0024           .data64 = { 1, }
0025         },
0026         { .retval = 2,
0027           .data64 = { 1ULL << 63 | 1, }
0028         },
0029     },
0030     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0031 },
0032 {
0033     "jset32: BPF_X",
0034     .insns = {
0035     BPF_DIRECT_PKT_R2,
0036     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0037     BPF_LD_IMM64(BPF_REG_8, 0x8000000000000000),
0038     BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
0039     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0040     BPF_EXIT_INSN(),
0041 
0042     BPF_LD_IMM64(BPF_REG_8, 0x8000000000000001),
0043     BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
0044     BPF_EXIT_INSN(),
0045     BPF_MOV64_IMM(BPF_REG_0, 2),
0046     BPF_EXIT_INSN(),
0047     },
0048     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0049     .result = ACCEPT,
0050     .runs = 3,
0051     .retvals = {
0052         { .retval = 0,
0053           .data64 = { 1ULL << 63, }
0054         },
0055         { .retval = 2,
0056           .data64 = { 1, }
0057         },
0058         { .retval = 2,
0059           .data64 = { 1ULL << 63 | 1, }
0060         },
0061     },
0062     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0063 },
0064 {
0065     "jset32: ignores upper bits",
0066     .insns = {
0067     BPF_MOV64_IMM(BPF_REG_0, 0),
0068     BPF_LD_IMM64(BPF_REG_7, 0x8000000000000000),
0069     BPF_LD_IMM64(BPF_REG_8, 0x8000000000000000),
0070     BPF_JMP_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
0071     BPF_EXIT_INSN(),
0072     BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
0073     BPF_MOV64_IMM(BPF_REG_0, 2),
0074     BPF_EXIT_INSN(),
0075     },
0076     .result = ACCEPT,
0077     .retval = 2,
0078 },
0079 {
0080     "jset32: min/max deduction",
0081     .insns = {
0082     BPF_RAND_UEXT_R7,
0083     BPF_MOV64_IMM(BPF_REG_0, 0),
0084     BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, 0x10, 1),
0085     BPF_EXIT_INSN(),
0086     BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, 0x10, 1),
0087     BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
0088     BPF_EXIT_INSN(),
0089     },
0090     .errstr_unpriv = "R9 !read_ok",
0091     .result_unpriv = REJECT,
0092     .result = ACCEPT,
0093 },
0094 {
0095     "jeq32: BPF_K",
0096     .insns = {
0097     BPF_DIRECT_PKT_R2,
0098     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0099     BPF_JMP32_IMM(BPF_JEQ, BPF_REG_7, -1, 1),
0100     BPF_EXIT_INSN(),
0101     BPF_MOV64_IMM(BPF_REG_0, 2),
0102     BPF_EXIT_INSN(),
0103     },
0104     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0105     .result = ACCEPT,
0106     .runs = 2,
0107     .retvals = {
0108         { .retval = 0,
0109           .data64 = { -2, }
0110         },
0111         { .retval = 2,
0112           .data64 = { -1, }
0113         },
0114     },
0115     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0116 },
0117 {
0118     "jeq32: BPF_X",
0119     .insns = {
0120     BPF_DIRECT_PKT_R2,
0121     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0122     BPF_LD_IMM64(BPF_REG_8, 0x7000000000000001),
0123     BPF_JMP32_REG(BPF_JEQ, BPF_REG_7, BPF_REG_8, 1),
0124     BPF_EXIT_INSN(),
0125     BPF_MOV64_IMM(BPF_REG_0, 2),
0126     BPF_EXIT_INSN(),
0127     },
0128     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0129     .result = ACCEPT,
0130     .runs = 3,
0131     .retvals = {
0132         { .retval = 0,
0133           .data64 = { 2, }
0134         },
0135         { .retval = 2,
0136           .data64 = { 1, }
0137         },
0138         { .retval = 2,
0139           .data64 = { 1ULL << 63 | 1, }
0140         },
0141     },
0142     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0143 },
0144 {
0145     "jeq32: min/max deduction",
0146     .insns = {
0147     BPF_RAND_UEXT_R7,
0148     BPF_MOV64_IMM(BPF_REG_0, 0),
0149     BPF_JMP32_IMM(BPF_JEQ, BPF_REG_7, 0x10, 1),
0150     BPF_EXIT_INSN(),
0151     BPF_JMP32_IMM(BPF_JSGE, BPF_REG_7, 0xf, 1),
0152     BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
0153     BPF_EXIT_INSN(),
0154     },
0155     .errstr_unpriv = "R9 !read_ok",
0156     .result_unpriv = REJECT,
0157     .result = ACCEPT,
0158 },
0159 {
0160     "jne32: BPF_K",
0161     .insns = {
0162     BPF_DIRECT_PKT_R2,
0163     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0164     BPF_JMP32_IMM(BPF_JNE, BPF_REG_7, -1, 1),
0165     BPF_EXIT_INSN(),
0166     BPF_MOV64_IMM(BPF_REG_0, 2),
0167     BPF_EXIT_INSN(),
0168     },
0169     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0170     .result = ACCEPT,
0171     .runs = 2,
0172     .retvals = {
0173         { .retval = 2,
0174           .data64 = { 1, }
0175         },
0176         { .retval = 0,
0177           .data64 = { -1, }
0178         },
0179     },
0180     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0181 },
0182 {
0183     "jne32: BPF_X",
0184     .insns = {
0185     BPF_DIRECT_PKT_R2,
0186     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0187     BPF_LD_IMM64(BPF_REG_8, 0x8000000000000001),
0188     BPF_JMP32_REG(BPF_JNE, BPF_REG_7, BPF_REG_8, 1),
0189     BPF_EXIT_INSN(),
0190     BPF_MOV64_IMM(BPF_REG_0, 2),
0191     BPF_EXIT_INSN(),
0192     },
0193     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0194     .result = ACCEPT,
0195     .runs = 3,
0196     .retvals = {
0197         { .retval = 0,
0198           .data64 = { 1, }
0199         },
0200         { .retval = 2,
0201           .data64 = { 2, }
0202         },
0203         { .retval = 2,
0204           .data64 = { 1ULL << 63 | 2, }
0205         },
0206     },
0207     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0208 },
0209 {
0210     "jne32: min/max deduction",
0211     .insns = {
0212     BPF_RAND_UEXT_R7,
0213     BPF_MOV64_IMM(BPF_REG_0, 0),
0214     BPF_JMP32_IMM(BPF_JNE, BPF_REG_7, 0x10, 1),
0215     BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 0x10, 1),
0216     BPF_EXIT_INSN(),
0217     BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
0218     BPF_EXIT_INSN(),
0219     },
0220     .errstr_unpriv = "R9 !read_ok",
0221     .result_unpriv = REJECT,
0222     .result = ACCEPT,
0223 },
0224 {
0225     "jge32: BPF_K",
0226     .insns = {
0227     BPF_DIRECT_PKT_R2,
0228     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0229     BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, UINT_MAX - 1, 1),
0230     BPF_EXIT_INSN(),
0231     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0232     BPF_EXIT_INSN(),
0233     },
0234     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0235     .result = ACCEPT,
0236     .runs = 3,
0237     .retvals = {
0238         { .retval = 2,
0239           .data64 = { UINT_MAX, }
0240         },
0241         { .retval = 2,
0242           .data64 = { UINT_MAX - 1, }
0243         },
0244         { .retval = 0,
0245           .data64 = { 0, }
0246         },
0247     },
0248     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0249 },
0250 {
0251     "jge32: BPF_X",
0252     .insns = {
0253     BPF_DIRECT_PKT_R2,
0254     BPF_LD_IMM64(BPF_REG_8, UINT_MAX | 1ULL << 32),
0255     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0256     BPF_JMP32_REG(BPF_JGE, BPF_REG_7, BPF_REG_8, 1),
0257     BPF_EXIT_INSN(),
0258     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0259     BPF_EXIT_INSN(),
0260     },
0261     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0262     .result = ACCEPT,
0263     .runs = 3,
0264     .retvals = {
0265         { .retval = 2,
0266           .data64 = { UINT_MAX, }
0267         },
0268         { .retval = 0,
0269           .data64 = { INT_MAX, }
0270         },
0271         { .retval = 0,
0272           .data64 = { (UINT_MAX - 1) | 2ULL << 32, }
0273         },
0274     },
0275     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0276 },
0277 {
0278     "jge32: min/max deduction",
0279     .insns = {
0280     BPF_RAND_UEXT_R7,
0281     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0282     BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
0283     BPF_JMP32_REG(BPF_JGE, BPF_REG_7, BPF_REG_8, 1),
0284     BPF_EXIT_INSN(),
0285     BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, 0x7ffffff0, 1),
0286     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
0287     BPF_EXIT_INSN(),
0288     },
0289     .errstr_unpriv = "R0 invalid mem access 'scalar'",
0290     .result_unpriv = REJECT,
0291     .result = ACCEPT,
0292     .retval = 2,
0293 },
0294 {
0295     "jgt32: BPF_K",
0296     .insns = {
0297     BPF_DIRECT_PKT_R2,
0298     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0299     BPF_JMP32_IMM(BPF_JGT, BPF_REG_7, UINT_MAX - 1, 1),
0300     BPF_EXIT_INSN(),
0301     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0302     BPF_EXIT_INSN(),
0303     },
0304     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0305     .result = ACCEPT,
0306     .runs = 3,
0307     .retvals = {
0308         { .retval = 2,
0309           .data64 = { UINT_MAX, }
0310         },
0311         { .retval = 0,
0312           .data64 = { UINT_MAX - 1, }
0313         },
0314         { .retval = 0,
0315           .data64 = { 0, }
0316         },
0317     },
0318     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0319 },
0320 {
0321     "jgt32: BPF_X",
0322     .insns = {
0323     BPF_DIRECT_PKT_R2,
0324     BPF_LD_IMM64(BPF_REG_8, (UINT_MAX - 1) | 1ULL << 32),
0325     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0326     BPF_JMP32_REG(BPF_JGT, BPF_REG_7, BPF_REG_8, 1),
0327     BPF_EXIT_INSN(),
0328     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0329     BPF_EXIT_INSN(),
0330     },
0331     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0332     .result = ACCEPT,
0333     .runs = 3,
0334     .retvals = {
0335         { .retval = 2,
0336           .data64 = { UINT_MAX, }
0337         },
0338         { .retval = 0,
0339           .data64 = { UINT_MAX - 1, }
0340         },
0341         { .retval = 0,
0342           .data64 = { (UINT_MAX - 1) | 2ULL << 32, }
0343         },
0344     },
0345     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0346 },
0347 {
0348     "jgt32: min/max deduction",
0349     .insns = {
0350     BPF_RAND_UEXT_R7,
0351     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0352     BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
0353     BPF_JMP32_REG(BPF_JGT, BPF_REG_7, BPF_REG_8, 1),
0354     BPF_EXIT_INSN(),
0355     BPF_JMP_IMM(BPF_JGT, BPF_REG_7, 0x7ffffff0, 1),
0356     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
0357     BPF_EXIT_INSN(),
0358     },
0359     .errstr_unpriv = "R0 invalid mem access 'scalar'",
0360     .result_unpriv = REJECT,
0361     .result = ACCEPT,
0362     .retval = 2,
0363 },
0364 {
0365     "jle32: BPF_K",
0366     .insns = {
0367     BPF_DIRECT_PKT_R2,
0368     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0369     BPF_JMP32_IMM(BPF_JLE, BPF_REG_7, INT_MAX, 1),
0370     BPF_EXIT_INSN(),
0371     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0372     BPF_EXIT_INSN(),
0373     },
0374     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0375     .result = ACCEPT,
0376     .runs = 3,
0377     .retvals = {
0378         { .retval = 2,
0379           .data64 = { INT_MAX - 1, }
0380         },
0381         { .retval = 0,
0382           .data64 = { UINT_MAX, }
0383         },
0384         { .retval = 2,
0385           .data64 = { INT_MAX, }
0386         },
0387     },
0388     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0389 },
0390 {
0391     "jle32: BPF_X",
0392     .insns = {
0393     BPF_DIRECT_PKT_R2,
0394     BPF_LD_IMM64(BPF_REG_8, (INT_MAX - 1) | 2ULL << 32),
0395     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0396     BPF_JMP32_REG(BPF_JLE, BPF_REG_7, BPF_REG_8, 1),
0397     BPF_EXIT_INSN(),
0398     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0399     BPF_EXIT_INSN(),
0400     },
0401     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0402     .result = ACCEPT,
0403     .runs = 3,
0404     .retvals = {
0405         { .retval = 0,
0406           .data64 = { INT_MAX | 1ULL << 32, }
0407         },
0408         { .retval = 2,
0409           .data64 = { INT_MAX - 2, }
0410         },
0411         { .retval = 0,
0412           .data64 = { UINT_MAX, }
0413         },
0414     },
0415     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0416 },
0417 {
0418     "jle32: min/max deduction",
0419     .insns = {
0420     BPF_RAND_UEXT_R7,
0421     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0422     BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
0423     BPF_JMP32_REG(BPF_JLE, BPF_REG_7, BPF_REG_8, 1),
0424     BPF_EXIT_INSN(),
0425     BPF_JMP32_IMM(BPF_JLE, BPF_REG_7, 0x7ffffff0, 1),
0426     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
0427     BPF_EXIT_INSN(),
0428     },
0429     .errstr_unpriv = "R0 invalid mem access 'scalar'",
0430     .result_unpriv = REJECT,
0431     .result = ACCEPT,
0432     .retval = 2,
0433 },
0434 {
0435     "jlt32: BPF_K",
0436     .insns = {
0437     BPF_DIRECT_PKT_R2,
0438     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0439     BPF_JMP32_IMM(BPF_JLT, BPF_REG_7, INT_MAX, 1),
0440     BPF_EXIT_INSN(),
0441     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0442     BPF_EXIT_INSN(),
0443     },
0444     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0445     .result = ACCEPT,
0446     .runs = 3,
0447     .retvals = {
0448         { .retval = 0,
0449           .data64 = { INT_MAX, }
0450         },
0451         { .retval = 0,
0452           .data64 = { UINT_MAX, }
0453         },
0454         { .retval = 2,
0455           .data64 = { INT_MAX - 1, }
0456         },
0457     },
0458     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0459 },
0460 {
0461     "jlt32: BPF_X",
0462     .insns = {
0463     BPF_DIRECT_PKT_R2,
0464     BPF_LD_IMM64(BPF_REG_8, INT_MAX | 2ULL << 32),
0465     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0466     BPF_JMP32_REG(BPF_JLT, BPF_REG_7, BPF_REG_8, 1),
0467     BPF_EXIT_INSN(),
0468     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0469     BPF_EXIT_INSN(),
0470     },
0471     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0472     .result = ACCEPT,
0473     .runs = 3,
0474     .retvals = {
0475         { .retval = 0,
0476           .data64 = { INT_MAX | 1ULL << 32, }
0477         },
0478         { .retval = 0,
0479           .data64 = { UINT_MAX, }
0480         },
0481         { .retval = 2,
0482           .data64 = { (INT_MAX - 1) | 3ULL << 32, }
0483         },
0484     },
0485     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0486 },
0487 {
0488     "jlt32: min/max deduction",
0489     .insns = {
0490     BPF_RAND_UEXT_R7,
0491     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0492     BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
0493     BPF_JMP32_REG(BPF_JLT, BPF_REG_7, BPF_REG_8, 1),
0494     BPF_EXIT_INSN(),
0495     BPF_JMP_IMM(BPF_JSLT, BPF_REG_7, 0x7ffffff0, 1),
0496     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
0497     BPF_EXIT_INSN(),
0498     },
0499     .errstr_unpriv = "R0 invalid mem access 'scalar'",
0500     .result_unpriv = REJECT,
0501     .result = ACCEPT,
0502     .retval = 2,
0503 },
0504 {
0505     "jsge32: BPF_K",
0506     .insns = {
0507     BPF_DIRECT_PKT_R2,
0508     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0509     BPF_JMP32_IMM(BPF_JSGE, BPF_REG_7, -1, 1),
0510     BPF_EXIT_INSN(),
0511     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0512     BPF_EXIT_INSN(),
0513     },
0514     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0515     .result = ACCEPT,
0516     .runs = 3,
0517     .retvals = {
0518         { .retval = 2,
0519           .data64 = { 0, }
0520         },
0521         { .retval = 2,
0522           .data64 = { -1, }
0523         },
0524         { .retval = 0,
0525           .data64 = { -2, }
0526         },
0527     },
0528     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0529 },
0530 {
0531     "jsge32: BPF_X",
0532     .insns = {
0533     BPF_DIRECT_PKT_R2,
0534     BPF_LD_IMM64(BPF_REG_8, (__u32)-1 | 2ULL << 32),
0535     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0536     BPF_JMP32_REG(BPF_JSGE, BPF_REG_7, BPF_REG_8, 1),
0537     BPF_EXIT_INSN(),
0538     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0539     BPF_EXIT_INSN(),
0540     },
0541     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0542     .result = ACCEPT,
0543     .runs = 3,
0544     .retvals = {
0545         { .retval = 2,
0546           .data64 = { -1, }
0547         },
0548         { .retval = 2,
0549           .data64 = { 0x7fffffff | 1ULL << 32, }
0550         },
0551         { .retval = 0,
0552           .data64 = { -2, }
0553         },
0554     },
0555     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0556 },
0557 {
0558     "jsge32: min/max deduction",
0559     .insns = {
0560     BPF_RAND_UEXT_R7,
0561     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0562     BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
0563     BPF_JMP32_REG(BPF_JSGE, BPF_REG_7, BPF_REG_8, 1),
0564     BPF_EXIT_INSN(),
0565     BPF_JMP_IMM(BPF_JSGE, BPF_REG_7, 0x7ffffff0, 1),
0566     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
0567     BPF_EXIT_INSN(),
0568     },
0569     .errstr_unpriv = "R0 invalid mem access 'scalar'",
0570     .result_unpriv = REJECT,
0571     .result = ACCEPT,
0572     .retval = 2,
0573 },
0574 {
0575     "jsgt32: BPF_K",
0576     .insns = {
0577     BPF_DIRECT_PKT_R2,
0578     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0579     BPF_JMP32_IMM(BPF_JSGT, BPF_REG_7, -1, 1),
0580     BPF_EXIT_INSN(),
0581     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0582     BPF_EXIT_INSN(),
0583     },
0584     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0585     .result = ACCEPT,
0586     .runs = 3,
0587     .retvals = {
0588         { .retval = 0,
0589           .data64 = { (__u32)-2, }
0590         },
0591         { .retval = 0,
0592           .data64 = { -1, }
0593         },
0594         { .retval = 2,
0595           .data64 = { 1, }
0596         },
0597     },
0598     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0599 },
0600 {
0601     "jsgt32: BPF_X",
0602     .insns = {
0603     BPF_DIRECT_PKT_R2,
0604     BPF_LD_IMM64(BPF_REG_8, 0x7ffffffe | 1ULL << 32),
0605     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0606     BPF_JMP32_REG(BPF_JSGT, BPF_REG_7, BPF_REG_8, 1),
0607     BPF_EXIT_INSN(),
0608     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0609     BPF_EXIT_INSN(),
0610     },
0611     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0612     .result = ACCEPT,
0613     .runs = 3,
0614     .retvals = {
0615         { .retval = 0,
0616           .data64 = { 0x7ffffffe, }
0617         },
0618         { .retval = 0,
0619           .data64 = { 0x1ffffffffULL, }
0620         },
0621         { .retval = 2,
0622           .data64 = { 0x7fffffff, }
0623         },
0624     },
0625     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0626 },
0627 {
0628     "jsgt32: min/max deduction",
0629     .insns = {
0630     BPF_RAND_SEXT_R7,
0631     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0632     BPF_LD_IMM64(BPF_REG_8, (__u32)(-2) | 1ULL << 32),
0633     BPF_JMP32_REG(BPF_JSGT, BPF_REG_7, BPF_REG_8, 1),
0634     BPF_EXIT_INSN(),
0635     BPF_JMP_IMM(BPF_JSGT, BPF_REG_7, -2, 1),
0636     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
0637     BPF_EXIT_INSN(),
0638     },
0639     .errstr_unpriv = "R0 invalid mem access 'scalar'",
0640     .result_unpriv = REJECT,
0641     .result = ACCEPT,
0642     .retval = 2,
0643 },
0644 {
0645     "jsle32: BPF_K",
0646     .insns = {
0647     BPF_DIRECT_PKT_R2,
0648     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0649     BPF_JMP32_IMM(BPF_JSLE, BPF_REG_7, -1, 1),
0650     BPF_EXIT_INSN(),
0651     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0652     BPF_EXIT_INSN(),
0653     },
0654     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0655     .result = ACCEPT,
0656     .runs = 3,
0657     .retvals = {
0658         { .retval = 2,
0659           .data64 = { (__u32)-2, }
0660         },
0661         { .retval = 2,
0662           .data64 = { -1, }
0663         },
0664         { .retval = 0,
0665           .data64 = { 1, }
0666         },
0667     },
0668     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0669 },
0670 {
0671     "jsle32: BPF_X",
0672     .insns = {
0673     BPF_DIRECT_PKT_R2,
0674     BPF_LD_IMM64(BPF_REG_8, 0x7ffffffe | 1ULL << 32),
0675     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0676     BPF_JMP32_REG(BPF_JSLE, BPF_REG_7, BPF_REG_8, 1),
0677     BPF_EXIT_INSN(),
0678     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0679     BPF_EXIT_INSN(),
0680     },
0681     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0682     .result = ACCEPT,
0683     .runs = 3,
0684     .retvals = {
0685         { .retval = 2,
0686           .data64 = { 0x7ffffffe, }
0687         },
0688         { .retval = 2,
0689           .data64 = { (__u32)-1, }
0690         },
0691         { .retval = 0,
0692           .data64 = { 0x7fffffff | 2ULL << 32, }
0693         },
0694     },
0695     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0696 },
0697 {
0698     "jsle32: min/max deduction",
0699     .insns = {
0700     BPF_RAND_UEXT_R7,
0701     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0702     BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
0703     BPF_JMP32_REG(BPF_JSLE, BPF_REG_7, BPF_REG_8, 1),
0704     BPF_EXIT_INSN(),
0705     BPF_JMP_IMM(BPF_JSLE, BPF_REG_7, 0x7ffffff0, 1),
0706     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
0707     BPF_EXIT_INSN(),
0708     },
0709     .errstr_unpriv = "R0 invalid mem access 'scalar'",
0710     .result_unpriv = REJECT,
0711     .result = ACCEPT,
0712     .retval = 2,
0713 },
0714 {
0715     "jslt32: BPF_K",
0716     .insns = {
0717     BPF_DIRECT_PKT_R2,
0718     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0719     BPF_JMP32_IMM(BPF_JSLT, BPF_REG_7, -1, 1),
0720     BPF_EXIT_INSN(),
0721     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0722     BPF_EXIT_INSN(),
0723     },
0724     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0725     .result = ACCEPT,
0726     .runs = 3,
0727     .retvals = {
0728         { .retval = 2,
0729           .data64 = { (__u32)-2, }
0730         },
0731         { .retval = 0,
0732           .data64 = { -1, }
0733         },
0734         { .retval = 0,
0735           .data64 = { 1, }
0736         },
0737     },
0738     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0739 },
0740 {
0741     "jslt32: BPF_X",
0742     .insns = {
0743     BPF_DIRECT_PKT_R2,
0744     BPF_LD_IMM64(BPF_REG_8, 0x7fffffff | 1ULL << 32),
0745     BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
0746     BPF_JMP32_REG(BPF_JSLT, BPF_REG_7, BPF_REG_8, 1),
0747     BPF_EXIT_INSN(),
0748     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0749     BPF_EXIT_INSN(),
0750     },
0751     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0752     .result = ACCEPT,
0753     .runs = 3,
0754     .retvals = {
0755         { .retval = 2,
0756           .data64 = { 0x7ffffffe, }
0757         },
0758         { .retval = 2,
0759           .data64 = { 0xffffffff, }
0760         },
0761         { .retval = 0,
0762           .data64 = { 0x7fffffff | 2ULL << 32, }
0763         },
0764     },
0765     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0766 },
0767 {
0768     "jslt32: min/max deduction",
0769     .insns = {
0770     BPF_RAND_SEXT_R7,
0771     BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
0772     BPF_LD_IMM64(BPF_REG_8, (__u32)(-1) | 1ULL << 32),
0773     BPF_JMP32_REG(BPF_JSLT, BPF_REG_7, BPF_REG_8, 1),
0774     BPF_EXIT_INSN(),
0775     BPF_JMP32_IMM(BPF_JSLT, BPF_REG_7, -1, 1),
0776     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
0777     BPF_EXIT_INSN(),
0778     },
0779     .errstr_unpriv = "R0 invalid mem access 'scalar'",
0780     .result_unpriv = REJECT,
0781     .result = ACCEPT,
0782     .retval = 2,
0783 },
0784 {
0785     "jgt32: range bound deduction, reg op imm",
0786     .insns = {
0787     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0788     BPF_MOV64_REG(BPF_REG_8, BPF_REG_1),
0789     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0790     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0791     BPF_LD_MAP_FD(BPF_REG_1, 0),
0792     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0793     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9),
0794     BPF_MOV64_REG(BPF_REG_1, BPF_REG_8),
0795     BPF_MOV64_REG(BPF_REG_8, BPF_REG_0),
0796     BPF_EMIT_CALL(BPF_FUNC_get_cgroup_classid),
0797     BPF_JMP32_IMM(BPF_JGT, BPF_REG_0, 1, 5),
0798     BPF_MOV32_REG(BPF_REG_6, BPF_REG_0),
0799     BPF_ALU64_IMM(BPF_LSH, BPF_REG_6, 32),
0800     BPF_ALU64_IMM(BPF_RSH, BPF_REG_6, 32),
0801     BPF_ALU64_REG(BPF_ADD, BPF_REG_8, BPF_REG_6),
0802     BPF_ST_MEM(BPF_B, BPF_REG_8, 0, 0),
0803     BPF_MOV32_IMM(BPF_REG_0, 0),
0804     BPF_EXIT_INSN(),
0805     },
0806     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0807     .fixup_map_hash_48b = { 4 },
0808     .result = ACCEPT,
0809     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0810 },
0811 {
0812     "jgt32: range bound deduction, reg1 op reg2, reg1 unknown",
0813     .insns = {
0814     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0815     BPF_MOV64_REG(BPF_REG_8, BPF_REG_1),
0816     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0817     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0818     BPF_LD_MAP_FD(BPF_REG_1, 0),
0819     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0820     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 10),
0821     BPF_MOV64_REG(BPF_REG_1, BPF_REG_8),
0822     BPF_MOV64_REG(BPF_REG_8, BPF_REG_0),
0823     BPF_EMIT_CALL(BPF_FUNC_get_cgroup_classid),
0824     BPF_MOV32_IMM(BPF_REG_2, 1),
0825     BPF_JMP32_REG(BPF_JGT, BPF_REG_0, BPF_REG_2, 5),
0826     BPF_MOV32_REG(BPF_REG_6, BPF_REG_0),
0827     BPF_ALU64_IMM(BPF_LSH, BPF_REG_6, 32),
0828     BPF_ALU64_IMM(BPF_RSH, BPF_REG_6, 32),
0829     BPF_ALU64_REG(BPF_ADD, BPF_REG_8, BPF_REG_6),
0830     BPF_ST_MEM(BPF_B, BPF_REG_8, 0, 0),
0831     BPF_MOV32_IMM(BPF_REG_0, 0),
0832     BPF_EXIT_INSN(),
0833     },
0834     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0835     .fixup_map_hash_48b = { 4 },
0836     .result = ACCEPT,
0837     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0838 },
0839 {
0840     "jle32: range bound deduction, reg1 op reg2, reg2 unknown",
0841     .insns = {
0842     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0843     BPF_MOV64_REG(BPF_REG_8, BPF_REG_1),
0844     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0845     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0846     BPF_LD_MAP_FD(BPF_REG_1, 0),
0847     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0848     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 10),
0849     BPF_MOV64_REG(BPF_REG_1, BPF_REG_8),
0850     BPF_MOV64_REG(BPF_REG_8, BPF_REG_0),
0851     BPF_EMIT_CALL(BPF_FUNC_get_cgroup_classid),
0852     BPF_MOV32_IMM(BPF_REG_2, 1),
0853     BPF_JMP32_REG(BPF_JLE, BPF_REG_2, BPF_REG_0, 5),
0854     BPF_MOV32_REG(BPF_REG_6, BPF_REG_0),
0855     BPF_ALU64_IMM(BPF_LSH, BPF_REG_6, 32),
0856     BPF_ALU64_IMM(BPF_RSH, BPF_REG_6, 32),
0857     BPF_ALU64_REG(BPF_ADD, BPF_REG_8, BPF_REG_6),
0858     BPF_ST_MEM(BPF_B, BPF_REG_8, 0, 0),
0859     BPF_MOV32_IMM(BPF_REG_0, 0),
0860     BPF_EXIT_INSN(),
0861     },
0862     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0863     .fixup_map_hash_48b = { 4 },
0864     .result = ACCEPT,
0865     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0866 },
0867 {
0868     "jeq32/jne32: bounds checking",
0869     .insns = {
0870     BPF_MOV64_IMM(BPF_REG_6, 563),
0871     BPF_MOV64_IMM(BPF_REG_2, 0),
0872     BPF_ALU64_IMM(BPF_NEG, BPF_REG_2, 0),
0873     BPF_ALU64_IMM(BPF_NEG, BPF_REG_2, 0),
0874     BPF_ALU32_REG(BPF_OR, BPF_REG_2, BPF_REG_6),
0875     BPF_JMP32_IMM(BPF_JNE, BPF_REG_2, 8, 5),
0876     BPF_JMP_IMM(BPF_JSGE, BPF_REG_2, 500, 2),
0877     BPF_MOV64_IMM(BPF_REG_0, 2),
0878     BPF_EXIT_INSN(),
0879     BPF_MOV64_REG(BPF_REG_0, BPF_REG_4),
0880     BPF_EXIT_INSN(),
0881     BPF_MOV64_IMM(BPF_REG_0, 1),
0882     BPF_EXIT_INSN(),
0883     },
0884     .prog_type = BPF_PROG_TYPE_SCHED_CLS,
0885     .result = ACCEPT,
0886     .retval = 1,
0887 },
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!