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

   1 {
   2         "map access: known scalar += value_ptr from different maps",
   3         .insns = {
   4         BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1,
   5                     offsetof(struct __sk_buff, len)),
   6         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
   7         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
   8         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
   9         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 1, 3),
  10         BPF_LD_MAP_FD(BPF_REG_1, 0),
  11         BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 1, 2),
  12         BPF_LD_MAP_FD(BPF_REG_1, 0),
  13         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
  14         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 3),
  15         BPF_MOV64_IMM(BPF_REG_1, 4),
  16         BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_0),
  17         BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_1, 0),
  18         BPF_MOV64_IMM(BPF_REG_0, 1),
  19         BPF_EXIT_INSN(),
  20         },
  21         .fixup_map_hash_16b = { 5 },
  22         .fixup_map_array_48b = { 8 },
  23         .result = ACCEPT,
  24         .retval = 1,
  25 },
  26 {
  27         "map access: value_ptr -= known scalar from different maps",
  28         .insns = {
  29         BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1,
  30                     offsetof(struct __sk_buff, len)),
  31         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
  32         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
  33         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
  34         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 1, 3),
  35         BPF_LD_MAP_FD(BPF_REG_1, 0),
  36         BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 1, 2),
  37         BPF_LD_MAP_FD(BPF_REG_1, 0),
  38         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
  39         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 4),
  40         BPF_MOV64_IMM(BPF_REG_1, 4),
  41         BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
  42         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
  43         BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_0, 0),
  44         BPF_MOV64_IMM(BPF_REG_0, 1),
  45         BPF_EXIT_INSN(),
  46         },
  47         .fixup_map_hash_16b = { 5 },
  48         .fixup_map_array_48b = { 8 },
  49         .result = ACCEPT,
  50         .result_unpriv = REJECT,
  51         .errstr_unpriv = "R0 min value is outside of the allowed memory range",
  52         .retval = 1,
  53 },
  54 {
  55         "map access: known scalar += value_ptr from different maps, but same value properties",
  56         .insns = {
  57         BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1,
  58                     offsetof(struct __sk_buff, len)),
  59         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
  60         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
  61         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
  62         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 1, 3),
  63         BPF_LD_MAP_FD(BPF_REG_1, 0),
  64         BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 1, 2),
  65         BPF_LD_MAP_FD(BPF_REG_1, 0),
  66         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
  67         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 3),
  68         BPF_MOV64_IMM(BPF_REG_1, 4),
  69         BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_0),
  70         BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_1, 0),
  71         BPF_MOV64_IMM(BPF_REG_0, 1),
  72         BPF_EXIT_INSN(),
  73         },
  74         .fixup_map_hash_48b = { 5 },
  75         .fixup_map_array_48b = { 8 },
  76         .result = ACCEPT,
  77         .retval = 1,
  78 },
  79 {
  80         "map access: mixing value pointer and scalar, 1",
  81         .insns = {
  82         // load map value pointer into r0 and r2
  83         BPF_MOV64_IMM(BPF_REG_0, 1),
  84         BPF_LD_MAP_FD(BPF_REG_ARG1, 0),
  85         BPF_MOV64_REG(BPF_REG_ARG2, BPF_REG_FP),
  86         BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG2, -16),
  87         BPF_ST_MEM(BPF_DW, BPF_REG_FP, -16, 0),
  88         BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
  89         BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
  90         BPF_EXIT_INSN(),
  91         // load some number from the map into r1
  92         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
  93         // depending on r1, branch:
  94         BPF_JMP_IMM(BPF_JNE, BPF_REG_1, 0, 3),
  95         // branch A
  96         BPF_MOV64_REG(BPF_REG_2, BPF_REG_0),
  97         BPF_MOV64_IMM(BPF_REG_3, 0),
  98         BPF_JMP_A(2),
  99         // branch B
 100         BPF_MOV64_IMM(BPF_REG_2, 0),
 101         BPF_MOV64_IMM(BPF_REG_3, 0x100000),
 102         // common instruction
 103         BPF_ALU64_REG(BPF_ADD, BPF_REG_2, BPF_REG_3),
 104         // depending on r1, branch:
 105         BPF_JMP_IMM(BPF_JNE, BPF_REG_1, 0, 1),
 106         // branch A
 107         BPF_JMP_A(4),
 108         // branch B
 109         BPF_MOV64_IMM(BPF_REG_0, 0x13371337),
 110         // verifier follows fall-through
 111         BPF_JMP_IMM(BPF_JNE, BPF_REG_2, 0x100000, 2),
 112         BPF_MOV64_IMM(BPF_REG_0, 0),
 113         BPF_EXIT_INSN(),
 114         // fake-dead code; targeted from branch A to
 115         // prevent dead code sanitization
 116         BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_0, 0),
 117         BPF_MOV64_IMM(BPF_REG_0, 0),
 118         BPF_EXIT_INSN(),
 119         },
 120         .fixup_map_array_48b = { 1 },
 121         .result = ACCEPT,
 122         .result_unpriv = REJECT,
 123         .errstr_unpriv = "R2 pointer comparison prohibited",
 124         .retval = 0,
 125 },
 126 {
 127         "map access: mixing value pointer and scalar, 2",
 128         .insns = {
 129         // load map value pointer into r0 and r2
 130         BPF_MOV64_IMM(BPF_REG_0, 1),
 131         BPF_LD_MAP_FD(BPF_REG_ARG1, 0),
 132         BPF_MOV64_REG(BPF_REG_ARG2, BPF_REG_FP),
 133         BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG2, -16),
 134         BPF_ST_MEM(BPF_DW, BPF_REG_FP, -16, 0),
 135         BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
 136         BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
 137         BPF_EXIT_INSN(),
 138         // load some number from the map into r1
 139         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 140         // depending on r1, branch:
 141         BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 3),
 142         // branch A
 143         BPF_MOV64_IMM(BPF_REG_2, 0),
 144         BPF_MOV64_IMM(BPF_REG_3, 0x100000),
 145         BPF_JMP_A(2),
 146         // branch B
 147         BPF_MOV64_REG(BPF_REG_2, BPF_REG_0),
 148         BPF_MOV64_IMM(BPF_REG_3, 0),
 149         // common instruction
 150         BPF_ALU64_REG(BPF_ADD, BPF_REG_2, BPF_REG_3),
 151         // depending on r1, branch:
 152         BPF_JMP_IMM(BPF_JNE, BPF_REG_1, 0, 1),
 153         // branch A
 154         BPF_JMP_A(4),
 155         // branch B
 156         BPF_MOV64_IMM(BPF_REG_0, 0x13371337),
 157         // verifier follows fall-through
 158         BPF_JMP_IMM(BPF_JNE, BPF_REG_2, 0x100000, 2),
 159         BPF_MOV64_IMM(BPF_REG_0, 0),
 160         BPF_EXIT_INSN(),
 161         // fake-dead code; targeted from branch A to
 162         // prevent dead code sanitization, rejected
 163         // via branch B however
 164         BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_0, 0),
 165         BPF_MOV64_IMM(BPF_REG_0, 0),
 166         BPF_EXIT_INSN(),
 167         },
 168         .fixup_map_array_48b = { 1 },
 169         .result = ACCEPT,
 170         .result_unpriv = REJECT,
 171         .errstr_unpriv = "R0 invalid mem access 'inv'",
 172         .retval = 0,
 173 },
 174 {
 175         "sanitation: alu with different scalars 1",
 176         .insns = {
 177         BPF_MOV64_IMM(BPF_REG_0, 1),
 178         BPF_LD_MAP_FD(BPF_REG_ARG1, 0),
 179         BPF_MOV64_REG(BPF_REG_ARG2, BPF_REG_FP),
 180         BPF_ALU64_IMM(BPF_ADD, BPF_REG_ARG2, -16),
 181         BPF_ST_MEM(BPF_DW, BPF_REG_FP, -16, 0),
 182         BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
 183         BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
 184         BPF_EXIT_INSN(),
 185         BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 0),
 186         BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 3),
 187         BPF_MOV64_IMM(BPF_REG_2, 0),
 188         BPF_MOV64_IMM(BPF_REG_3, 0x100000),
 189         BPF_JMP_A(2),
 190         BPF_MOV64_IMM(BPF_REG_2, 42),
 191         BPF_MOV64_IMM(BPF_REG_3, 0x100001),
 192         BPF_ALU64_REG(BPF_ADD, BPF_REG_2, BPF_REG_3),
 193         BPF_MOV64_REG(BPF_REG_0, BPF_REG_2),
 194         BPF_EXIT_INSN(),
 195         },
 196         .fixup_map_array_48b = { 1 },
 197         .result = ACCEPT,
 198         .retval = 0x100000,
 199 },
 200 {
 201         "sanitation: alu with different scalars 2",
 202         .insns = {
 203         BPF_MOV64_IMM(BPF_REG_0, 1),
 204         BPF_LD_MAP_FD(BPF_REG_1, 0),
 205         BPF_MOV64_REG(BPF_REG_6, BPF_REG_1),
 206         BPF_MOV64_REG(BPF_REG_2, BPF_REG_FP),
 207         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -16),
 208         BPF_ST_MEM(BPF_DW, BPF_REG_FP, -16, 0),
 209         BPF_EMIT_CALL(BPF_FUNC_map_delete_elem),
 210         BPF_MOV64_REG(BPF_REG_7, BPF_REG_0),
 211         BPF_MOV64_REG(BPF_REG_1, BPF_REG_6),
 212         BPF_MOV64_REG(BPF_REG_2, BPF_REG_FP),
 213         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -16),
 214         BPF_EMIT_CALL(BPF_FUNC_map_delete_elem),
 215         BPF_MOV64_REG(BPF_REG_6, BPF_REG_0),
 216         BPF_MOV64_REG(BPF_REG_8, BPF_REG_6),
 217         BPF_ALU64_REG(BPF_ADD, BPF_REG_8, BPF_REG_7),
 218         BPF_MOV64_REG(BPF_REG_0, BPF_REG_8),
 219         BPF_EXIT_INSN(),
 220         },
 221         .fixup_map_array_48b = { 1 },
 222         .result = ACCEPT,
 223         .retval = -EINVAL * 2,
 224 },
 225 {
 226         "sanitation: alu with different scalars 3",
 227         .insns = {
 228         BPF_MOV64_IMM(BPF_REG_0, EINVAL),
 229         BPF_ALU64_IMM(BPF_MUL, BPF_REG_0, -1),
 230         BPF_MOV64_REG(BPF_REG_7, BPF_REG_0),
 231         BPF_MOV64_IMM(BPF_REG_0, EINVAL),
 232         BPF_ALU64_IMM(BPF_MUL, BPF_REG_0, -1),
 233         BPF_MOV64_REG(BPF_REG_6, BPF_REG_0),
 234         BPF_MOV64_REG(BPF_REG_8, BPF_REG_6),
 235         BPF_ALU64_REG(BPF_ADD, BPF_REG_8, BPF_REG_7),
 236         BPF_MOV64_REG(BPF_REG_0, BPF_REG_8),
 237         BPF_EXIT_INSN(),
 238         },
 239         .result = ACCEPT,
 240         .retval = -EINVAL * 2,
 241 },
 242 {
 243         "map access: value_ptr += known scalar, upper oob arith, test 1",
 244         .insns = {
 245         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 246         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 247         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 248         BPF_LD_MAP_FD(BPF_REG_1, 0),
 249         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 250         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 4),
 251         BPF_MOV64_IMM(BPF_REG_1, 48),
 252         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 253         BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
 254         BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_0, 0),
 255         BPF_MOV64_IMM(BPF_REG_0, 1),
 256         BPF_EXIT_INSN(),
 257         },
 258         .fixup_map_array_48b = { 3 },
 259         .result = ACCEPT,
 260         .result_unpriv = REJECT,
 261         .errstr_unpriv = "R0 pointer arithmetic of map value goes out of range",
 262         .retval = 1,
 263 },
 264 {
 265         "map access: value_ptr += known scalar, upper oob arith, test 2",
 266         .insns = {
 267         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 268         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 269         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 270         BPF_LD_MAP_FD(BPF_REG_1, 0),
 271         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 272         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 4),
 273         BPF_MOV64_IMM(BPF_REG_1, 49),
 274         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 275         BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
 276         BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_0, 0),
 277         BPF_MOV64_IMM(BPF_REG_0, 1),
 278         BPF_EXIT_INSN(),
 279         },
 280         .fixup_map_array_48b = { 3 },
 281         .result = ACCEPT,
 282         .result_unpriv = REJECT,
 283         .errstr_unpriv = "R0 pointer arithmetic of map value goes out of range",
 284         .retval = 1,
 285 },
 286 {
 287         "map access: value_ptr += known scalar, upper oob arith, test 3",
 288         .insns = {
 289         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 290         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 291         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 292         BPF_LD_MAP_FD(BPF_REG_1, 0),
 293         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 294         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 4),
 295         BPF_MOV64_IMM(BPF_REG_1, 47),
 296         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 297         BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
 298         BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_0, 0),
 299         BPF_MOV64_IMM(BPF_REG_0, 1),
 300         BPF_EXIT_INSN(),
 301         },
 302         .fixup_map_array_48b = { 3 },
 303         .result = ACCEPT,
 304         .retval = 1,
 305 },
 306 {
 307         "map access: value_ptr -= known scalar, lower oob arith, test 1",
 308         .insns = {
 309         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 310         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 311         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 312         BPF_LD_MAP_FD(BPF_REG_1, 0),
 313         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 314         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 5),
 315         BPF_MOV64_IMM(BPF_REG_1, 47),
 316         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 317         BPF_MOV64_IMM(BPF_REG_1, 48),
 318         BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
 319         BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_0, 0),
 320         BPF_MOV64_IMM(BPF_REG_0, 1),
 321         BPF_EXIT_INSN(),
 322         },
 323         .fixup_map_array_48b = { 3 },
 324         .result = REJECT,
 325         .errstr = "R0 min value is outside of the allowed memory range",
 326         .result_unpriv = REJECT,
 327         .errstr_unpriv = "R0 pointer arithmetic of map value goes out of range",
 328 },
 329 {
 330         "map access: value_ptr -= known scalar, lower oob arith, test 2",
 331         .insns = {
 332         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 333         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 334         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 335         BPF_LD_MAP_FD(BPF_REG_1, 0),
 336         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 337         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 7),
 338         BPF_MOV64_IMM(BPF_REG_1, 47),
 339         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 340         BPF_MOV64_IMM(BPF_REG_1, 48),
 341         BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
 342         BPF_MOV64_IMM(BPF_REG_1, 1),
 343         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 344         BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_0, 0),
 345         BPF_MOV64_IMM(BPF_REG_0, 1),
 346         BPF_EXIT_INSN(),
 347         },
 348         .fixup_map_array_48b = { 3 },
 349         .result = ACCEPT,
 350         .result_unpriv = REJECT,
 351         .errstr_unpriv = "R0 pointer arithmetic of map value goes out of range",
 352         .retval = 1,
 353 },
 354 {
 355         "map access: value_ptr -= known scalar, lower oob arith, test 3",
 356         .insns = {
 357         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 358         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 359         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 360         BPF_LD_MAP_FD(BPF_REG_1, 0),
 361         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 362         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 5),
 363         BPF_MOV64_IMM(BPF_REG_1, 47),
 364         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 365         BPF_MOV64_IMM(BPF_REG_1, 47),
 366         BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
 367         BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_0, 0),
 368         BPF_MOV64_IMM(BPF_REG_0, 1),
 369         BPF_EXIT_INSN(),
 370         },
 371         .fixup_map_array_48b = { 3 },
 372         .result = ACCEPT,
 373         .retval = 1,
 374 },
 375 {
 376         "map access: known scalar += value_ptr",
 377         .insns = {
 378         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 379         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 380         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 381         BPF_LD_MAP_FD(BPF_REG_1, 0),
 382         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 383         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 3),
 384         BPF_MOV64_IMM(BPF_REG_1, 4),
 385         BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_0),
 386         BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_1, 0),
 387         BPF_MOV64_IMM(BPF_REG_0, 1),
 388         BPF_EXIT_INSN(),
 389         },
 390         .fixup_map_array_48b = { 3 },
 391         .result = ACCEPT,
 392         .retval = 1,
 393 },
 394 {
 395         "map access: value_ptr += known scalar, 1",
 396         .insns = {
 397         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 398         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 399         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 400         BPF_LD_MAP_FD(BPF_REG_1, 0),
 401         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 402         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 3),
 403         BPF_MOV64_IMM(BPF_REG_1, 4),
 404         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 405         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 406         BPF_MOV64_IMM(BPF_REG_0, 1),
 407         BPF_EXIT_INSN(),
 408         },
 409         .fixup_map_array_48b = { 3 },
 410         .result = ACCEPT,
 411         .retval = 1,
 412 },
 413 {
 414         "map access: value_ptr += known scalar, 2",
 415         .insns = {
 416         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 417         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 418         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 419         BPF_LD_MAP_FD(BPF_REG_1, 0),
 420         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 421         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 3),
 422         BPF_MOV64_IMM(BPF_REG_1, 49),
 423         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 424         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 425         BPF_MOV64_IMM(BPF_REG_0, 1),
 426         BPF_EXIT_INSN(),
 427         },
 428         .fixup_map_array_48b = { 3 },
 429         .result = REJECT,
 430         .errstr = "invalid access to map value",
 431 },
 432 {
 433         "map access: value_ptr += known scalar, 3",
 434         .insns = {
 435         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 436         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 437         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 438         BPF_LD_MAP_FD(BPF_REG_1, 0),
 439         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 440         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 3),
 441         BPF_MOV64_IMM(BPF_REG_1, -1),
 442         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 443         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 444         BPF_MOV64_IMM(BPF_REG_0, 1),
 445         BPF_EXIT_INSN(),
 446         },
 447         .fixup_map_array_48b = { 3 },
 448         .result = REJECT,
 449         .errstr = "invalid access to map value",
 450 },
 451 {
 452         "map access: value_ptr += known scalar, 4",
 453         .insns = {
 454         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 455         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 456         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 457         BPF_LD_MAP_FD(BPF_REG_1, 0),
 458         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 459         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 7),
 460         BPF_MOV64_IMM(BPF_REG_1, 5),
 461         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 462         BPF_MOV64_IMM(BPF_REG_1, -2),
 463         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 464         BPF_MOV64_IMM(BPF_REG_1, -1),
 465         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 466         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 467         BPF_MOV64_IMM(BPF_REG_0, 1),
 468         BPF_EXIT_INSN(),
 469         },
 470         .fixup_map_array_48b = { 3 },
 471         .result = ACCEPT,
 472         .retval = 1,
 473 },
 474 {
 475         "map access: value_ptr += known scalar, 5",
 476         .insns = {
 477         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 478         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 479         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 480         BPF_LD_MAP_FD(BPF_REG_1, 0),
 481         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 482         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 3),
 483         BPF_MOV64_IMM(BPF_REG_1, (6 + 1) * sizeof(int)),
 484         BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_0),
 485         BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 0),
 486         BPF_EXIT_INSN(),
 487         },
 488         .fixup_map_array_48b = { 3 },
 489         .result = ACCEPT,
 490         .retval = 0xabcdef12,
 491 },
 492 {
 493         "map access: value_ptr += known scalar, 6",
 494         .insns = {
 495         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 496         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 497         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 498         BPF_LD_MAP_FD(BPF_REG_1, 0),
 499         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 500         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 5),
 501         BPF_MOV64_IMM(BPF_REG_1, (3 + 1) * sizeof(int)),
 502         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 503         BPF_MOV64_IMM(BPF_REG_1, 3 * sizeof(int)),
 504         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 505         BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_0, 0),
 506         BPF_EXIT_INSN(),
 507         },
 508         .fixup_map_array_48b = { 3 },
 509         .result = ACCEPT,
 510         .retval = 0xabcdef12,
 511 },
 512 {
 513         "map access: value_ptr += N, value_ptr -= N known scalar",
 514         .insns = {
 515         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 516         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 517         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 518         BPF_LD_MAP_FD(BPF_REG_1, 0),
 519         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 520         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 6),
 521         BPF_MOV32_IMM(BPF_REG_1, 0x12345678),
 522         BPF_STX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 0),
 523         BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 2),
 524         BPF_MOV64_IMM(BPF_REG_1, 2),
 525         BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
 526         BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_0, 0),
 527         BPF_EXIT_INSN(),
 528         },
 529         .fixup_map_array_48b = { 3 },
 530         .result = ACCEPT,
 531         .retval = 0x12345678,
 532 },
 533 {
 534         "map access: unknown scalar += value_ptr, 1",
 535         .insns = {
 536         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 537         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 538         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 539         BPF_LD_MAP_FD(BPF_REG_1, 0),
 540         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 541         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 4),
 542         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 543         BPF_ALU64_IMM(BPF_AND, BPF_REG_1, 0xf),
 544         BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_0),
 545         BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_1, 0),
 546         BPF_MOV64_IMM(BPF_REG_0, 1),
 547         BPF_EXIT_INSN(),
 548         },
 549         .fixup_map_array_48b = { 3 },
 550         .result = ACCEPT,
 551         .retval = 1,
 552 },
 553 {
 554         "map access: unknown scalar += value_ptr, 2",
 555         .insns = {
 556         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 557         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 558         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 559         BPF_LD_MAP_FD(BPF_REG_1, 0),
 560         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 561         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 4),
 562         BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 0),
 563         BPF_ALU64_IMM(BPF_AND, BPF_REG_1, 31),
 564         BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_0),
 565         BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 0),
 566         BPF_EXIT_INSN(),
 567         },
 568         .fixup_map_array_48b = { 3 },
 569         .result = ACCEPT,
 570         .retval = 0xabcdef12,
 571         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 572 },
 573 {
 574         "map access: unknown scalar += value_ptr, 3",
 575         .insns = {
 576         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 577         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 578         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 579         BPF_LD_MAP_FD(BPF_REG_1, 0),
 580         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 581         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 8),
 582         BPF_MOV64_IMM(BPF_REG_1, -1),
 583         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 584         BPF_MOV64_IMM(BPF_REG_1, 1),
 585         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 586         BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 0),
 587         BPF_ALU64_IMM(BPF_AND, BPF_REG_1, 31),
 588         BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_0),
 589         BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 0),
 590         BPF_EXIT_INSN(),
 591         },
 592         .fixup_map_array_48b = { 3 },
 593         .result = ACCEPT,
 594         .result_unpriv = REJECT,
 595         .errstr_unpriv = "R0 pointer arithmetic of map value goes out of range",
 596         .retval = 0xabcdef12,
 597         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 598 },
 599 {
 600         "map access: unknown scalar += value_ptr, 4",
 601         .insns = {
 602         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 603         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 604         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 605         BPF_LD_MAP_FD(BPF_REG_1, 0),
 606         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 607         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 6),
 608         BPF_MOV64_IMM(BPF_REG_1, 19),
 609         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 610         BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 0),
 611         BPF_ALU64_IMM(BPF_AND, BPF_REG_1, 31),
 612         BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_0),
 613         BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, 0),
 614         BPF_EXIT_INSN(),
 615         },
 616         .fixup_map_array_48b = { 3 },
 617         .result = REJECT,
 618         .errstr = "R1 max value is outside of the allowed memory range",
 619         .errstr_unpriv = "R1 pointer arithmetic of map value goes out of range",
 620         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 621 },
 622 {
 623         "map access: value_ptr += unknown scalar, 1",
 624         .insns = {
 625         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 626         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 627         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 628         BPF_LD_MAP_FD(BPF_REG_1, 0),
 629         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 630         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 4),
 631         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 632         BPF_ALU64_IMM(BPF_AND, BPF_REG_1, 0xf),
 633         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 634         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 635         BPF_MOV64_IMM(BPF_REG_0, 1),
 636         BPF_EXIT_INSN(),
 637         },
 638         .fixup_map_array_48b = { 3 },
 639         .result = ACCEPT,
 640         .retval = 1,
 641 },
 642 {
 643         "map access: value_ptr += unknown scalar, 2",
 644         .insns = {
 645         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 646         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 647         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 648         BPF_LD_MAP_FD(BPF_REG_1, 0),
 649         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 650         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 4),
 651         BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 0),
 652         BPF_ALU64_IMM(BPF_AND, BPF_REG_1, 31),
 653         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 654         BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_0, 0),
 655         BPF_EXIT_INSN(),
 656         },
 657         .fixup_map_array_48b = { 3 },
 658         .result = ACCEPT,
 659         .retval = 0xabcdef12,
 660         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 661 },
 662 {
 663         "map access: value_ptr += unknown scalar, 3",
 664         .insns = {
 665         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 666         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 667         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 668         BPF_LD_MAP_FD(BPF_REG_1, 0),
 669         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 670         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 11),
 671         BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_0, 0),
 672         BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_0, 8),
 673         BPF_LDX_MEM(BPF_DW, BPF_REG_3, BPF_REG_0, 16),
 674         BPF_ALU64_IMM(BPF_AND, BPF_REG_1, 0xf),
 675         BPF_ALU64_IMM(BPF_AND, BPF_REG_3, 1),
 676         BPF_ALU64_IMM(BPF_OR, BPF_REG_3, 1),
 677         BPF_JMP_REG(BPF_JGT, BPF_REG_2, BPF_REG_3, 4),
 678         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_3),
 679         BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_0, 0),
 680         BPF_MOV64_IMM(BPF_REG_0, 1),
 681         BPF_EXIT_INSN(),
 682         BPF_MOV64_IMM(BPF_REG_0, 2),
 683         BPF_JMP_IMM(BPF_JA, 0, 0, -3),
 684         },
 685         .fixup_map_array_48b = { 3 },
 686         .result = ACCEPT,
 687         .retval = 1,
 688 },
 689 {
 690         "map access: value_ptr += value_ptr",
 691         .insns = {
 692         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 693         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 694         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 695         BPF_LD_MAP_FD(BPF_REG_1, 0),
 696         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 697         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2),
 698         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_0),
 699         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 700         BPF_MOV64_IMM(BPF_REG_0, 1),
 701         BPF_EXIT_INSN(),
 702         },
 703         .fixup_map_array_48b = { 3 },
 704         .result = REJECT,
 705         .errstr = "R0 pointer += pointer prohibited",
 706 },
 707 {
 708         "map access: known scalar -= value_ptr",
 709         .insns = {
 710         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 711         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 712         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 713         BPF_LD_MAP_FD(BPF_REG_1, 0),
 714         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 715         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 3),
 716         BPF_MOV64_IMM(BPF_REG_1, 4),
 717         BPF_ALU64_REG(BPF_SUB, BPF_REG_1, BPF_REG_0),
 718         BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_1, 0),
 719         BPF_MOV64_IMM(BPF_REG_0, 1),
 720         BPF_EXIT_INSN(),
 721         },
 722         .fixup_map_array_48b = { 3 },
 723         .result = REJECT,
 724         .errstr = "R1 tried to subtract pointer from scalar",
 725 },
 726 {
 727         "map access: value_ptr -= known scalar",
 728         .insns = {
 729         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 730         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 731         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 732         BPF_LD_MAP_FD(BPF_REG_1, 0),
 733         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 734         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 3),
 735         BPF_MOV64_IMM(BPF_REG_1, 4),
 736         BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
 737         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 738         BPF_MOV64_IMM(BPF_REG_0, 1),
 739         BPF_EXIT_INSN(),
 740         },
 741         .fixup_map_array_48b = { 3 },
 742         .result = REJECT,
 743         .errstr = "R0 min value is outside of the allowed memory range",
 744 },
 745 {
 746         "map access: value_ptr -= known scalar, 2",
 747         .insns = {
 748         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 749         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 750         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 751         BPF_LD_MAP_FD(BPF_REG_1, 0),
 752         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 753         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 5),
 754         BPF_MOV64_IMM(BPF_REG_1, 6),
 755         BPF_MOV64_IMM(BPF_REG_2, 4),
 756         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 757         BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_2),
 758         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 759         BPF_MOV64_IMM(BPF_REG_0, 1),
 760         BPF_EXIT_INSN(),
 761         },
 762         .fixup_map_array_48b = { 3 },
 763         .result = ACCEPT,
 764         .retval = 1,
 765 },
 766 {
 767         "map access: unknown scalar -= value_ptr",
 768         .insns = {
 769         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 770         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 771         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 772         BPF_LD_MAP_FD(BPF_REG_1, 0),
 773         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 774         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 4),
 775         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 776         BPF_ALU64_IMM(BPF_AND, BPF_REG_1, 0xf),
 777         BPF_ALU64_REG(BPF_SUB, BPF_REG_1, BPF_REG_0),
 778         BPF_LDX_MEM(BPF_B, BPF_REG_0, BPF_REG_1, 0),
 779         BPF_MOV64_IMM(BPF_REG_0, 1),
 780         BPF_EXIT_INSN(),
 781         },
 782         .fixup_map_array_48b = { 3 },
 783         .result = REJECT,
 784         .errstr = "R1 tried to subtract pointer from scalar",
 785 },
 786 {
 787         "map access: value_ptr -= unknown scalar",
 788         .insns = {
 789         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 790         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 791         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 792         BPF_LD_MAP_FD(BPF_REG_1, 0),
 793         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 794         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 4),
 795         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 796         BPF_ALU64_IMM(BPF_AND, BPF_REG_1, 0xf),
 797         BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
 798         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 799         BPF_MOV64_IMM(BPF_REG_0, 1),
 800         BPF_EXIT_INSN(),
 801         },
 802         .fixup_map_array_48b = { 3 },
 803         .result = REJECT,
 804         .errstr = "R0 min value is negative",
 805 },
 806 {
 807         "map access: value_ptr -= unknown scalar, 2",
 808         .insns = {
 809         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 810         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 811         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 812         BPF_LD_MAP_FD(BPF_REG_1, 0),
 813         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 814         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 8),
 815         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 816         BPF_ALU64_IMM(BPF_AND, BPF_REG_1, 0xf),
 817         BPF_ALU64_IMM(BPF_OR, BPF_REG_1, 0x7),
 818         BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
 819         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 820         BPF_ALU64_IMM(BPF_AND, BPF_REG_1, 0x7),
 821         BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),
 822         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 823         BPF_MOV64_IMM(BPF_REG_0, 1),
 824         BPF_EXIT_INSN(),
 825         },
 826         .fixup_map_array_48b = { 3 },
 827         .result = ACCEPT,
 828         .result_unpriv = REJECT,
 829         .errstr_unpriv = "R0 pointer arithmetic of map value goes out of range",
 830         .retval = 1,
 831 },
 832 {
 833         "map access: value_ptr -= value_ptr",
 834         .insns = {
 835         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
 836         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
 837         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
 838         BPF_LD_MAP_FD(BPF_REG_1, 0),
 839         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
 840         BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2),
 841         BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_0),
 842         BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_0, 0),
 843         BPF_MOV64_IMM(BPF_REG_0, 1),
 844         BPF_EXIT_INSN(),
 845         },
 846         .fixup_map_array_48b = { 3 },
 847         .result = REJECT,
 848         .errstr = "R0 invalid mem access 'inv'",
 849         .errstr_unpriv = "R0 pointer -= pointer prohibited",
 850 },
 851 {
 852         "32bit pkt_ptr -= scalar",
 853         .insns = {
 854         BPF_LDX_MEM(BPF_W, BPF_REG_8, BPF_REG_1,
 855                     offsetof(struct __sk_buff, data_end)),
 856         BPF_LDX_MEM(BPF_W, BPF_REG_7, BPF_REG_1,
 857                     offsetof(struct __sk_buff, data)),
 858         BPF_MOV64_REG(BPF_REG_6, BPF_REG_7),
 859         BPF_ALU64_IMM(BPF_ADD, BPF_REG_6, 40),
 860         BPF_JMP_REG(BPF_JGT, BPF_REG_6, BPF_REG_8, 2),
 861         BPF_ALU32_REG(BPF_MOV, BPF_REG_4, BPF_REG_7),
 862         BPF_ALU32_REG(BPF_SUB, BPF_REG_6, BPF_REG_4),
 863         BPF_MOV64_IMM(BPF_REG_0, 0),
 864         BPF_EXIT_INSN(),
 865         },
 866         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 867         .result = ACCEPT,
 868         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 869 },
 870 {
 871         "32bit scalar -= pkt_ptr",
 872         .insns = {
 873         BPF_LDX_MEM(BPF_W, BPF_REG_8, BPF_REG_1,
 874                     offsetof(struct __sk_buff, data_end)),
 875         BPF_LDX_MEM(BPF_W, BPF_REG_7, BPF_REG_1,
 876                     offsetof(struct __sk_buff, data)),
 877         BPF_MOV64_REG(BPF_REG_6, BPF_REG_7),
 878         BPF_ALU64_IMM(BPF_ADD, BPF_REG_6, 40),
 879         BPF_JMP_REG(BPF_JGT, BPF_REG_6, BPF_REG_8, 2),
 880         BPF_ALU32_REG(BPF_MOV, BPF_REG_4, BPF_REG_6),
 881         BPF_ALU32_REG(BPF_SUB, BPF_REG_4, BPF_REG_7),
 882         BPF_MOV64_IMM(BPF_REG_0, 0),
 883         BPF_EXIT_INSN(),
 884         },
 885         .prog_type = BPF_PROG_TYPE_SCHED_CLS,
 886         .result = ACCEPT,
 887         .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
 888 },