Back to home page

OSCL-LXR
 
 

     

0001 {
0002     "bounds checks mixing signed and unsigned, positive bounds",
0003     .insns = {
0004     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0005     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0006     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0007     BPF_LD_MAP_FD(BPF_REG_1, 0),
0008     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0009     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 7),
0010     BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
0011     BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
0012     BPF_MOV64_IMM(BPF_REG_2, 2),
0013     BPF_JMP_REG(BPF_JGE, BPF_REG_2, BPF_REG_1, 3),
0014     BPF_JMP_IMM(BPF_JSGT, BPF_REG_1, 4, 2),
0015     BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
0016     BPF_ST_MEM(BPF_B, BPF_REG_0, 0, 0),
0017     BPF_MOV64_IMM(BPF_REG_0, 0),
0018     BPF_EXIT_INSN(),
0019     },
0020     .fixup_map_hash_8b = { 3 },
0021     .errstr = "unbounded min value",
0022     .result = REJECT,
0023 },
0024 {
0025     "bounds checks mixing signed and unsigned",
0026     .insns = {
0027     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0028     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0029     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0030     BPF_LD_MAP_FD(BPF_REG_1, 0),
0031     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0032     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 7),
0033     BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
0034     BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
0035     BPF_MOV64_IMM(BPF_REG_2, -1),
0036     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_2, 3),
0037     BPF_JMP_IMM(BPF_JSGT, BPF_REG_1, 1, 2),
0038     BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
0039     BPF_ST_MEM(BPF_B, BPF_REG_0, 0, 0),
0040     BPF_MOV64_IMM(BPF_REG_0, 0),
0041     BPF_EXIT_INSN(),
0042     },
0043     .fixup_map_hash_8b = { 3 },
0044     .errstr = "unbounded min value",
0045     .result = REJECT,
0046 },
0047 {
0048     "bounds checks mixing signed and unsigned, variant 2",
0049     .insns = {
0050     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0051     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0052     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0053     BPF_LD_MAP_FD(BPF_REG_1, 0),
0054     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0055     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9),
0056     BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
0057     BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
0058     BPF_MOV64_IMM(BPF_REG_2, -1),
0059     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_2, 5),
0060     BPF_MOV64_IMM(BPF_REG_8, 0),
0061     BPF_ALU64_REG(BPF_ADD, BPF_REG_8, BPF_REG_1),
0062     BPF_JMP_IMM(BPF_JSGT, BPF_REG_8, 1, 2),
0063     BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_8),
0064     BPF_ST_MEM(BPF_B, BPF_REG_8, 0, 0),
0065     BPF_MOV64_IMM(BPF_REG_0, 0),
0066     BPF_EXIT_INSN(),
0067     },
0068     .fixup_map_hash_8b = { 3 },
0069     .errstr = "unbounded min value",
0070     .result = REJECT,
0071 },
0072 {
0073     "bounds checks mixing signed and unsigned, variant 3",
0074     .insns = {
0075     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0076     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0077     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0078     BPF_LD_MAP_FD(BPF_REG_1, 0),
0079     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0080     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 8),
0081     BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
0082     BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
0083     BPF_MOV64_IMM(BPF_REG_2, -1),
0084     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_2, 4),
0085     BPF_MOV64_REG(BPF_REG_8, BPF_REG_1),
0086     BPF_JMP_IMM(BPF_JSGT, BPF_REG_8, 1, 2),
0087     BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_8),
0088     BPF_ST_MEM(BPF_B, BPF_REG_8, 0, 0),
0089     BPF_MOV64_IMM(BPF_REG_0, 0),
0090     BPF_EXIT_INSN(),
0091     },
0092     .fixup_map_hash_8b = { 3 },
0093     .errstr = "unbounded min value",
0094     .result = REJECT,
0095 },
0096 {
0097     "bounds checks mixing signed and unsigned, variant 4",
0098     .insns = {
0099     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0100     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0101     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0102     BPF_LD_MAP_FD(BPF_REG_1, 0),
0103     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0104     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 7),
0105     BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
0106     BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
0107     BPF_MOV64_IMM(BPF_REG_2, 1),
0108     BPF_ALU64_REG(BPF_AND, BPF_REG_1, BPF_REG_2),
0109     BPF_JMP_IMM(BPF_JSGT, BPF_REG_1, 1, 2),
0110     BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
0111     BPF_ST_MEM(BPF_B, BPF_REG_0, 0, 0),
0112     BPF_MOV64_IMM(BPF_REG_0, 0),
0113     BPF_EXIT_INSN(),
0114     },
0115     .fixup_map_hash_8b = { 3 },
0116     .result = ACCEPT,
0117 },
0118 {
0119     "bounds checks mixing signed and unsigned, variant 5",
0120     .insns = {
0121     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0122     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0123     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0124     BPF_LD_MAP_FD(BPF_REG_1, 0),
0125     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0126     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9),
0127     BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
0128     BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
0129     BPF_MOV64_IMM(BPF_REG_2, -1),
0130     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_2, 5),
0131     BPF_JMP_IMM(BPF_JSGT, BPF_REG_1, 1, 4),
0132     BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 4),
0133     BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
0134     BPF_ST_MEM(BPF_B, BPF_REG_0, 0, 0),
0135     BPF_MOV64_IMM(BPF_REG_0, 0),
0136     BPF_EXIT_INSN(),
0137     },
0138     .fixup_map_hash_8b = { 3 },
0139     .errstr = "unbounded min value",
0140     .result = REJECT,
0141 },
0142 {
0143     "bounds checks mixing signed and unsigned, variant 6",
0144     .insns = {
0145     BPF_MOV64_IMM(BPF_REG_2, 0),
0146     BPF_MOV64_REG(BPF_REG_3, BPF_REG_10),
0147     BPF_ALU64_IMM(BPF_ADD, BPF_REG_3, -512),
0148     BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
0149     BPF_LDX_MEM(BPF_DW, BPF_REG_4, BPF_REG_10, -16),
0150     BPF_MOV64_IMM(BPF_REG_6, -1),
0151     BPF_JMP_REG(BPF_JGT, BPF_REG_4, BPF_REG_6, 5),
0152     BPF_JMP_IMM(BPF_JSGT, BPF_REG_4, 1, 4),
0153     BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, 1),
0154     BPF_MOV64_IMM(BPF_REG_5, 0),
0155     BPF_ST_MEM(BPF_H, BPF_REG_10, -512, 0),
0156     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_skb_load_bytes),
0157     BPF_MOV64_IMM(BPF_REG_0, 0),
0158     BPF_EXIT_INSN(),
0159     },
0160     .errstr = "R4 min value is negative, either use unsigned",
0161     .result = REJECT,
0162 },
0163 {
0164     "bounds checks mixing signed and unsigned, variant 7",
0165     .insns = {
0166     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0167     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0168     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0169     BPF_LD_MAP_FD(BPF_REG_1, 0),
0170     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0171     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 7),
0172     BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
0173     BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
0174     BPF_MOV64_IMM(BPF_REG_2, 1024 * 1024 * 1024),
0175     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_2, 3),
0176     BPF_JMP_IMM(BPF_JSGT, BPF_REG_1, 1, 2),
0177     BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
0178     BPF_ST_MEM(BPF_B, BPF_REG_0, 0, 0),
0179     BPF_MOV64_IMM(BPF_REG_0, 0),
0180     BPF_EXIT_INSN(),
0181     },
0182     .fixup_map_hash_8b = { 3 },
0183     .result = ACCEPT,
0184 },
0185 {
0186     "bounds checks mixing signed and unsigned, variant 8",
0187     .insns = {
0188     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0189     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0190     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0191     BPF_LD_MAP_FD(BPF_REG_1, 0),
0192     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0193     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9),
0194     BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
0195     BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
0196     BPF_MOV64_IMM(BPF_REG_2, -1),
0197     BPF_JMP_REG(BPF_JGT, BPF_REG_2, BPF_REG_1, 2),
0198     BPF_MOV64_IMM(BPF_REG_0, 0),
0199     BPF_EXIT_INSN(),
0200     BPF_JMP_IMM(BPF_JSGT, BPF_REG_1, 1, 2),
0201     BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
0202     BPF_ST_MEM(BPF_B, BPF_REG_0, 0, 0),
0203     BPF_MOV64_IMM(BPF_REG_0, 0),
0204     BPF_EXIT_INSN(),
0205     },
0206     .fixup_map_hash_8b = { 3 },
0207     .errstr = "unbounded min value",
0208     .result = REJECT,
0209 },
0210 {
0211     "bounds checks mixing signed and unsigned, variant 9",
0212     .insns = {
0213     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0214     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0215     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0216     BPF_LD_MAP_FD(BPF_REG_1, 0),
0217     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0218     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 10),
0219     BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
0220     BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
0221     BPF_LD_IMM64(BPF_REG_2, -9223372036854775808ULL),
0222     BPF_JMP_REG(BPF_JGT, BPF_REG_2, BPF_REG_1, 2),
0223     BPF_MOV64_IMM(BPF_REG_0, 0),
0224     BPF_EXIT_INSN(),
0225     BPF_JMP_IMM(BPF_JSGT, BPF_REG_1, 1, 2),
0226     BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
0227     BPF_ST_MEM(BPF_B, BPF_REG_0, 0, 0),
0228     BPF_MOV64_IMM(BPF_REG_0, 0),
0229     BPF_EXIT_INSN(),
0230     },
0231     .fixup_map_hash_8b = { 3 },
0232     .result = ACCEPT,
0233 },
0234 {
0235     "bounds checks mixing signed and unsigned, variant 10",
0236     .insns = {
0237     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0238     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0239     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0240     BPF_LD_MAP_FD(BPF_REG_1, 0),
0241     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0242     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9),
0243     BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
0244     BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
0245     BPF_MOV64_IMM(BPF_REG_2, 0),
0246     BPF_JMP_REG(BPF_JGT, BPF_REG_2, BPF_REG_1, 2),
0247     BPF_MOV64_IMM(BPF_REG_0, 0),
0248     BPF_EXIT_INSN(),
0249     BPF_JMP_IMM(BPF_JSGT, BPF_REG_1, 1, 2),
0250     BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
0251     BPF_ST_MEM(BPF_B, BPF_REG_0, 0, 0),
0252     BPF_MOV64_IMM(BPF_REG_0, 0),
0253     BPF_EXIT_INSN(),
0254     },
0255     .fixup_map_hash_8b = { 3 },
0256     .errstr = "unbounded min value",
0257     .result = REJECT,
0258 },
0259 {
0260     "bounds checks mixing signed and unsigned, variant 11",
0261     .insns = {
0262     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0263     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0264     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0265     BPF_LD_MAP_FD(BPF_REG_1, 0),
0266     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0267     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9),
0268     BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
0269     BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
0270     BPF_MOV64_IMM(BPF_REG_2, -1),
0271     BPF_JMP_REG(BPF_JGE, BPF_REG_2, BPF_REG_1, 2),
0272     /* Dead branch. */
0273     BPF_MOV64_IMM(BPF_REG_0, 0),
0274     BPF_EXIT_INSN(),
0275     BPF_JMP_IMM(BPF_JSGT, BPF_REG_1, 1, 2),
0276     BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
0277     BPF_ST_MEM(BPF_B, BPF_REG_0, 0, 0),
0278     BPF_MOV64_IMM(BPF_REG_0, 0),
0279     BPF_EXIT_INSN(),
0280     },
0281     .fixup_map_hash_8b = { 3 },
0282     .errstr = "unbounded min value",
0283     .result = REJECT,
0284 },
0285 {
0286     "bounds checks mixing signed and unsigned, variant 12",
0287     .insns = {
0288     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0289     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0290     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0291     BPF_LD_MAP_FD(BPF_REG_1, 0),
0292     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0293     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 9),
0294     BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
0295     BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
0296     BPF_MOV64_IMM(BPF_REG_2, -6),
0297     BPF_JMP_REG(BPF_JGE, BPF_REG_2, BPF_REG_1, 2),
0298     BPF_MOV64_IMM(BPF_REG_0, 0),
0299     BPF_EXIT_INSN(),
0300     BPF_JMP_IMM(BPF_JSGT, BPF_REG_1, 1, 2),
0301     BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
0302     BPF_ST_MEM(BPF_B, BPF_REG_0, 0, 0),
0303     BPF_MOV64_IMM(BPF_REG_0, 0),
0304     BPF_EXIT_INSN(),
0305     },
0306     .fixup_map_hash_8b = { 3 },
0307     .errstr = "unbounded min value",
0308     .result = REJECT,
0309 },
0310 {
0311     "bounds checks mixing signed and unsigned, variant 13",
0312     .insns = {
0313     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0314     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0315     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0316     BPF_LD_MAP_FD(BPF_REG_1, 0),
0317     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0318     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 6),
0319     BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
0320     BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
0321     BPF_MOV64_IMM(BPF_REG_2, 2),
0322     BPF_JMP_REG(BPF_JGE, BPF_REG_2, BPF_REG_1, 2),
0323     BPF_MOV64_IMM(BPF_REG_7, 1),
0324     BPF_JMP_IMM(BPF_JSGT, BPF_REG_7, 0, 2),
0325     BPF_MOV64_IMM(BPF_REG_0, 0),
0326     BPF_EXIT_INSN(),
0327     BPF_ALU64_REG(BPF_ADD, BPF_REG_7, BPF_REG_1),
0328     BPF_JMP_IMM(BPF_JSGT, BPF_REG_7, 4, 2),
0329     BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_7),
0330     BPF_ST_MEM(BPF_B, BPF_REG_0, 0, 0),
0331     BPF_MOV64_IMM(BPF_REG_0, 0),
0332     BPF_EXIT_INSN(),
0333     },
0334     .fixup_map_hash_8b = { 3 },
0335     .errstr = "unbounded min value",
0336     .result = REJECT,
0337 },
0338 {
0339     "bounds checks mixing signed and unsigned, variant 14",
0340     .insns = {
0341     BPF_LDX_MEM(BPF_W, BPF_REG_9, BPF_REG_1,
0342             offsetof(struct __sk_buff, mark)),
0343     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0344     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0345     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0346     BPF_LD_MAP_FD(BPF_REG_1, 0),
0347     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0348     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 8),
0349     BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
0350     BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
0351     BPF_MOV64_IMM(BPF_REG_2, -1),
0352     BPF_MOV64_IMM(BPF_REG_8, 2),
0353     BPF_JMP_IMM(BPF_JEQ, BPF_REG_9, 42, 6),
0354     BPF_JMP_REG(BPF_JSGT, BPF_REG_8, BPF_REG_1, 3),
0355     BPF_JMP_IMM(BPF_JSGT, BPF_REG_1, 1, 2),
0356     BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
0357     BPF_ST_MEM(BPF_B, BPF_REG_0, 0, 0),
0358     BPF_MOV64_IMM(BPF_REG_0, 0),
0359     BPF_EXIT_INSN(),
0360     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_2, -3),
0361     BPF_JMP_IMM(BPF_JA, 0, 0, -7),
0362     },
0363     .fixup_map_hash_8b = { 4 },
0364     .errstr = "unbounded min value",
0365     .result = REJECT,
0366 },
0367 {
0368     "bounds checks mixing signed and unsigned, variant 15",
0369     .insns = {
0370     BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
0371     BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
0372     BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
0373     BPF_LD_MAP_FD(BPF_REG_1, 0),
0374     BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
0375     BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 4),
0376     BPF_ST_MEM(BPF_DW, BPF_REG_10, -16, -8),
0377     BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_10, -16),
0378     BPF_MOV64_IMM(BPF_REG_2, -6),
0379     BPF_JMP_REG(BPF_JGE, BPF_REG_2, BPF_REG_1, 2),
0380     BPF_MOV64_IMM(BPF_REG_0, 0),
0381     BPF_EXIT_INSN(),
0382     BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
0383     BPF_JMP_IMM(BPF_JGT, BPF_REG_0, 1, 2),
0384     BPF_MOV64_IMM(BPF_REG_0, 0),
0385     BPF_EXIT_INSN(),
0386     BPF_ST_MEM(BPF_B, BPF_REG_0, 0, 0),
0387     BPF_MOV64_IMM(BPF_REG_0, 0),
0388     BPF_EXIT_INSN(),
0389     },
0390     .fixup_map_hash_8b = { 3 },
0391     .errstr = "unbounded min value",
0392     .result = REJECT,
0393 },
[ 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!