Back to home page

OSCL-LXR
 
 

     

0001 {
0002     "XDP pkt read, pkt_end mangling, bad access 1",
0003     .insns = {
0004     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0005     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0006             offsetof(struct xdp_md, data_end)),
0007     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0008     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0009     BPF_ALU64_IMM(BPF_ADD, BPF_REG_3, 8),
0010     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
0011     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0012     BPF_MOV64_IMM(BPF_REG_0, 0),
0013     BPF_EXIT_INSN(),
0014     },
0015     .errstr = "R3 pointer arithmetic on pkt_end",
0016     .result = REJECT,
0017     .prog_type = BPF_PROG_TYPE_XDP,
0018 },
0019 {
0020     "XDP pkt read, pkt_end mangling, bad access 2",
0021     .insns = {
0022     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0023     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0024             offsetof(struct xdp_md, data_end)),
0025     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0026     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0027     BPF_ALU64_IMM(BPF_SUB, BPF_REG_3, 8),
0028     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
0029     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0030     BPF_MOV64_IMM(BPF_REG_0, 0),
0031     BPF_EXIT_INSN(),
0032     },
0033     .errstr = "R3 pointer arithmetic on pkt_end",
0034     .result = REJECT,
0035     .prog_type = BPF_PROG_TYPE_XDP,
0036 },
0037 {
0038     "XDP pkt read, pkt_data' > pkt_end, corner case, good access",
0039     .insns = {
0040     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0041     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0042             offsetof(struct xdp_md, data_end)),
0043     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0044     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0045     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
0046     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0047     BPF_MOV64_IMM(BPF_REG_0, 0),
0048     BPF_EXIT_INSN(),
0049     },
0050     .result = ACCEPT,
0051     .prog_type = BPF_PROG_TYPE_XDP,
0052     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0053 },
0054 {
0055     "XDP pkt read, pkt_data' > pkt_end, bad access 1",
0056     .insns = {
0057     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0058     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0059             offsetof(struct xdp_md, data_end)),
0060     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0061     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0062     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
0063     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -4),
0064     BPF_MOV64_IMM(BPF_REG_0, 0),
0065     BPF_EXIT_INSN(),
0066     },
0067     .errstr = "R1 offset is outside of the packet",
0068     .result = REJECT,
0069     .prog_type = BPF_PROG_TYPE_XDP,
0070     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0071 },
0072 {
0073     "XDP pkt read, pkt_data' > pkt_end, bad access 2",
0074     .insns = {
0075     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0076     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0077             offsetof(struct xdp_md, data_end)),
0078     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0079     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0080     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 0),
0081     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0082     BPF_MOV64_IMM(BPF_REG_0, 0),
0083     BPF_EXIT_INSN(),
0084     },
0085     .errstr = "R1 offset is outside of the packet",
0086     .result = REJECT,
0087     .prog_type = BPF_PROG_TYPE_XDP,
0088     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0089 },
0090 {
0091     "XDP pkt read, pkt_data' > pkt_end, corner case +1, good access",
0092     .insns = {
0093     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0094     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0095             offsetof(struct xdp_md, data_end)),
0096     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0097     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
0098     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
0099     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
0100     BPF_MOV64_IMM(BPF_REG_0, 0),
0101     BPF_EXIT_INSN(),
0102     },
0103     .result = ACCEPT,
0104     .prog_type = BPF_PROG_TYPE_XDP,
0105     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0106 },
0107 {
0108     "XDP pkt read, pkt_data' > pkt_end, corner case -1, bad access",
0109     .insns = {
0110     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0111     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0112             offsetof(struct xdp_md, data_end)),
0113     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0114     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
0115     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
0116     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
0117     BPF_MOV64_IMM(BPF_REG_0, 0),
0118     BPF_EXIT_INSN(),
0119     },
0120     .errstr = "R1 offset is outside of the packet",
0121     .result = REJECT,
0122     .prog_type = BPF_PROG_TYPE_XDP,
0123     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0124 },
0125 {
0126     "XDP pkt read, pkt_end > pkt_data', good access",
0127     .insns = {
0128     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0129     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0130             offsetof(struct xdp_md, data_end)),
0131     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0132     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0133     BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
0134     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0135     BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),
0136     BPF_MOV64_IMM(BPF_REG_0, 0),
0137     BPF_EXIT_INSN(),
0138     },
0139     .result = ACCEPT,
0140     .prog_type = BPF_PROG_TYPE_XDP,
0141     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0142 },
0143 {
0144     "XDP pkt read, pkt_end > pkt_data', corner case -1, bad access",
0145     .insns = {
0146     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0147     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0148             offsetof(struct xdp_md, data_end)),
0149     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0150     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 6),
0151     BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
0152     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0153     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -6),
0154     BPF_MOV64_IMM(BPF_REG_0, 0),
0155     BPF_EXIT_INSN(),
0156     },
0157     .errstr = "R1 offset is outside of the packet",
0158     .result = REJECT,
0159     .prog_type = BPF_PROG_TYPE_XDP,
0160     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0161 },
0162 {
0163     "XDP pkt read, pkt_end > pkt_data', bad access 2",
0164     .insns = {
0165     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0166     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0167             offsetof(struct xdp_md, data_end)),
0168     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0169     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0170     BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
0171     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0172     BPF_MOV64_IMM(BPF_REG_0, 0),
0173     BPF_EXIT_INSN(),
0174     },
0175     .errstr = "R1 offset is outside of the packet",
0176     .result = REJECT,
0177     .prog_type = BPF_PROG_TYPE_XDP,
0178     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0179 },
0180 {
0181     "XDP pkt read, pkt_end > pkt_data', corner case, good access",
0182     .insns = {
0183     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0184     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0185             offsetof(struct xdp_md, data_end)),
0186     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0187     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
0188     BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
0189     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0190     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
0191     BPF_MOV64_IMM(BPF_REG_0, 0),
0192     BPF_EXIT_INSN(),
0193     },
0194     .result = ACCEPT,
0195     .prog_type = BPF_PROG_TYPE_XDP,
0196     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0197 },
0198 {
0199     "XDP pkt read, pkt_end > pkt_data', corner case +1, good access",
0200     .insns = {
0201     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0202     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0203             offsetof(struct xdp_md, data_end)),
0204     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0205     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0206     BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
0207     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0208     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0209     BPF_MOV64_IMM(BPF_REG_0, 0),
0210     BPF_EXIT_INSN(),
0211     },
0212     .result = ACCEPT,
0213     .prog_type = BPF_PROG_TYPE_XDP,
0214     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0215 },
0216 {
0217     "XDP pkt read, pkt_data' < pkt_end, good access",
0218     .insns = {
0219     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0220     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0221             offsetof(struct xdp_md, data_end)),
0222     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0223     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0224     BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
0225     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0226     BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),
0227     BPF_MOV64_IMM(BPF_REG_0, 0),
0228     BPF_EXIT_INSN(),
0229     },
0230     .result = ACCEPT,
0231     .prog_type = BPF_PROG_TYPE_XDP,
0232     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0233 },
0234 {
0235     "XDP pkt read, pkt_data' < pkt_end, corner case -1, bad access",
0236     .insns = {
0237     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0238     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0239             offsetof(struct xdp_md, data_end)),
0240     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0241     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 6),
0242     BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
0243     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0244     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -6),
0245     BPF_MOV64_IMM(BPF_REG_0, 0),
0246     BPF_EXIT_INSN(),
0247     },
0248     .errstr = "R1 offset is outside of the packet",
0249     .result = REJECT,
0250     .prog_type = BPF_PROG_TYPE_XDP,
0251     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0252 },
0253 {
0254     "XDP pkt read, pkt_data' < pkt_end, bad access 2",
0255     .insns = {
0256     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0257     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0258             offsetof(struct xdp_md, data_end)),
0259     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0260     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0261     BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
0262     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0263     BPF_MOV64_IMM(BPF_REG_0, 0),
0264     BPF_EXIT_INSN(),
0265     },
0266     .errstr = "R1 offset is outside of the packet",
0267     .result = REJECT,
0268     .prog_type = BPF_PROG_TYPE_XDP,
0269     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0270 },
0271 {
0272     "XDP pkt read, pkt_data' < pkt_end, corner case, good access",
0273     .insns = {
0274     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0275     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0276             offsetof(struct xdp_md, data_end)),
0277     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0278     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
0279     BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
0280     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0281     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
0282     BPF_MOV64_IMM(BPF_REG_0, 0),
0283     BPF_EXIT_INSN(),
0284     },
0285     .result = ACCEPT,
0286     .prog_type = BPF_PROG_TYPE_XDP,
0287     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0288 },
0289 {
0290     "XDP pkt read, pkt_data' < pkt_end, corner case +1, good access",
0291     .insns = {
0292     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0293     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0294             offsetof(struct xdp_md, data_end)),
0295     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0296     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0297     BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
0298     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0299     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0300     BPF_MOV64_IMM(BPF_REG_0, 0),
0301     BPF_EXIT_INSN(),
0302     },
0303     .result = ACCEPT,
0304     .prog_type = BPF_PROG_TYPE_XDP,
0305     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0306 },
0307 {
0308     "XDP pkt read, pkt_end < pkt_data', corner case, good access",
0309     .insns = {
0310     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0311     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0312             offsetof(struct xdp_md, data_end)),
0313     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0314     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0315     BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),
0316     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0317     BPF_MOV64_IMM(BPF_REG_0, 0),
0318     BPF_EXIT_INSN(),
0319     },
0320     .result = ACCEPT,
0321     .prog_type = BPF_PROG_TYPE_XDP,
0322     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0323 },
0324 {
0325     "XDP pkt read, pkt_end < pkt_data', bad access 1",
0326     .insns = {
0327     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0328     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0329             offsetof(struct xdp_md, data_end)),
0330     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0331     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0332     BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),
0333     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -4),
0334     BPF_MOV64_IMM(BPF_REG_0, 0),
0335     BPF_EXIT_INSN(),
0336     },
0337     .errstr = "R1 offset is outside of the packet",
0338     .result = REJECT,
0339     .prog_type = BPF_PROG_TYPE_XDP,
0340     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0341 },
0342 {
0343     "XDP pkt read, pkt_end < pkt_data', bad access 2",
0344     .insns = {
0345     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0346     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0347             offsetof(struct xdp_md, data_end)),
0348     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0349     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0350     BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 0),
0351     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0352     BPF_MOV64_IMM(BPF_REG_0, 0),
0353     BPF_EXIT_INSN(),
0354     },
0355     .errstr = "R1 offset is outside of the packet",
0356     .result = REJECT,
0357     .prog_type = BPF_PROG_TYPE_XDP,
0358     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0359 },
0360 {
0361     "XDP pkt read, pkt_end < pkt_data', corner case +1, good access",
0362     .insns = {
0363     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0364     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0365             offsetof(struct xdp_md, data_end)),
0366     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0367     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
0368     BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),
0369     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
0370     BPF_MOV64_IMM(BPF_REG_0, 0),
0371     BPF_EXIT_INSN(),
0372     },
0373     .result = ACCEPT,
0374     .prog_type = BPF_PROG_TYPE_XDP,
0375     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0376 },
0377 {
0378     "XDP pkt read, pkt_end < pkt_data', corner case -1, bad access",
0379     .insns = {
0380     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0381     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0382             offsetof(struct xdp_md, data_end)),
0383     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0384     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
0385     BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),
0386     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
0387     BPF_MOV64_IMM(BPF_REG_0, 0),
0388     BPF_EXIT_INSN(),
0389     },
0390     .errstr = "R1 offset is outside of the packet",
0391     .result = REJECT,
0392     .prog_type = BPF_PROG_TYPE_XDP,
0393     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0394 },
0395 {
0396     "XDP pkt read, pkt_data' >= pkt_end, good access",
0397     .insns = {
0398     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0399     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0400             offsetof(struct xdp_md, data_end)),
0401     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0402     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0403     BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
0404     BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),
0405     BPF_MOV64_IMM(BPF_REG_0, 0),
0406     BPF_EXIT_INSN(),
0407     },
0408     .result = ACCEPT,
0409     .prog_type = BPF_PROG_TYPE_XDP,
0410     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0411 },
0412 {
0413     "XDP pkt read, pkt_data' >= pkt_end, corner case -1, bad access",
0414     .insns = {
0415     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0416     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0417             offsetof(struct xdp_md, data_end)),
0418     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0419     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 6),
0420     BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
0421     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -6),
0422     BPF_MOV64_IMM(BPF_REG_0, 0),
0423     BPF_EXIT_INSN(),
0424     },
0425     .errstr = "R1 offset is outside of the packet",
0426     .result = REJECT,
0427     .prog_type = BPF_PROG_TYPE_XDP,
0428     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0429 },
0430 {
0431     "XDP pkt read, pkt_data' >= pkt_end, bad access 2",
0432     .insns = {
0433     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0434     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0435             offsetof(struct xdp_md, data_end)),
0436     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0437     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0438     BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 0),
0439     BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),
0440     BPF_MOV64_IMM(BPF_REG_0, 0),
0441     BPF_EXIT_INSN(),
0442     },
0443     .errstr = "R1 offset is outside of the packet",
0444     .result = REJECT,
0445     .prog_type = BPF_PROG_TYPE_XDP,
0446     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0447 },
0448 {
0449     "XDP pkt read, pkt_data' >= pkt_end, corner case, good access",
0450     .insns = {
0451     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0452     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0453             offsetof(struct xdp_md, data_end)),
0454     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0455     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
0456     BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
0457     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
0458     BPF_MOV64_IMM(BPF_REG_0, 0),
0459     BPF_EXIT_INSN(),
0460     },
0461     .result = ACCEPT,
0462     .prog_type = BPF_PROG_TYPE_XDP,
0463     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0464 },
0465 {
0466     "XDP pkt read, pkt_data' >= pkt_end, corner case +1, good access",
0467     .insns = {
0468     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0469     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0470             offsetof(struct xdp_md, data_end)),
0471     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0472     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0473     BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
0474     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0475     BPF_MOV64_IMM(BPF_REG_0, 0),
0476     BPF_EXIT_INSN(),
0477     },
0478     .result = ACCEPT,
0479     .prog_type = BPF_PROG_TYPE_XDP,
0480     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0481 },
0482 {
0483     "XDP pkt read, pkt_end >= pkt_data', corner case, good access",
0484     .insns = {
0485     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0486     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0487             offsetof(struct xdp_md, data_end)),
0488     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0489     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0490     BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
0491     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0492     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0493     BPF_MOV64_IMM(BPF_REG_0, 0),
0494     BPF_EXIT_INSN(),
0495     },
0496     .result = ACCEPT,
0497     .prog_type = BPF_PROG_TYPE_XDP,
0498     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0499 },
0500 {
0501     "XDP pkt read, pkt_end >= pkt_data', bad access 1",
0502     .insns = {
0503     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0504     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0505             offsetof(struct xdp_md, data_end)),
0506     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0507     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0508     BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
0509     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0510     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -4),
0511     BPF_MOV64_IMM(BPF_REG_0, 0),
0512     BPF_EXIT_INSN(),
0513     },
0514     .errstr = "R1 offset is outside of the packet",
0515     .result = REJECT,
0516     .prog_type = BPF_PROG_TYPE_XDP,
0517     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0518 },
0519 {
0520     "XDP pkt read, pkt_end >= pkt_data', bad access 2",
0521     .insns = {
0522     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0523     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0524             offsetof(struct xdp_md, data_end)),
0525     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0526     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0527     BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
0528     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0529     BPF_MOV64_IMM(BPF_REG_0, 0),
0530     BPF_EXIT_INSN(),
0531     },
0532     .errstr = "R1 offset is outside of the packet",
0533     .result = REJECT,
0534     .prog_type = BPF_PROG_TYPE_XDP,
0535     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0536 },
0537 {
0538     "XDP pkt read, pkt_end >= pkt_data', corner case +1, good access",
0539     .insns = {
0540     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0541     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0542             offsetof(struct xdp_md, data_end)),
0543     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0544     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
0545     BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
0546     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0547     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
0548     BPF_MOV64_IMM(BPF_REG_0, 0),
0549     BPF_EXIT_INSN(),
0550     },
0551     .result = ACCEPT,
0552     .prog_type = BPF_PROG_TYPE_XDP,
0553     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0554 },
0555 {
0556     "XDP pkt read, pkt_end >= pkt_data', corner case -1, bad access",
0557     .insns = {
0558     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0559     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0560             offsetof(struct xdp_md, data_end)),
0561     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0562     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
0563     BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
0564     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0565     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
0566     BPF_MOV64_IMM(BPF_REG_0, 0),
0567     BPF_EXIT_INSN(),
0568     },
0569     .errstr = "R1 offset is outside of the packet",
0570     .result = REJECT,
0571     .prog_type = BPF_PROG_TYPE_XDP,
0572     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0573 },
0574 {
0575     "XDP pkt read, pkt_data' <= pkt_end, corner case, good access",
0576     .insns = {
0577     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0578     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0579             offsetof(struct xdp_md, data_end)),
0580     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0581     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0582     BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
0583     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0584     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0585     BPF_MOV64_IMM(BPF_REG_0, 0),
0586     BPF_EXIT_INSN(),
0587     },
0588     .result = ACCEPT,
0589     .prog_type = BPF_PROG_TYPE_XDP,
0590     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0591 },
0592 {
0593     "XDP pkt read, pkt_data' <= pkt_end, bad access 1",
0594     .insns = {
0595     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0596     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0597             offsetof(struct xdp_md, data_end)),
0598     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0599     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0600     BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
0601     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0602     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -4),
0603     BPF_MOV64_IMM(BPF_REG_0, 0),
0604     BPF_EXIT_INSN(),
0605     },
0606     .errstr = "R1 offset is outside of the packet",
0607     .result = REJECT,
0608     .prog_type = BPF_PROG_TYPE_XDP,
0609     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0610 },
0611 {
0612     "XDP pkt read, pkt_data' <= pkt_end, bad access 2",
0613     .insns = {
0614     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0615     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0616             offsetof(struct xdp_md, data_end)),
0617     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0618     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0619     BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
0620     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0621     BPF_MOV64_IMM(BPF_REG_0, 0),
0622     BPF_EXIT_INSN(),
0623     },
0624     .errstr = "R1 offset is outside of the packet",
0625     .result = REJECT,
0626     .prog_type = BPF_PROG_TYPE_XDP,
0627     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0628 },
0629 {
0630     "XDP pkt read, pkt_data' <= pkt_end, corner case +1, good access",
0631     .insns = {
0632     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0633     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0634             offsetof(struct xdp_md, data_end)),
0635     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0636     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
0637     BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
0638     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0639     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
0640     BPF_MOV64_IMM(BPF_REG_0, 0),
0641     BPF_EXIT_INSN(),
0642     },
0643     .result = ACCEPT,
0644     .prog_type = BPF_PROG_TYPE_XDP,
0645     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0646 },
0647 {
0648     "XDP pkt read, pkt_data' <= pkt_end, corner case -1, bad access",
0649     .insns = {
0650     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0651     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0652             offsetof(struct xdp_md, data_end)),
0653     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0654     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
0655     BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
0656     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0657     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
0658     BPF_MOV64_IMM(BPF_REG_0, 0),
0659     BPF_EXIT_INSN(),
0660     },
0661     .errstr = "R1 offset is outside of the packet",
0662     .result = REJECT,
0663     .prog_type = BPF_PROG_TYPE_XDP,
0664     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0665 },
0666 {
0667     "XDP pkt read, pkt_end <= pkt_data', good access",
0668     .insns = {
0669     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0670     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0671             offsetof(struct xdp_md, data_end)),
0672     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0673     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0674     BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),
0675     BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),
0676     BPF_MOV64_IMM(BPF_REG_0, 0),
0677     BPF_EXIT_INSN(),
0678     },
0679     .result = ACCEPT,
0680     .prog_type = BPF_PROG_TYPE_XDP,
0681     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0682 },
0683 {
0684     "XDP pkt read, pkt_end <= pkt_data', corner case -1, bad access",
0685     .insns = {
0686     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0687     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0688             offsetof(struct xdp_md, data_end)),
0689     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0690     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 6),
0691     BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),
0692     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -6),
0693     BPF_MOV64_IMM(BPF_REG_0, 0),
0694     BPF_EXIT_INSN(),
0695     },
0696     .errstr = "R1 offset is outside of the packet",
0697     .result = REJECT,
0698     .prog_type = BPF_PROG_TYPE_XDP,
0699     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0700 },
0701 {
0702     "XDP pkt read, pkt_end <= pkt_data', bad access 2",
0703     .insns = {
0704     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0705     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0706             offsetof(struct xdp_md, data_end)),
0707     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0708     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0709     BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 0),
0710     BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),
0711     BPF_MOV64_IMM(BPF_REG_0, 0),
0712     BPF_EXIT_INSN(),
0713     },
0714     .errstr = "R1 offset is outside of the packet",
0715     .result = REJECT,
0716     .prog_type = BPF_PROG_TYPE_XDP,
0717     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0718 },
0719 {
0720     "XDP pkt read, pkt_end <= pkt_data', corner case, good access",
0721     .insns = {
0722     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0723     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0724             offsetof(struct xdp_md, data_end)),
0725     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0726     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
0727     BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),
0728     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
0729     BPF_MOV64_IMM(BPF_REG_0, 0),
0730     BPF_EXIT_INSN(),
0731     },
0732     .result = ACCEPT,
0733     .prog_type = BPF_PROG_TYPE_XDP,
0734     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0735 },
0736 {
0737     "XDP pkt read, pkt_end <= pkt_data', corner case +1, good access",
0738     .insns = {
0739     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
0740     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
0741             offsetof(struct xdp_md, data_end)),
0742     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0743     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0744     BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),
0745     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0746     BPF_MOV64_IMM(BPF_REG_0, 0),
0747     BPF_EXIT_INSN(),
0748     },
0749     .result = ACCEPT,
0750     .prog_type = BPF_PROG_TYPE_XDP,
0751     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0752 },
0753 {
0754     "XDP pkt read, pkt_meta' > pkt_data, corner case, good access",
0755     .insns = {
0756     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
0757             offsetof(struct xdp_md, data_meta)),
0758     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
0759     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0760     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0761     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
0762     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0763     BPF_MOV64_IMM(BPF_REG_0, 0),
0764     BPF_EXIT_INSN(),
0765     },
0766     .result = ACCEPT,
0767     .prog_type = BPF_PROG_TYPE_XDP,
0768     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0769 },
0770 {
0771     "XDP pkt read, pkt_meta' > pkt_data, bad access 1",
0772     .insns = {
0773     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
0774             offsetof(struct xdp_md, data_meta)),
0775     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
0776     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0777     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0778     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
0779     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -4),
0780     BPF_MOV64_IMM(BPF_REG_0, 0),
0781     BPF_EXIT_INSN(),
0782     },
0783     .errstr = "R1 offset is outside of the packet",
0784     .result = REJECT,
0785     .prog_type = BPF_PROG_TYPE_XDP,
0786     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0787 },
0788 {
0789     "XDP pkt read, pkt_meta' > pkt_data, bad access 2",
0790     .insns = {
0791     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
0792             offsetof(struct xdp_md, data_meta)),
0793     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
0794     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0795     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0796     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 0),
0797     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0798     BPF_MOV64_IMM(BPF_REG_0, 0),
0799     BPF_EXIT_INSN(),
0800     },
0801     .errstr = "R1 offset is outside of the packet",
0802     .result = REJECT,
0803     .prog_type = BPF_PROG_TYPE_XDP,
0804     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0805 },
0806 {
0807     "XDP pkt read, pkt_meta' > pkt_data, corner case +1, good access",
0808     .insns = {
0809     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
0810             offsetof(struct xdp_md, data_meta)),
0811     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
0812     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0813     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
0814     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
0815     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
0816     BPF_MOV64_IMM(BPF_REG_0, 0),
0817     BPF_EXIT_INSN(),
0818     },
0819     .result = ACCEPT,
0820     .prog_type = BPF_PROG_TYPE_XDP,
0821     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0822 },
0823 {
0824     "XDP pkt read, pkt_meta' > pkt_data, corner case -1, bad access",
0825     .insns = {
0826     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
0827             offsetof(struct xdp_md, data_meta)),
0828     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
0829     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0830     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
0831     BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
0832     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
0833     BPF_MOV64_IMM(BPF_REG_0, 0),
0834     BPF_EXIT_INSN(),
0835     },
0836     .errstr = "R1 offset is outside of the packet",
0837     .result = REJECT,
0838     .prog_type = BPF_PROG_TYPE_XDP,
0839     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0840 },
0841 {
0842     "XDP pkt read, pkt_data > pkt_meta', good access",
0843     .insns = {
0844     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
0845             offsetof(struct xdp_md, data_meta)),
0846     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
0847     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0848     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0849     BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
0850     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0851     BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),
0852     BPF_MOV64_IMM(BPF_REG_0, 0),
0853     BPF_EXIT_INSN(),
0854     },
0855     .result = ACCEPT,
0856     .prog_type = BPF_PROG_TYPE_XDP,
0857     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0858 },
0859 {
0860     "XDP pkt read, pkt_data > pkt_meta', corner case -1, bad access",
0861     .insns = {
0862     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
0863             offsetof(struct xdp_md, data_meta)),
0864     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
0865     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0866     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 6),
0867     BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
0868     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0869     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -6),
0870     BPF_MOV64_IMM(BPF_REG_0, 0),
0871     BPF_EXIT_INSN(),
0872     },
0873     .errstr = "R1 offset is outside of the packet",
0874     .result = REJECT,
0875     .prog_type = BPF_PROG_TYPE_XDP,
0876     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0877 },
0878 {
0879     "XDP pkt read, pkt_data > pkt_meta', bad access 2",
0880     .insns = {
0881     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
0882             offsetof(struct xdp_md, data_meta)),
0883     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
0884     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0885     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0886     BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
0887     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0888     BPF_MOV64_IMM(BPF_REG_0, 0),
0889     BPF_EXIT_INSN(),
0890     },
0891     .errstr = "R1 offset is outside of the packet",
0892     .result = REJECT,
0893     .prog_type = BPF_PROG_TYPE_XDP,
0894     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0895 },
0896 {
0897     "XDP pkt read, pkt_data > pkt_meta', corner case, good access",
0898     .insns = {
0899     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
0900             offsetof(struct xdp_md, data_meta)),
0901     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
0902     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0903     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
0904     BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
0905     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0906     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
0907     BPF_MOV64_IMM(BPF_REG_0, 0),
0908     BPF_EXIT_INSN(),
0909     },
0910     .result = ACCEPT,
0911     .prog_type = BPF_PROG_TYPE_XDP,
0912     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0913 },
0914 {
0915     "XDP pkt read, pkt_data > pkt_meta', corner case +1, good access",
0916     .insns = {
0917     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
0918             offsetof(struct xdp_md, data_meta)),
0919     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
0920     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0921     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0922     BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
0923     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0924     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0925     BPF_MOV64_IMM(BPF_REG_0, 0),
0926     BPF_EXIT_INSN(),
0927     },
0928     .result = ACCEPT,
0929     .prog_type = BPF_PROG_TYPE_XDP,
0930     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0931 },
0932 {
0933     "XDP pkt read, pkt_meta' < pkt_data, good access",
0934     .insns = {
0935     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
0936             offsetof(struct xdp_md, data_meta)),
0937     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
0938     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0939     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0940     BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
0941     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0942     BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),
0943     BPF_MOV64_IMM(BPF_REG_0, 0),
0944     BPF_EXIT_INSN(),
0945     },
0946     .result = ACCEPT,
0947     .prog_type = BPF_PROG_TYPE_XDP,
0948     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0949 },
0950 {
0951     "XDP pkt read, pkt_meta' < pkt_data, corner case -1, bad access",
0952     .insns = {
0953     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
0954             offsetof(struct xdp_md, data_meta)),
0955     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
0956     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0957     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 6),
0958     BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
0959     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0960     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -6),
0961     BPF_MOV64_IMM(BPF_REG_0, 0),
0962     BPF_EXIT_INSN(),
0963     },
0964     .errstr = "R1 offset is outside of the packet",
0965     .result = REJECT,
0966     .prog_type = BPF_PROG_TYPE_XDP,
0967     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0968 },
0969 {
0970     "XDP pkt read, pkt_meta' < pkt_data, bad access 2",
0971     .insns = {
0972     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
0973             offsetof(struct xdp_md, data_meta)),
0974     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
0975     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0976     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
0977     BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
0978     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
0979     BPF_MOV64_IMM(BPF_REG_0, 0),
0980     BPF_EXIT_INSN(),
0981     },
0982     .errstr = "R1 offset is outside of the packet",
0983     .result = REJECT,
0984     .prog_type = BPF_PROG_TYPE_XDP,
0985     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
0986 },
0987 {
0988     "XDP pkt read, pkt_meta' < pkt_data, corner case, good access",
0989     .insns = {
0990     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
0991             offsetof(struct xdp_md, data_meta)),
0992     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
0993     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
0994     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
0995     BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
0996     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
0997     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
0998     BPF_MOV64_IMM(BPF_REG_0, 0),
0999     BPF_EXIT_INSN(),
1000     },
1001     .result = ACCEPT,
1002     .prog_type = BPF_PROG_TYPE_XDP,
1003     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1004 },
1005 {
1006     "XDP pkt read, pkt_meta' < pkt_data, corner case +1, good access",
1007     .insns = {
1008     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1009             offsetof(struct xdp_md, data_meta)),
1010     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1011     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1012     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
1013     BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
1014     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
1015     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
1016     BPF_MOV64_IMM(BPF_REG_0, 0),
1017     BPF_EXIT_INSN(),
1018     },
1019     .result = ACCEPT,
1020     .prog_type = BPF_PROG_TYPE_XDP,
1021     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1022 },
1023 {
1024     "XDP pkt read, pkt_data < pkt_meta', corner case, good access",
1025     .insns = {
1026     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1027             offsetof(struct xdp_md, data_meta)),
1028     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1029     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1030     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
1031     BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),
1032     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
1033     BPF_MOV64_IMM(BPF_REG_0, 0),
1034     BPF_EXIT_INSN(),
1035     },
1036     .result = ACCEPT,
1037     .prog_type = BPF_PROG_TYPE_XDP,
1038     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1039 },
1040 {
1041     "XDP pkt read, pkt_data < pkt_meta', bad access 1",
1042     .insns = {
1043     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1044             offsetof(struct xdp_md, data_meta)),
1045     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1046     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1047     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
1048     BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),
1049     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -4),
1050     BPF_MOV64_IMM(BPF_REG_0, 0),
1051     BPF_EXIT_INSN(),
1052     },
1053     .errstr = "R1 offset is outside of the packet",
1054     .result = REJECT,
1055     .prog_type = BPF_PROG_TYPE_XDP,
1056     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1057 },
1058 {
1059     "XDP pkt read, pkt_data < pkt_meta', bad access 2",
1060     .insns = {
1061     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1062             offsetof(struct xdp_md, data_meta)),
1063     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1064     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1065     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
1066     BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 0),
1067     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
1068     BPF_MOV64_IMM(BPF_REG_0, 0),
1069     BPF_EXIT_INSN(),
1070     },
1071     .errstr = "R1 offset is outside of the packet",
1072     .result = REJECT,
1073     .prog_type = BPF_PROG_TYPE_XDP,
1074     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1075 },
1076 {
1077     "XDP pkt read, pkt_data < pkt_meta', corner case +1, good access",
1078     .insns = {
1079     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1080             offsetof(struct xdp_md, data_meta)),
1081     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1082     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1083     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
1084     BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),
1085     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
1086     BPF_MOV64_IMM(BPF_REG_0, 0),
1087     BPF_EXIT_INSN(),
1088     },
1089     .result = ACCEPT,
1090     .prog_type = BPF_PROG_TYPE_XDP,
1091     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1092 },
1093 {
1094     "XDP pkt read, pkt_data < pkt_meta', corner case -1, bad access",
1095     .insns = {
1096     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1097             offsetof(struct xdp_md, data_meta)),
1098     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1099     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1100     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
1101     BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),
1102     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
1103     BPF_MOV64_IMM(BPF_REG_0, 0),
1104     BPF_EXIT_INSN(),
1105     },
1106     .errstr = "R1 offset is outside of the packet",
1107     .result = REJECT,
1108     .prog_type = BPF_PROG_TYPE_XDP,
1109     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1110 },
1111 {
1112     "XDP pkt read, pkt_meta' >= pkt_data, good access",
1113     .insns = {
1114     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1115             offsetof(struct xdp_md, data_meta)),
1116     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1117     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1118     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
1119     BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
1120     BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),
1121     BPF_MOV64_IMM(BPF_REG_0, 0),
1122     BPF_EXIT_INSN(),
1123     },
1124     .result = ACCEPT,
1125     .prog_type = BPF_PROG_TYPE_XDP,
1126     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1127 },
1128 {
1129     "XDP pkt read, pkt_meta' >= pkt_data, corner case -1, bad access",
1130     .insns = {
1131     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1132             offsetof(struct xdp_md, data_meta)),
1133     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1134     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1135     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 6),
1136     BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
1137     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -6),
1138     BPF_MOV64_IMM(BPF_REG_0, 0),
1139     BPF_EXIT_INSN(),
1140     },
1141     .errstr = "R1 offset is outside of the packet",
1142     .result = REJECT,
1143     .prog_type = BPF_PROG_TYPE_XDP,
1144     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1145 },
1146 {
1147     "XDP pkt read, pkt_meta' >= pkt_data, bad access 2",
1148     .insns = {
1149     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1150             offsetof(struct xdp_md, data_meta)),
1151     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1152     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1153     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
1154     BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 0),
1155     BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),
1156     BPF_MOV64_IMM(BPF_REG_0, 0),
1157     BPF_EXIT_INSN(),
1158     },
1159     .errstr = "R1 offset is outside of the packet",
1160     .result = REJECT,
1161     .prog_type = BPF_PROG_TYPE_XDP,
1162     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1163 },
1164 {
1165     "XDP pkt read, pkt_meta' >= pkt_data, corner case, good access",
1166     .insns = {
1167     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1168             offsetof(struct xdp_md, data_meta)),
1169     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1170     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1171     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
1172     BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
1173     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
1174     BPF_MOV64_IMM(BPF_REG_0, 0),
1175     BPF_EXIT_INSN(),
1176     },
1177     .result = ACCEPT,
1178     .prog_type = BPF_PROG_TYPE_XDP,
1179     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1180 },
1181 {
1182     "XDP pkt read, pkt_meta' >= pkt_data, corner case +1, good access",
1183     .insns = {
1184     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1185             offsetof(struct xdp_md, data_meta)),
1186     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1187     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1188     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
1189     BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
1190     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
1191     BPF_MOV64_IMM(BPF_REG_0, 0),
1192     BPF_EXIT_INSN(),
1193     },
1194     .result = ACCEPT,
1195     .prog_type = BPF_PROG_TYPE_XDP,
1196     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1197 },
1198 {
1199     "XDP pkt read, pkt_data >= pkt_meta', corner case, good access",
1200     .insns = {
1201     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1202             offsetof(struct xdp_md, data_meta)),
1203     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1204     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1205     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
1206     BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
1207     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
1208     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
1209     BPF_MOV64_IMM(BPF_REG_0, 0),
1210     BPF_EXIT_INSN(),
1211     },
1212     .result = ACCEPT,
1213     .prog_type = BPF_PROG_TYPE_XDP,
1214     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1215 },
1216 {
1217     "XDP pkt read, pkt_data >= pkt_meta', bad access 1",
1218     .insns = {
1219     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1220             offsetof(struct xdp_md, data_meta)),
1221     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1222     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1223     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
1224     BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
1225     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
1226     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -4),
1227     BPF_MOV64_IMM(BPF_REG_0, 0),
1228     BPF_EXIT_INSN(),
1229     },
1230     .errstr = "R1 offset is outside of the packet",
1231     .result = REJECT,
1232     .prog_type = BPF_PROG_TYPE_XDP,
1233     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1234 },
1235 {
1236     "XDP pkt read, pkt_data >= pkt_meta', bad access 2",
1237     .insns = {
1238     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1239             offsetof(struct xdp_md, data_meta)),
1240     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1241     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1242     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
1243     BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
1244     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
1245     BPF_MOV64_IMM(BPF_REG_0, 0),
1246     BPF_EXIT_INSN(),
1247     },
1248     .errstr = "R1 offset is outside of the packet",
1249     .result = REJECT,
1250     .prog_type = BPF_PROG_TYPE_XDP,
1251     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1252 },
1253 {
1254     "XDP pkt read, pkt_data >= pkt_meta', corner case +1, good access",
1255     .insns = {
1256     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1257             offsetof(struct xdp_md, data_meta)),
1258     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1259     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1260     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
1261     BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
1262     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
1263     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
1264     BPF_MOV64_IMM(BPF_REG_0, 0),
1265     BPF_EXIT_INSN(),
1266     },
1267     .result = ACCEPT,
1268     .prog_type = BPF_PROG_TYPE_XDP,
1269     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1270 },
1271 {
1272     "XDP pkt read, pkt_data >= pkt_meta', corner case -1, bad access",
1273     .insns = {
1274     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1275             offsetof(struct xdp_md, data_meta)),
1276     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1277     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1278     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
1279     BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
1280     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
1281     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
1282     BPF_MOV64_IMM(BPF_REG_0, 0),
1283     BPF_EXIT_INSN(),
1284     },
1285     .errstr = "R1 offset is outside of the packet",
1286     .result = REJECT,
1287     .prog_type = BPF_PROG_TYPE_XDP,
1288     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1289 },
1290 {
1291     "XDP pkt read, pkt_meta' <= pkt_data, corner case, good access",
1292     .insns = {
1293     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1294             offsetof(struct xdp_md, data_meta)),
1295     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1296     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1297     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
1298     BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
1299     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
1300     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
1301     BPF_MOV64_IMM(BPF_REG_0, 0),
1302     BPF_EXIT_INSN(),
1303     },
1304     .result = ACCEPT,
1305     .prog_type = BPF_PROG_TYPE_XDP,
1306     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1307 },
1308 {
1309     "XDP pkt read, pkt_meta' <= pkt_data, bad access 1",
1310     .insns = {
1311     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1312             offsetof(struct xdp_md, data_meta)),
1313     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1314     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1315     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
1316     BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
1317     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
1318     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -4),
1319     BPF_MOV64_IMM(BPF_REG_0, 0),
1320     BPF_EXIT_INSN(),
1321     },
1322     .errstr = "R1 offset is outside of the packet",
1323     .result = REJECT,
1324     .prog_type = BPF_PROG_TYPE_XDP,
1325     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1326 },
1327 {
1328     "XDP pkt read, pkt_meta' <= pkt_data, bad access 2",
1329     .insns = {
1330     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1331             offsetof(struct xdp_md, data_meta)),
1332     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1333     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1334     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
1335     BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
1336     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
1337     BPF_MOV64_IMM(BPF_REG_0, 0),
1338     BPF_EXIT_INSN(),
1339     },
1340     .errstr = "R1 offset is outside of the packet",
1341     .result = REJECT,
1342     .prog_type = BPF_PROG_TYPE_XDP,
1343     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1344 },
1345 {
1346     "XDP pkt read, pkt_meta' <= pkt_data, corner case +1, good access",
1347     .insns = {
1348     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1349             offsetof(struct xdp_md, data_meta)),
1350     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1351     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1352     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
1353     BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
1354     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
1355     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
1356     BPF_MOV64_IMM(BPF_REG_0, 0),
1357     BPF_EXIT_INSN(),
1358     },
1359     .result = ACCEPT,
1360     .prog_type = BPF_PROG_TYPE_XDP,
1361     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1362 },
1363 {
1364     "XDP pkt read, pkt_meta' <= pkt_data, corner case -1, bad access",
1365     .insns = {
1366     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1367             offsetof(struct xdp_md, data_meta)),
1368     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1369     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1370     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
1371     BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
1372     BPF_JMP_IMM(BPF_JA, 0, 0, 1),
1373     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
1374     BPF_MOV64_IMM(BPF_REG_0, 0),
1375     BPF_EXIT_INSN(),
1376     },
1377     .errstr = "R1 offset is outside of the packet",
1378     .result = REJECT,
1379     .prog_type = BPF_PROG_TYPE_XDP,
1380     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1381 },
1382 {
1383     "XDP pkt read, pkt_data <= pkt_meta', good access",
1384     .insns = {
1385     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1386             offsetof(struct xdp_md, data_meta)),
1387     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1388     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1389     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
1390     BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),
1391     BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),
1392     BPF_MOV64_IMM(BPF_REG_0, 0),
1393     BPF_EXIT_INSN(),
1394     },
1395     .result = ACCEPT,
1396     .prog_type = BPF_PROG_TYPE_XDP,
1397     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1398 },
1399 {
1400     "XDP pkt read, pkt_data <= pkt_meta', corner case -1, bad access",
1401     .insns = {
1402     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1403             offsetof(struct xdp_md, data_meta)),
1404     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1405     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1406     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 6),
1407     BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),
1408     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -6),
1409     BPF_MOV64_IMM(BPF_REG_0, 0),
1410     BPF_EXIT_INSN(),
1411     },
1412     .errstr = "R1 offset is outside of the packet",
1413     .result = REJECT,
1414     .prog_type = BPF_PROG_TYPE_XDP,
1415     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1416 },
1417 {
1418     "XDP pkt read, pkt_data <= pkt_meta', bad access 2",
1419     .insns = {
1420     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1421             offsetof(struct xdp_md, data_meta)),
1422     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1423     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1424     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
1425     BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 0),
1426     BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),
1427     BPF_MOV64_IMM(BPF_REG_0, 0),
1428     BPF_EXIT_INSN(),
1429     },
1430     .errstr = "R1 offset is outside of the packet",
1431     .result = REJECT,
1432     .prog_type = BPF_PROG_TYPE_XDP,
1433     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1434 },
1435 {
1436     "XDP pkt read, pkt_data <= pkt_meta', corner case, good access",
1437     .insns = {
1438     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1439             offsetof(struct xdp_md, data_meta)),
1440     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1441     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1442     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
1443     BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),
1444     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
1445     BPF_MOV64_IMM(BPF_REG_0, 0),
1446     BPF_EXIT_INSN(),
1447     },
1448     .result = ACCEPT,
1449     .prog_type = BPF_PROG_TYPE_XDP,
1450     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1451 },
1452 {
1453     "XDP pkt read, pkt_data <= pkt_meta', corner case +1, good access",
1454     .insns = {
1455     BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
1456             offsetof(struct xdp_md, data_meta)),
1457     BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
1458     BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
1459     BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
1460     BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),
1461     BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
1462     BPF_MOV64_IMM(BPF_REG_0, 0),
1463     BPF_EXIT_INSN(),
1464     },
1465     .result = ACCEPT,
1466     .prog_type = BPF_PROG_TYPE_XDP,
1467     .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
1468 },
[ 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!