tools/testing/selftests/bpf/progs/dynptr_fail.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2022 Facebook */
   3
   4 #include <errno.h>
   5 #include <string.h>
   6 #include <stdbool.h>
   7 #include <linux/bpf.h>
   8 #include <bpf/bpf_helpers.h>
   9 #include <bpf/bpf_tracing.h>
  10 #include <linux/if_ether.h>
  11 #include "bpf_misc.h"
  12 #include "bpf_kfuncs.h"
  13
  14 char _license[] SEC("license") = "GPL";
  15
  16 struct test_info {
  17         int x;
  18         struct bpf_dynptr ptr;
  19 };
  20
  21 struct {
  22         __uint(type, BPF_MAP_TYPE_ARRAY);
  23         __uint(max_entries, 1);
  24         __type(key, __u32);
  25         __type(value, struct bpf_dynptr);
  26 } array_map1 SEC(".maps");
  27
  28 struct {
  29         __uint(type, BPF_MAP_TYPE_ARRAY);
  30         __uint(max_entries, 1);
  31         __type(key, __u32);
  32         __type(value, struct test_info);
  33 } array_map2 SEC(".maps");
  34
  35 struct {
  36         __uint(type, BPF_MAP_TYPE_ARRAY);
  37         __uint(max_entries, 1);
  38         __type(key, __u32);
  39         __type(value, __u32);
  40 } array_map3 SEC(".maps");
  41
  42 struct {
  43         __uint(type, BPF_MAP_TYPE_ARRAY);
  44         __uint(max_entries, 1);
  45         __type(key, __u32);
  46         __type(value, __u64);
  47 } array_map4 SEC(".maps");
  48
  49 struct sample {
  50         int pid;
  51         long value;
  52         char comm[16];
  53 };
  54
  55 struct {
  56         __uint(type, BPF_MAP_TYPE_RINGBUF);
  57         __uint(max_entries, 4096);
  58 } ringbuf SEC(".maps");
  59
  60 int err, val;
  61
  62 static int get_map_val_dynptr(struct bpf_dynptr *ptr)
  63 {
  64         __u32 key = 0, *map_val;
  65
  66         bpf_map_update_elem(&array_map3, &key, &val, 0);
  67
  68         map_val = bpf_map_lookup_elem(&array_map3, &key);
  69         if (!map_val)
  70                 return -ENOENT;
  71
  72         bpf_dynptr_from_mem(map_val, sizeof(*map_val), 0, ptr);
  73
  74         return 0;
  75 }
  76
  77 /* Every bpf_ringbuf_reserve_dynptr call must have a corresponding
  78  * bpf_ringbuf_submit/discard_dynptr call
  79  */
  80 SEC("?raw_tp")
  81 __failure __msg("Unreleased reference id=2")
  82 int ringbuf_missing_release1(void *ctx)
  83 {
  84         struct bpf_dynptr ptr = {};
  85
  86         bpf_ringbuf_reserve_dynptr(&ringbuf, val, 0, &ptr);
  87
  88         /* missing a call to bpf_ringbuf_discard/submit_dynptr */
  89
  90         return 0;
  91 }
  92
  93 SEC("?raw_tp")
  94 __failure __msg("Unreleased reference id=4")
  95 int ringbuf_missing_release2(void *ctx)
  96 {
  97         struct bpf_dynptr ptr1, ptr2;
  98         struct sample *sample;
  99
 100         bpf_ringbuf_reserve_dynptr(&ringbuf, sizeof(*sample), 0, &ptr1);
 101         bpf_ringbuf_reserve_dynptr(&ringbuf, sizeof(*sample), 0, &ptr2);
 102
 103         sample = bpf_dynptr_data(&ptr1, 0, sizeof(*sample));
 104         if (!sample) {
 105                 bpf_ringbuf_discard_dynptr(&ptr1, 0);
 106                 bpf_ringbuf_discard_dynptr(&ptr2, 0);
 107                 return 0;
 108         }
 109
 110         bpf_ringbuf_submit_dynptr(&ptr1, 0);
 111
 112         /* missing a call to bpf_ringbuf_discard/submit_dynptr on ptr2 */
 113
 114         return 0;
 115 }
 116
 117 static int missing_release_callback_fn(__u32 index, void *data)
 118 {
 119         struct bpf_dynptr ptr;
 120
 121         bpf_ringbuf_reserve_dynptr(&ringbuf, val, 0, &ptr);
 122
 123         /* missing a call to bpf_ringbuf_discard/submit_dynptr */
 124
 125         return 0;
 126 }
 127
 128 /* Any dynptr initialized within a callback must have bpf_dynptr_put called */
 129 SEC("?raw_tp")
 130 __failure __msg("Unreleased reference id")
 131 int ringbuf_missing_release_callback(void *ctx)
 132 {
 133         bpf_loop(10, missing_release_callback_fn, NULL, 0);
 134         return 0;
 135 }
 136
 137 /* Can't call bpf_ringbuf_submit/discard_dynptr on a non-initialized dynptr */
 138 SEC("?raw_tp")
 139 __failure __msg("arg 1 is an unacquired reference")
 140 int ringbuf_release_uninit_dynptr(void *ctx)
 141 {
 142         struct bpf_dynptr ptr;
 143
 144         /* this should fail */
 145         bpf_ringbuf_submit_dynptr(&ptr, 0);
 146
 147         return 0;
 148 }
 149
 150 /* A dynptr can't be used after it has been invalidated */
 151 SEC("?raw_tp")
 152 __failure __msg("Expected an initialized dynptr as arg #2")
 153 int use_after_invalid(void *ctx)
 154 {
 155         struct bpf_dynptr ptr;
 156         char read_data[64];
 157
 158         bpf_ringbuf_reserve_dynptr(&ringbuf, sizeof(read_data), 0, &ptr);
 159
 160         bpf_dynptr_read(read_data, sizeof(read_data), &ptr, 0, 0);
 161
 162         bpf_ringbuf_submit_dynptr(&ptr, 0);
 163
 164         /* this should fail */
 165         bpf_dynptr_read(read_data, sizeof(read_data), &ptr, 0, 0);
 166
 167         return 0;
 168 }
 169
 170 /* Can't call non-dynptr ringbuf APIs on a dynptr ringbuf sample */
 171 SEC("?raw_tp")
 172 __failure __msg("type=mem expected=ringbuf_mem")
 173 int ringbuf_invalid_api(void *ctx)
 174 {
 175         struct bpf_dynptr ptr;
 176         struct sample *sample;
 177
 178         bpf_ringbuf_reserve_dynptr(&ringbuf, sizeof(*sample), 0, &ptr);
 179         sample = bpf_dynptr_data(&ptr, 0, sizeof(*sample));
 180         if (!sample)
 181                 goto done;
 182
 183         sample->pid = 123;
 184
 185         /* invalid API use. need to use dynptr API to submit/discard */
 186         bpf_ringbuf_submit(sample, 0);
 187
 188 done:
 189         bpf_ringbuf_discard_dynptr(&ptr, 0);
 190         return 0;
 191 }
 192
 193 /* Can't add a dynptr to a map */
 194 SEC("?raw_tp")
 195 __failure __msg("invalid read from stack")
 196 int add_dynptr_to_map1(void *ctx)
 197 {
 198         struct bpf_dynptr ptr;
 199         int key = 0;
 200
 201         bpf_ringbuf_reserve_dynptr(&ringbuf, val, 0, &ptr);
 202
 203         /* this should fail */
 204         bpf_map_update_elem(&array_map1, &key, &ptr, 0);
 205
 206         bpf_ringbuf_submit_dynptr(&ptr, 0);
 207
 208         return 0;
 209 }
 210
 211 /* Can't add a struct with an embedded dynptr to a map */
 212 SEC("?raw_tp")
 213 __failure __msg("invalid read from stack")
 214 int add_dynptr_to_map2(void *ctx)
 215 {
 216         struct test_info x;
 217         int key = 0;
 218
 219         bpf_ringbuf_reserve_dynptr(&ringbuf, val, 0, &x.ptr);
 220
 221         /* this should fail */
 222         bpf_map_update_elem(&array_map2, &key, &x, 0);
 223
 224         bpf_ringbuf_submit_dynptr(&x.ptr, 0);
 225
 226         return 0;
 227 }
 228
 229 /* A data slice can't be accessed out of bounds */
 230 SEC("?raw_tp")
 231 __failure __msg("value is outside of the allowed memory range")
 232 int data_slice_out_of_bounds_ringbuf(void *ctx)
 233 {
 234         struct bpf_dynptr ptr;
 235         void *data;
 236
 237         bpf_ringbuf_reserve_dynptr(&ringbuf, 8, 0, &ptr);
 238
 239         data  = bpf_dynptr_data(&ptr, 0, 8);
 240         if (!data)
 241                 goto done;
 242
 243         /* can't index out of bounds of the data slice */
 244         val = *((char *)data + 8);
 245
 246 done:
 247         bpf_ringbuf_submit_dynptr(&ptr, 0);
 248         return 0;
 249 }
 250
 251 /* A data slice can't be accessed out of bounds */
 252 SEC("?tc")
 253 __failure __msg("value is outside of the allowed memory range")
 254 int data_slice_out_of_bounds_skb(struct __sk_buff *skb)
 255 {
 256         struct bpf_dynptr ptr;
 257         struct ethhdr *hdr;
 258         char buffer[sizeof(*hdr)] = {};
 259
 260         bpf_dynptr_from_skb(skb, 0, &ptr);
 261
 262         hdr = bpf_dynptr_slice_rdwr(&ptr, 0, buffer, sizeof(buffer));
 263         if (!hdr)
 264                 return SK_DROP;
 265
 266         /* this should fail */
 267         *(__u8*)(hdr + 1) = 1;
 268
 269         return SK_PASS;
 270 }
 271
 272 SEC("?raw_tp")
 273 __failure __msg("value is outside of the allowed memory range")
 274 int data_slice_out_of_bounds_map_value(void *ctx)
 275 {
 276         __u32 map_val;
 277         struct bpf_dynptr ptr;
 278         void *data;
 279
 280         get_map_val_dynptr(&ptr);
 281
 282         data  = bpf_dynptr_data(&ptr, 0, sizeof(map_val));
 283         if (!data)
 284                 return 0;
 285
 286         /* can't index out of bounds of the data slice */
 287         val = *((char *)data + (sizeof(map_val) + 1));
 288
 289         return 0;
 290 }
 291
 292 /* A data slice can't be used after it has been released */
 293 SEC("?raw_tp")
 294 __failure __msg("invalid mem access 'scalar'")
 295 int data_slice_use_after_release1(void *ctx)
 296 {
 297         struct bpf_dynptr ptr;
 298         struct sample *sample;
 299
 300         bpf_ringbuf_reserve_dynptr(&ringbuf, sizeof(*sample), 0, &ptr);
 301         sample = bpf_dynptr_data(&ptr, 0, sizeof(*sample));
 302         if (!sample)
 303                 goto done;
 304
 305         sample->pid = 123;
 306
 307         bpf_ringbuf_submit_dynptr(&ptr, 0);
 308
 309         /* this should fail */
 310         val = sample->pid;
 311
 312         return 0;
 313
 314 done:
 315         bpf_ringbuf_discard_dynptr(&ptr, 0);
 316         return 0;
 317 }
 318
 319 /* A data slice can't be used after it has been released.
 320  *
 321  * This tests the case where the data slice tracks a dynptr (ptr2)
 322  * that is at a non-zero offset from the frame pointer (ptr1 is at fp,
 323  * ptr2 is at fp - 16).
 324  */
 325 SEC("?raw_tp")
 326 __failure __msg("invalid mem access 'scalar'")
 327 int data_slice_use_after_release2(void *ctx)
 328 {
 329         struct bpf_dynptr ptr1, ptr2;
 330         struct sample *sample;
 331
 332         bpf_ringbuf_reserve_dynptr(&ringbuf, 64, 0, &ptr1);
 333         bpf_ringbuf_reserve_dynptr(&ringbuf, sizeof(*sample), 0, &ptr2);
 334
 335         sample = bpf_dynptr_data(&ptr2, 0, sizeof(*sample));
 336         if (!sample)
 337                 goto done;
 338
 339         sample->pid = 23;
 340
 341         bpf_ringbuf_submit_dynptr(&ptr2, 0);
 342
 343         /* this should fail */
 344         sample->pid = 23;
 345
 346         bpf_ringbuf_submit_dynptr(&ptr1, 0);
 347
 348         return 0;
 349
 350 done:
 351         bpf_ringbuf_discard_dynptr(&ptr2, 0);
 352         bpf_ringbuf_discard_dynptr(&ptr1, 0);
 353         return 0;
 354 }
 355
 356 /* A data slice must be first checked for NULL */
 357 SEC("?raw_tp")
 358 __failure __msg("invalid mem access 'mem_or_null'")
 359 int data_slice_missing_null_check1(void *ctx)
 360 {
 361         struct bpf_dynptr ptr;
 362         void *data;
 363
 364         bpf_ringbuf_reserve_dynptr(&ringbuf, 8, 0, &ptr);
 365
 366         data  = bpf_dynptr_data(&ptr, 0, 8);
 367
 368         /* missing if (!data) check */
 369
 370         /* this should fail */
 371         *(__u8 *)data = 3;
 372
 373         bpf_ringbuf_submit_dynptr(&ptr, 0);
 374         return 0;
 375 }
 376
 377 /* A data slice can't be dereferenced if it wasn't checked for null */
 378 SEC("?raw_tp")
 379 __failure __msg("invalid mem access 'mem_or_null'")
 380 int data_slice_missing_null_check2(void *ctx)
 381 {
 382         struct bpf_dynptr ptr;
 383         __u64 *data1, *data2;
 384
 385         bpf_ringbuf_reserve_dynptr(&ringbuf, 16, 0, &ptr);
 386
 387         data1 = bpf_dynptr_data(&ptr, 0, 8);
 388         data2 = bpf_dynptr_data(&ptr, 0, 8);
 389         if (data1)
 390                 /* this should fail */
 391                 *data2 = 3;
 392
 393         bpf_ringbuf_discard_dynptr(&ptr, 0);
 394         return 0;
 395 }
 396
 397 /* Can't pass in a dynptr as an arg to a helper function that doesn't take in a
 398  * dynptr argument
 399  */
 400 SEC("?raw_tp")
 401 __failure __msg("invalid read from stack")
 402 int invalid_helper1(void *ctx)
 403 {
 404         struct bpf_dynptr ptr;
 405
 406         get_map_val_dynptr(&ptr);
 407
 408         /* this should fail */
 409         bpf_strncmp((const char *)&ptr, sizeof(ptr), "hello!");
 410
 411         return 0;
 412 }
 413
 414 /* A dynptr can't be passed into a helper function at a non-zero offset */
 415 SEC("?raw_tp")
 416 __failure __msg("cannot pass in dynptr at an offset=-8")
 417 int invalid_helper2(void *ctx)
 418 {
 419         struct bpf_dynptr ptr;
 420         char read_data[64];
 421
 422         get_map_val_dynptr(&ptr);
 423
 424         /* this should fail */
 425         bpf_dynptr_read(read_data, sizeof(read_data), (void *)&ptr + 8, 0, 0);
 426         return 0;
 427 }
 428
 429 /* A bpf_dynptr is invalidated if it's been written into */
 430 SEC("?raw_tp")
 431 __failure __msg("Expected an initialized dynptr as arg #0")
 432 int invalid_write1(void *ctx)
 433 {
 434         struct bpf_dynptr ptr;
 435         void *data;
 436         __u8 x = 0;
 437
 438         get_map_val_dynptr(&ptr);
 439
 440         memcpy(&ptr, &x, sizeof(x));
 441
 442         /* this should fail */
 443         data = bpf_dynptr_data(&ptr, 0, 1);
 444         __sink(data);
 445
 446         return 0;
 447 }
 448
 449 /*
 450  * A bpf_dynptr can't be used as a dynptr if it has been written into at a fixed
 451  * offset
 452  */
 453 SEC("?raw_tp")
 454 __failure __msg("cannot overwrite referenced dynptr")
 455 int invalid_write2(void *ctx)
 456 {
 457         struct bpf_dynptr ptr;
 458         char read_data[64];
 459         __u8 x = 0;
 460
 461         bpf_ringbuf_reserve_dynptr(&ringbuf, 64, 0, &ptr);
 462
 463         memcpy((void *)&ptr + 8, &x, sizeof(x));
 464
 465         /* this should fail */
 466         bpf_dynptr_read(read_data, sizeof(read_data), &ptr, 0, 0);
 467
 468         bpf_ringbuf_submit_dynptr(&ptr, 0);
 469
 470         return 0;
 471 }
 472
 473 /*
 474  * A bpf_dynptr can't be used as a dynptr if it has been written into at a
 475  * non-const offset
 476  */
 477 SEC("?raw_tp")
 478 __failure __msg("cannot overwrite referenced dynptr")
 479 int invalid_write3(void *ctx)
 480 {
 481         struct bpf_dynptr ptr;
 482         char stack_buf[16];
 483         unsigned long len;
 484         __u8 x = 0;
 485
 486         bpf_ringbuf_reserve_dynptr(&ringbuf, 8, 0, &ptr);
 487
 488         memcpy(stack_buf, &val, sizeof(val));
 489         len = stack_buf[0] & 0xf;
 490
 491         memcpy((void *)&ptr + len, &x, sizeof(x));
 492
 493         /* this should fail */
 494         bpf_ringbuf_submit_dynptr(&ptr, 0);
 495
 496         return 0;
 497 }
 498
 499 static int invalid_write4_callback(__u32 index, void *data)
 500 {
 501         *(__u32 *)data = 123;
 502
 503         return 0;
 504 }
 505
 506 /* If the dynptr is written into in a callback function, it should
 507  * be invalidated as a dynptr
 508  */
 509 SEC("?raw_tp")
 510 __failure __msg("cannot overwrite referenced dynptr")
 511 int invalid_write4(void *ctx)
 512 {
 513         struct bpf_dynptr ptr;
 514
 515         bpf_ringbuf_reserve_dynptr(&ringbuf, 64, 0, &ptr);
 516
 517         bpf_loop(10, invalid_write4_callback, &ptr, 0);
 518
 519         /* this should fail */
 520         bpf_ringbuf_submit_dynptr(&ptr, 0);
 521
 522         return 0;
 523 }
 524
 525 /* A globally-defined bpf_dynptr can't be used (it must reside as a stack frame) */
 526 struct bpf_dynptr global_dynptr;
 527
 528 SEC("?raw_tp")
 529 __failure __msg("type=map_value expected=fp")
 530 int global(void *ctx)
 531 {
 532         /* this should fail */
 533         bpf_ringbuf_reserve_dynptr(&ringbuf, 16, 0, &global_dynptr);
 534
 535         bpf_ringbuf_discard_dynptr(&global_dynptr, 0);
 536
 537         return 0;
 538 }
 539
 540 /* A direct read should fail */
 541 SEC("?raw_tp")
 542 __failure __msg("invalid read from stack")
 543 int invalid_read1(void *ctx)
 544 {
 545         struct bpf_dynptr ptr;
 546
 547         bpf_ringbuf_reserve_dynptr(&ringbuf, 64, 0, &ptr);
 548
 549         /* this should fail */
 550         val = *(int *)&ptr;
 551
 552         bpf_ringbuf_discard_dynptr(&ptr, 0);
 553
 554         return 0;
 555 }
 556
 557 /* A direct read at an offset should fail */
 558 SEC("?raw_tp")
 559 __failure __msg("cannot pass in dynptr at an offset")
 560 int invalid_read2(void *ctx)
 561 {
 562         struct bpf_dynptr ptr;
 563         char read_data[64];
 564
 565         get_map_val_dynptr(&ptr);
 566
 567         /* this should fail */
 568         bpf_dynptr_read(read_data, sizeof(read_data), (void *)&ptr + 1, 0, 0);
 569
 570         return 0;
 571 }
 572
 573 /* A direct read at an offset into the lower stack slot should fail */
 574 SEC("?raw_tp")
 575 __failure __msg("invalid read from stack")
 576 int invalid_read3(void *ctx)
 577 {
 578         struct bpf_dynptr ptr1, ptr2;
 579
 580         bpf_ringbuf_reserve_dynptr(&ringbuf, 16, 0, &ptr1);
 581         bpf_ringbuf_reserve_dynptr(&ringbuf, 16, 0, &ptr2);
 582
 583         /* this should fail */
 584         memcpy(&val, (void *)&ptr1 + 8, sizeof(val));
 585
 586         bpf_ringbuf_discard_dynptr(&ptr1, 0);
 587         bpf_ringbuf_discard_dynptr(&ptr2, 0);
 588
 589         return 0;
 590 }
 591
 592 static int invalid_read4_callback(__u32 index, void *data)
 593 {
 594         /* this should fail */
 595         val = *(__u32 *)data;
 596
 597         return 0;
 598 }
 599
 600 /* A direct read within a callback function should fail */
 601 SEC("?raw_tp")
 602 __failure __msg("invalid read from stack")
 603 int invalid_read4(void *ctx)
 604 {
 605         struct bpf_dynptr ptr;
 606
 607         bpf_ringbuf_reserve_dynptr(&ringbuf, 64, 0, &ptr);
 608
 609         bpf_loop(10, invalid_read4_callback, &ptr, 0);
 610
 611         bpf_ringbuf_submit_dynptr(&ptr, 0);
 612
 613         return 0;
 614 }
 615
 616 /* Initializing a dynptr on an offset should fail */
 617 SEC("?raw_tp")
 618 __failure __msg("cannot pass in dynptr at an offset=0")
 619 int invalid_offset(void *ctx)
 620 {
 621         struct bpf_dynptr ptr;
 622
 623         /* this should fail */
 624         bpf_ringbuf_reserve_dynptr(&ringbuf, 64, 0, &ptr + 1);
 625
 626         bpf_ringbuf_discard_dynptr(&ptr, 0);
 627
 628         return 0;
 629 }
 630
 631 /* Can't release a dynptr twice */
 632 SEC("?raw_tp")
 633 __failure __msg("arg 1 is an unacquired reference")
 634 int release_twice(void *ctx)
 635 {
 636         struct bpf_dynptr ptr;
 637
 638         bpf_ringbuf_reserve_dynptr(&ringbuf, 16, 0, &ptr);
 639
 640         bpf_ringbuf_discard_dynptr(&ptr, 0);
 641
 642         /* this second release should fail */
 643         bpf_ringbuf_discard_dynptr(&ptr, 0);
 644
 645         return 0;
 646 }
 647
 648 static int release_twice_callback_fn(__u32 index, void *data)
 649 {
 650         /* this should fail */
 651         bpf_ringbuf_discard_dynptr(data, 0);
 652
 653         return 0;
 654 }
 655
 656 /* Test that releasing a dynptr twice, where one of the releases happens
 657  * within a callback function, fails
 658  */
 659 SEC("?raw_tp")
 660 __failure __msg("arg 1 is an unacquired reference")
 661 int release_twice_callback(void *ctx)
 662 {
 663         struct bpf_dynptr ptr;
 664
 665         bpf_ringbuf_reserve_dynptr(&ringbuf, 32, 0, &ptr);
 666
 667         bpf_ringbuf_discard_dynptr(&ptr, 0);
 668
 669         bpf_loop(10, release_twice_callback_fn, &ptr, 0);
 670
 671         return 0;
 672 }
 673
 674 /* Reject unsupported local mem types for dynptr_from_mem API */
 675 SEC("?raw_tp")
 676 __failure __msg("Unsupported reg type fp for bpf_dynptr_from_mem data")
 677 int dynptr_from_mem_invalid_api(void *ctx)
 678 {
 679         struct bpf_dynptr ptr;
 680         int x = 0;
 681
 682         /* this should fail */
 683         bpf_dynptr_from_mem(&x, sizeof(x), 0, &ptr);
 684
 685         return 0;
 686 }
 687
 688 SEC("?tc")
 689 __failure __msg("cannot overwrite referenced dynptr") __log_level(2)
 690 int dynptr_pruning_overwrite(struct __sk_buff *ctx)
 691 {
 692         asm volatile (
 693                 "r9 = 0xeB9F;                           \
 694                  r6 = %[ringbuf] ll;                    \
 695                  r1 = r6;                               \
 696                  r2 = 8;                                \
 697                  r3 = 0;                                \
 698                  r4 = r10;                              \
 699                  r4 += -16;                             \
 700                  call %[bpf_ringbuf_reserve_dynptr];    \
 701                  if r0 == 0 goto pjmp1;                 \
 702                  goto pjmp2;                            \
 703         pjmp1:                                          \
 704                  *(u64 *)(r10 - 16) = r9;               \
 705         pjmp2:                                          \
 706                  r1 = r10;                              \
 707                  r1 += -16;                             \
 708                  r2 = 0;                                \
 709                  call %[bpf_ringbuf_discard_dynptr];    "
 710                 :
 711                 : __imm(bpf_ringbuf_reserve_dynptr),
 712                   __imm(bpf_ringbuf_discard_dynptr),
 713                   __imm_addr(ringbuf)
 714                 : __clobber_all
 715         );
 716         return 0;
 717 }
 718
 719 SEC("?tc")
 720 __success __msg("12: safe") __log_level(2)
 721 int dynptr_pruning_stacksafe(struct __sk_buff *ctx)
 722 {
 723         asm volatile (
 724                 "r9 = 0xeB9F;                           \
 725                  r6 = %[ringbuf] ll;                    \
 726                  r1 = r6;                               \
 727                  r2 = 8;                                \
 728                  r3 = 0;                                \
 729                  r4 = r10;                              \
 730                  r4 += -16;                             \
 731                  call %[bpf_ringbuf_reserve_dynptr];    \
 732                  if r0 == 0 goto stjmp1;                \
 733                  goto stjmp2;                           \
 734         stjmp1:                                         \
 735                  r9 = r9;                               \
 736         stjmp2:                                         \
 737                  r1 = r10;                              \
 738                  r1 += -16;                             \
 739                  r2 = 0;                                \
 740                  call %[bpf_ringbuf_discard_dynptr];    "
 741                 :
 742                 : __imm(bpf_ringbuf_reserve_dynptr),
 743                   __imm(bpf_ringbuf_discard_dynptr),
 744                   __imm_addr(ringbuf)
 745                 : __clobber_all
 746         );
 747         return 0;
 748 }
 749
 750 SEC("?tc")
 751 __failure __msg("cannot overwrite referenced dynptr") __log_level(2)
 752 int dynptr_pruning_type_confusion(struct __sk_buff *ctx)
 753 {
 754         asm volatile (
 755                 "r6 = %[array_map4] ll;                 \
 756                  r7 = %[ringbuf] ll;                    \
 757                  r1 = r6;                               \
 758                  r2 = r10;                              \
 759                  r2 += -8;                              \
 760                  r9 = 0;                                \
 761                  *(u64 *)(r2 + 0) = r9;                 \
 762                  r3 = r10;                              \
 763                  r3 += -24;                             \
 764                  r9 = 0xeB9FeB9F;                       \
 765                  *(u64 *)(r10 - 16) = r9;               \
 766                  *(u64 *)(r10 - 24) = r9;               \
 767                  r9 = 0;                                \
 768                  r4 = 0;                                \
 769                  r8 = r2;                               \
 770                  call %[bpf_map_update_elem];           \
 771                  r1 = r6;                               \
 772                  r2 = r8;                               \
 773                  call %[bpf_map_lookup_elem];           \
 774                  if r0 != 0 goto tjmp1;                 \
 775                  exit;                                  \
 776         tjmp1:                                          \
 777                  r8 = r0;                               \
 778                  r1 = r7;                               \
 779                  r2 = 8;                                \
 780                  r3 = 0;                                \
 781                  r4 = r10;                              \
 782                  r4 += -16;                             \
 783                  r0 = *(u64 *)(r0 + 0);                 \
 784                  call %[bpf_ringbuf_reserve_dynptr];    \
 785                  if r0 == 0 goto tjmp2;                 \
 786                  r8 = r8;                               \
 787                  r8 = r8;                               \
 788                  r8 = r8;                               \
 789                  r8 = r8;                               \
 790                  r8 = r8;                               \
 791                  r8 = r8;                               \
 792                  r8 = r8;                               \
 793                  goto tjmp3;                            \
 794         tjmp2:                                          \
 795                  *(u64 *)(r10 - 8) = r9;                \
 796                  *(u64 *)(r10 - 16) = r9;               \
 797                  r1 = r8;                               \
 798                  r1 += 8;                               \
 799                  r2 = 0;                                \
 800                  r3 = 0;                                \
 801                  r4 = r10;                              \
 802                  r4 += -16;                             \
 803                  call %[bpf_dynptr_from_mem];           \
 804         tjmp3:                                          \
 805                  r1 = r10;                              \
 806                  r1 += -16;                             \
 807                  r2 = 0;                                \
 808                  call %[bpf_ringbuf_discard_dynptr];    "
 809                 :
 810                 : __imm(bpf_map_update_elem),
 811                   __imm(bpf_map_lookup_elem),
 812                   __imm(bpf_ringbuf_reserve_dynptr),
 813                   __imm(bpf_dynptr_from_mem),
 814                   __imm(bpf_ringbuf_discard_dynptr),
 815                   __imm_addr(array_map4),
 816                   __imm_addr(ringbuf)
 817                 : __clobber_all
 818         );
 819         return 0;
 820 }
 821
 822 SEC("?tc")
 823 __failure __msg("dynptr has to be at a constant offset") __log_level(2)
 824 int dynptr_var_off_overwrite(struct __sk_buff *ctx)
 825 {
 826         asm volatile (
 827                 "r9 = 16;                               \
 828                  *(u32 *)(r10 - 4) = r9;                \
 829                  r8 = *(u32 *)(r10 - 4);                \
 830                  if r8 >= 0 goto vjmp1;                 \
 831                  r0 = 1;                                \
 832                  exit;                                  \
 833         vjmp1:                                          \
 834                  if r8 <= 16 goto vjmp2;                \
 835                  r0 = 1;                                \
 836                  exit;                                  \
 837         vjmp2:                                          \
 838                  r8 &= 16;                              \
 839                  r1 = %[ringbuf] ll;                    \
 840                  r2 = 8;                                \
 841                  r3 = 0;                                \
 842                  r4 = r10;                              \
 843                  r4 += -32;                             \
 844                  r4 += r8;                              \
 845                  call %[bpf_ringbuf_reserve_dynptr];    \
 846                  r9 = 0xeB9F;                           \
 847                  *(u64 *)(r10 - 16) = r9;               \
 848                  r1 = r10;                              \
 849                  r1 += -32;                             \
 850                  r1 += r8;                              \
 851                  r2 = 0;                                \
 852                  call %[bpf_ringbuf_discard_dynptr];    "
 853                 :
 854                 : __imm(bpf_ringbuf_reserve_dynptr),
 855                   __imm(bpf_ringbuf_discard_dynptr),
 856                   __imm_addr(ringbuf)
 857                 : __clobber_all
 858         );
 859         return 0;
 860 }
 861
 862 SEC("?tc")
 863 __failure __msg("cannot overwrite referenced dynptr") __log_level(2)
 864 int dynptr_partial_slot_invalidate(struct __sk_buff *ctx)
 865 {
 866         asm volatile (
 867                 "r6 = %[ringbuf] ll;                    \
 868                  r7 = %[array_map4] ll;                 \
 869                  r1 = r7;                               \
 870                  r2 = r10;                              \
 871                  r2 += -8;                              \
 872                  r9 = 0;                                \
 873                  *(u64 *)(r2 + 0) = r9;                 \
 874                  r3 = r2;                               \
 875                  r4 = 0;                                \
 876                  r8 = r2;                               \
 877                  call %[bpf_map_update_elem];           \
 878                  r1 = r7;                               \
 879                  r2 = r8;                               \
 880                  call %[bpf_map_lookup_elem];           \
 881                  if r0 != 0 goto sjmp1;                 \
 882                  exit;                                  \
 883         sjmp1:                                          \
 884                  r7 = r0;                               \
 885                  r1 = r6;                               \
 886                  r2 = 8;                                \
 887                  r3 = 0;                                \
 888                  r4 = r10;                              \
 889                  r4 += -24;                             \
 890                  call %[bpf_ringbuf_reserve_dynptr];    \
 891                  *(u64 *)(r10 - 16) = r9;               \
 892                  r1 = r7;                               \
 893                  r2 = 8;                                \
 894                  r3 = 0;                                \
 895                  r4 = r10;                              \
 896                  r4 += -16;                             \
 897                  call %[bpf_dynptr_from_mem];           \
 898                  r1 = r10;                              \
 899                  r1 += -512;                            \
 900                  r2 = 488;                              \
 901                  r3 = r10;                              \
 902                  r3 += -24;                             \
 903                  r4 = 0;                                \
 904                  r5 = 0;                                \
 905                  call %[bpf_dynptr_read];               \
 906                  r8 = 1;                                \
 907                  if r0 != 0 goto sjmp2;                 \
 908                  r8 = 0;                                \
 909         sjmp2:                                          \
 910                  r1 = r10;                              \
 911                  r1 += -24;                             \
 912                  r2 = 0;                                \
 913                  call %[bpf_ringbuf_discard_dynptr];    "
 914                 :
 915                 : __imm(bpf_map_update_elem),
 916                   __imm(bpf_map_lookup_elem),
 917                   __imm(bpf_ringbuf_reserve_dynptr),
 918                   __imm(bpf_ringbuf_discard_dynptr),
 919                   __imm(bpf_dynptr_from_mem),
 920                   __imm(bpf_dynptr_read),
 921                   __imm_addr(ringbuf),
 922                   __imm_addr(array_map4)
 923                 : __clobber_all
 924         );
 925         return 0;
 926 }
 927
 928 /* Test that it is allowed to overwrite unreferenced dynptr. */
 929 SEC("?raw_tp")
 930 __success
 931 int dynptr_overwrite_unref(void *ctx)
 932 {
 933         struct bpf_dynptr ptr;
 934
 935         if (get_map_val_dynptr(&ptr))
 936                 return 0;
 937         if (get_map_val_dynptr(&ptr))
 938                 return 0;
 939         if (get_map_val_dynptr(&ptr))
 940                 return 0;
 941
 942         return 0;
 943 }
 944
 945 /* Test that slices are invalidated on reinitializing a dynptr. */
 946 SEC("?raw_tp")
 947 __failure __msg("invalid mem access 'scalar'")
 948 int dynptr_invalidate_slice_reinit(void *ctx)
 949 {
 950         struct bpf_dynptr ptr;
 951         __u8 *p;
 952
 953         if (get_map_val_dynptr(&ptr))
 954                 return 0;
 955         p = bpf_dynptr_data(&ptr, 0, 1);
 956         if (!p)
 957                 return 0;
 958         if (get_map_val_dynptr(&ptr))
 959                 return 0;
 960         /* this should fail */
 961         return *p;
 962 }
 963
 964 /* Invalidation of dynptr slices on destruction of dynptr should not miss
 965  * mem_or_null pointers.
 966  */
 967 SEC("?raw_tp")
 968 __failure __msg("R{{[0-9]+}} type=scalar expected=percpu_ptr_")
 969 int dynptr_invalidate_slice_or_null(void *ctx)
 970 {
 971         struct bpf_dynptr ptr;
 972         __u8 *p;
 973
 974         if (get_map_val_dynptr(&ptr))
 975                 return 0;
 976
 977         p = bpf_dynptr_data(&ptr, 0, 1);
 978         *(__u8 *)&ptr = 0;
 979         /* this should fail */
 980         bpf_this_cpu_ptr(p);
 981         return 0;
 982 }
 983
 984 /* Destruction of dynptr should also any slices obtained from it */
 985 SEC("?raw_tp")
 986 __failure __msg("R{{[0-9]+}} invalid mem access 'scalar'")
 987 int dynptr_invalidate_slice_failure(void *ctx)
 988 {
 989         struct bpf_dynptr ptr1;
 990         struct bpf_dynptr ptr2;
 991         __u8 *p1, *p2;
 992
 993         if (get_map_val_dynptr(&ptr1))
 994                 return 0;
 995         if (get_map_val_dynptr(&ptr2))
 996                 return 0;
 997
 998         p1 = bpf_dynptr_data(&ptr1, 0, 1);
 999         if (!p1)
1000                 return 0;
1001         p2 = bpf_dynptr_data(&ptr2, 0, 1);
1002         if (!p2)
1003                 return 0;
1004
1005         *(__u8 *)&ptr1 = 0;
1006         /* this should fail */
1007         return *p1;
1008 }
1009
1010 /* Invalidation of slices should be scoped and should not prevent dereferencing
1011  * slices of another dynptr after destroying unrelated dynptr
1012  */
1013 SEC("?raw_tp")
1014 __success
1015 int dynptr_invalidate_slice_success(void *ctx)
1016 {
1017         struct bpf_dynptr ptr1;
1018         struct bpf_dynptr ptr2;
1019         __u8 *p1, *p2;
1020
1021         if (get_map_val_dynptr(&ptr1))
1022                 return 1;
1023         if (get_map_val_dynptr(&ptr2))
1024                 return 1;
1025
1026         p1 = bpf_dynptr_data(&ptr1, 0, 1);
1027         if (!p1)
1028                 return 1;
1029         p2 = bpf_dynptr_data(&ptr2, 0, 1);
1030         if (!p2)
1031                 return 1;
1032
1033         *(__u8 *)&ptr1 = 0;
1034         return *p2;
1035 }
1036
1037 /* Overwriting referenced dynptr should be rejected */
1038 SEC("?raw_tp")
1039 __failure __msg("cannot overwrite referenced dynptr")
1040 int dynptr_overwrite_ref(void *ctx)
1041 {
1042         struct bpf_dynptr ptr;
1043
1044         bpf_ringbuf_reserve_dynptr(&ringbuf, 64, 0, &ptr);
1045         /* this should fail */
1046         if (get_map_val_dynptr(&ptr))
1047                 bpf_ringbuf_discard_dynptr(&ptr, 0);
1048         return 0;
1049 }
1050
1051 /* Reject writes to dynptr slot from bpf_dynptr_read */
1052 SEC("?raw_tp")
1053 __failure __msg("potential write to dynptr at off=-16")
1054 int dynptr_read_into_slot(void *ctx)
1055 {
1056         union {
1057                 struct {
1058                         char _pad[48];
1059                         struct bpf_dynptr ptr;
1060                 };
1061                 char buf[64];
1062         } data;
1063
1064         bpf_ringbuf_reserve_dynptr(&ringbuf, 64, 0, &data.ptr);
1065         /* this should fail */
1066         bpf_dynptr_read(data.buf, sizeof(data.buf), &data.ptr, 0, 0);
1067
1068         return 0;
1069 }
1070
1071 /* bpf_dynptr_slice()s are read-only and cannot be written to */
1072 SEC("?tc")
1073 __failure __msg("R{{[0-9]+}} cannot write into rdonly_mem")
1074 int skb_invalid_slice_write(struct __sk_buff *skb)
1075 {
1076         struct bpf_dynptr ptr;
1077         struct ethhdr *hdr;
1078         char buffer[sizeof(*hdr)] = {};
1079
1080         bpf_dynptr_from_skb(skb, 0, &ptr);
1081
1082         hdr = bpf_dynptr_slice(&ptr, 0, buffer, sizeof(buffer));
1083         if (!hdr)
1084                 return SK_DROP;
1085
1086         /* this should fail */
1087         hdr->h_proto = 1;
1088
1089         return SK_PASS;
1090 }
1091
1092 /* The read-only data slice is invalidated whenever a helper changes packet data */
1093 SEC("?tc")
1094 __failure __msg("invalid mem access 'scalar'")
1095 int skb_invalid_data_slice1(struct __sk_buff *skb)
1096 {
1097         struct bpf_dynptr ptr;
1098         struct ethhdr *hdr;
1099         char buffer[sizeof(*hdr)] = {};
1100
1101         bpf_dynptr_from_skb(skb, 0, &ptr);
1102
1103         hdr = bpf_dynptr_slice(&ptr, 0, buffer, sizeof(buffer));
1104         if (!hdr)
1105                 return SK_DROP;
1106
1107         val = hdr->h_proto;
1108
1109         if (bpf_skb_pull_data(skb, skb->len))
1110                 return SK_DROP;
1111
1112         /* this should fail */
1113         val = hdr->h_proto;
1114
1115         return SK_PASS;
1116 }
1117
1118 /* The read-write data slice is invalidated whenever a helper changes packet data */
1119 SEC("?tc")
1120 __failure __msg("invalid mem access 'scalar'")
1121 int skb_invalid_data_slice2(struct __sk_buff *skb)
1122 {
1123         struct bpf_dynptr ptr;
1124         struct ethhdr *hdr;
1125         char buffer[sizeof(*hdr)] = {};
1126
1127         bpf_dynptr_from_skb(skb, 0, &ptr);
1128
1129         hdr = bpf_dynptr_slice_rdwr(&ptr, 0, buffer, sizeof(buffer));
1130         if (!hdr)
1131                 return SK_DROP;
1132
1133         hdr->h_proto = 123;
1134
1135         if (bpf_skb_pull_data(skb, skb->len))
1136                 return SK_DROP;
1137
1138         /* this should fail */
1139         hdr->h_proto = 1;
1140
1141         return SK_PASS;
1142 }
1143
1144 /* The read-only data slice is invalidated whenever bpf_dynptr_write() is called */
1145 SEC("?tc")
1146 __failure __msg("invalid mem access 'scalar'")
1147 int skb_invalid_data_slice3(struct __sk_buff *skb)
1148 {
1149         char write_data[64] = "hello there, world!!";
1150         struct bpf_dynptr ptr;
1151         struct ethhdr *hdr;
1152         char buffer[sizeof(*hdr)] = {};
1153
1154         bpf_dynptr_from_skb(skb, 0, &ptr);
1155
1156         hdr = bpf_dynptr_slice(&ptr, 0, buffer, sizeof(buffer));
1157         if (!hdr)
1158                 return SK_DROP;
1159
1160         val = hdr->h_proto;
1161
1162         bpf_dynptr_write(&ptr, 0, write_data, sizeof(write_data), 0);
1163
1164         /* this should fail */
1165         val = hdr->h_proto;
1166
1167         return SK_PASS;
1168 }
1169
1170 /* The read-write data slice is invalidated whenever bpf_dynptr_write() is called */
1171 SEC("?tc")
1172 __failure __msg("invalid mem access 'scalar'")
1173 int skb_invalid_data_slice4(struct __sk_buff *skb)
1174 {
1175         char write_data[64] = "hello there, world!!";
1176         struct bpf_dynptr ptr;
1177         struct ethhdr *hdr;
1178         char buffer[sizeof(*hdr)] = {};
1179
1180         bpf_dynptr_from_skb(skb, 0, &ptr);
1181         hdr = bpf_dynptr_slice_rdwr(&ptr, 0, buffer, sizeof(buffer));
1182         if (!hdr)
1183                 return SK_DROP;
1184
1185         hdr->h_proto = 123;
1186
1187         bpf_dynptr_write(&ptr, 0, write_data, sizeof(write_data), 0);
1188
1189         /* this should fail */
1190         hdr->h_proto = 1;
1191
1192         return SK_PASS;
1193 }
1194
1195 /* The read-only data slice is invalidated whenever a helper changes packet data */
1196 SEC("?xdp")
1197 __failure __msg("invalid mem access 'scalar'")
1198 int xdp_invalid_data_slice1(struct xdp_md *xdp)
1199 {
1200         struct bpf_dynptr ptr;
1201         struct ethhdr *hdr;
1202         char buffer[sizeof(*hdr)] = {};
1203
1204         bpf_dynptr_from_xdp(xdp, 0, &ptr);
1205         hdr = bpf_dynptr_slice(&ptr, 0, buffer, sizeof(buffer));
1206         if (!hdr)
1207                 return SK_DROP;
1208
1209         val = hdr->h_proto;
1210
1211         if (bpf_xdp_adjust_head(xdp, 0 - (int)sizeof(*hdr)))
1212                 return XDP_DROP;
1213
1214         /* this should fail */
1215         val = hdr->h_proto;
1216
1217         return XDP_PASS;
1218 }
1219
1220 /* The read-write data slice is invalidated whenever a helper changes packet data */
1221 SEC("?xdp")
1222 __failure __msg("invalid mem access 'scalar'")
1223 int xdp_invalid_data_slice2(struct xdp_md *xdp)
1224 {
1225         struct bpf_dynptr ptr;
1226         struct ethhdr *hdr;
1227         char buffer[sizeof(*hdr)] = {};
1228
1229         bpf_dynptr_from_xdp(xdp, 0, &ptr);
1230         hdr = bpf_dynptr_slice_rdwr(&ptr, 0, buffer, sizeof(buffer));
1231         if (!hdr)
1232                 return SK_DROP;
1233
1234         hdr->h_proto = 9;
1235
1236         if (bpf_xdp_adjust_head(xdp, 0 - (int)sizeof(*hdr)))
1237                 return XDP_DROP;
1238
1239         /* this should fail */
1240         hdr->h_proto = 1;
1241
1242         return XDP_PASS;
1243 }
1244
1245 /* Only supported prog type can create skb-type dynptrs */
1246 SEC("?raw_tp")
1247 __failure __msg("calling kernel function bpf_dynptr_from_skb is not allowed")
1248 int skb_invalid_ctx(void *ctx)
1249 {
1250         struct bpf_dynptr ptr;
1251
1252         /* this should fail */
1253         bpf_dynptr_from_skb(ctx, 0, &ptr);
1254
1255         return 0;
1256 }
1257
1258 SEC("fentry/skb_tx_error")
1259 __failure __msg("must be referenced or trusted")
1260 int BPF_PROG(skb_invalid_ctx_fentry, void *skb)
1261 {
1262         struct bpf_dynptr ptr;
1263
1264         /* this should fail */
1265         bpf_dynptr_from_skb(skb, 0, &ptr);
1266
1267         return 0;
1268 }
1269
1270 SEC("fexit/skb_tx_error")
1271 __failure __msg("must be referenced or trusted")
1272 int BPF_PROG(skb_invalid_ctx_fexit, void *skb)
1273 {
1274         struct bpf_dynptr ptr;
1275
1276         /* this should fail */
1277         bpf_dynptr_from_skb(skb, 0, &ptr);
1278
1279         return 0;
1280 }
1281
1282 /* Reject writes to dynptr slot for uninit arg */
1283 SEC("?raw_tp")
1284 __failure __msg("potential write to dynptr at off=-16")
1285 int uninit_write_into_slot(void *ctx)
1286 {
1287         struct {
1288                 char buf[64];
1289                 struct bpf_dynptr ptr;
1290         } data;
1291
1292         bpf_ringbuf_reserve_dynptr(&ringbuf, 80, 0, &data.ptr);
1293         /* this should fail */
1294         bpf_get_current_comm(data.buf, 80);
1295
1296         return 0;
1297 }
1298
1299 /* Only supported prog type can create xdp-type dynptrs */
1300 SEC("?raw_tp")
1301 __failure __msg("calling kernel function bpf_dynptr_from_xdp is not allowed")
1302 int xdp_invalid_ctx(void *ctx)
1303 {
1304         struct bpf_dynptr ptr;
1305
1306         /* this should fail */
1307         bpf_dynptr_from_xdp(ctx, 0, &ptr);
1308
1309         return 0;
1310 }
1311
1312 __u32 hdr_size = sizeof(struct ethhdr);
1313 /* Can't pass in variable-sized len to bpf_dynptr_slice */
1314 SEC("?tc")
1315 __failure __msg("unbounded memory access")
1316 int dynptr_slice_var_len1(struct __sk_buff *skb)
1317 {
1318         struct bpf_dynptr ptr;
1319         struct ethhdr *hdr;
1320         char buffer[sizeof(*hdr)] = {};
1321
1322         bpf_dynptr_from_skb(skb, 0, &ptr);
1323
1324         /* this should fail */
1325         hdr = bpf_dynptr_slice(&ptr, 0, buffer, hdr_size);
1326         if (!hdr)
1327                 return SK_DROP;
1328
1329         return SK_PASS;
1330 }
1331
1332 /* Can't pass in variable-sized len to bpf_dynptr_slice */
1333 SEC("?tc")
1334 __failure __msg("must be a known constant")
1335 int dynptr_slice_var_len2(struct __sk_buff *skb)
1336 {
1337         char buffer[sizeof(struct ethhdr)] = {};
1338         struct bpf_dynptr ptr;
1339         struct ethhdr *hdr;
1340
1341         bpf_dynptr_from_skb(skb, 0, &ptr);
1342
1343         if (hdr_size <= sizeof(buffer)) {
1344                 /* this should fail */
1345                 hdr = bpf_dynptr_slice_rdwr(&ptr, 0, buffer, hdr_size);
1346                 if (!hdr)
1347                         return SK_DROP;
1348                 hdr->h_proto = 12;
1349         }
1350
1351         return SK_PASS;
1352 }
1353
1354 static int callback(__u32 index, void *data)
1355 {
1356         *(__u32 *)data = 123;
1357
1358         return 0;
1359 }
1360
1361 /* If the dynptr is written into in a callback function, its data
1362  * slices should be invalidated as well.
1363  */
1364 SEC("?raw_tp")
1365 __failure __msg("invalid mem access 'scalar'")
1366 int invalid_data_slices(void *ctx)
1367 {
1368         struct bpf_dynptr ptr;
1369         __u32 *slice;
1370
1371         if (get_map_val_dynptr(&ptr))
1372                 return 0;
1373
1374         slice = bpf_dynptr_data(&ptr, 0, sizeof(__u32));
1375         if (!slice)
1376                 return 0;
1377
1378         bpf_loop(10, callback, &ptr, 0);
1379
1380         /* this should fail */
1381         *slice = 1;
1382
1383         return 0;
1384 }
1385
1386 /* Program types that don't allow writes to packet data should fail if
1387  * bpf_dynptr_slice_rdwr is called
1388  */
1389 SEC("cgroup_skb/ingress")
1390 __failure __msg("the prog does not allow writes to packet data")
1391 int invalid_slice_rdwr_rdonly(struct __sk_buff *skb)
1392 {
1393         char buffer[sizeof(struct ethhdr)] = {};
1394         struct bpf_dynptr ptr;
1395         struct ethhdr *hdr;
1396
1397         bpf_dynptr_from_skb(skb, 0, &ptr);
1398
1399         /* this should fail since cgroup_skb doesn't allow
1400          * changing packet data
1401          */
1402         hdr = bpf_dynptr_slice_rdwr(&ptr, 0, buffer, sizeof(buffer));
1403         __sink(hdr);
1404
1405         return 0;
1406 }
1407
1408 /* bpf_dynptr_adjust can only be called on initialized dynptrs */
1409 SEC("?raw_tp")
1410 __failure __msg("Expected an initialized dynptr as arg #0")
1411 int dynptr_adjust_invalid(void *ctx)
1412 {
1413         struct bpf_dynptr ptr = {};
1414
1415         /* this should fail */
1416         bpf_dynptr_adjust(&ptr, 1, 2);
1417
1418         return 0;
1419 }
1420
1421 /* bpf_dynptr_is_null can only be called on initialized dynptrs */
1422 SEC("?raw_tp")
1423 __failure __msg("Expected an initialized dynptr as arg #0")
1424 int dynptr_is_null_invalid(void *ctx)
1425 {
1426         struct bpf_dynptr ptr = {};
1427
1428         /* this should fail */
1429         bpf_dynptr_is_null(&ptr);
1430
1431         return 0;
1432 }
1433
1434 /* bpf_dynptr_is_rdonly can only be called on initialized dynptrs */
1435 SEC("?raw_tp")
1436 __failure __msg("Expected an initialized dynptr as arg #0")
1437 int dynptr_is_rdonly_invalid(void *ctx)
1438 {
1439         struct bpf_dynptr ptr = {};
1440
1441         /* this should fail */
1442         bpf_dynptr_is_rdonly(&ptr);
1443
1444         return 0;
1445 }
1446
1447 /* bpf_dynptr_size can only be called on initialized dynptrs */
1448 SEC("?raw_tp")
1449 __failure __msg("Expected an initialized dynptr as arg #0")
1450 int dynptr_size_invalid(void *ctx)
1451 {
1452         struct bpf_dynptr ptr = {};
1453
1454         /* this should fail */
1455         bpf_dynptr_size(&ptr);
1456
1457         return 0;
1458 }
1459
1460 /* Only initialized dynptrs can be cloned */
1461 SEC("?raw_tp")
1462 __failure __msg("Expected an initialized dynptr as arg #0")
1463 int clone_invalid1(void *ctx)
1464 {
1465         struct bpf_dynptr ptr1 = {};
1466         struct bpf_dynptr ptr2;
1467
1468         /* this should fail */
1469         bpf_dynptr_clone(&ptr1, &ptr2);
1470
1471         return 0;
1472 }
1473
1474 /* Can't overwrite an existing dynptr when cloning */
1475 SEC("?xdp")
1476 __failure __msg("cannot overwrite referenced dynptr")
1477 int clone_invalid2(struct xdp_md *xdp)
1478 {
1479         struct bpf_dynptr ptr1;
1480         struct bpf_dynptr clone;
1481
1482         bpf_dynptr_from_xdp(xdp, 0, &ptr1);
1483
1484         bpf_ringbuf_reserve_dynptr(&ringbuf, 64, 0, &clone);
1485
1486         /* this should fail */
1487         bpf_dynptr_clone(&ptr1, &clone);
1488
1489         bpf_ringbuf_submit_dynptr(&clone, 0);
1490
1491         return 0;
1492 }
1493
1494 /* Invalidating a dynptr should invalidate its clones */
1495 SEC("?raw_tp")
1496 __failure __msg("Expected an initialized dynptr as arg #2")
1497 int clone_invalidate1(void *ctx)
1498 {
1499         struct bpf_dynptr clone;
1500         struct bpf_dynptr ptr;
1501         char read_data[64];
1502
1503         bpf_ringbuf_reserve_dynptr(&ringbuf, val, 0, &ptr);
1504
1505         bpf_dynptr_clone(&ptr, &clone);
1506
1507         bpf_ringbuf_submit_dynptr(&ptr, 0);
1508
1509         /* this should fail */
1510         bpf_dynptr_read(read_data, sizeof(read_data), &clone, 0, 0);
1511
1512         return 0;
1513 }
1514
1515 /* Invalidating a dynptr should invalidate its parent */
1516 SEC("?raw_tp")
1517 __failure __msg("Expected an initialized dynptr as arg #2")
1518 int clone_invalidate2(void *ctx)
1519 {
1520         struct bpf_dynptr ptr;
1521         struct bpf_dynptr clone;
1522         char read_data[64];
1523
1524         bpf_ringbuf_reserve_dynptr(&ringbuf, val, 0, &ptr);
1525
1526         bpf_dynptr_clone(&ptr, &clone);
1527
1528         bpf_ringbuf_submit_dynptr(&clone, 0);
1529
1530         /* this should fail */
1531         bpf_dynptr_read(read_data, sizeof(read_data), &ptr, 0, 0);
1532
1533         return 0;
1534 }
1535
1536 /* Invalidating a dynptr should invalidate its siblings */
1537 SEC("?raw_tp")
1538 __failure __msg("Expected an initialized dynptr as arg #2")
1539 int clone_invalidate3(void *ctx)
1540 {
1541         struct bpf_dynptr ptr;
1542         struct bpf_dynptr clone1;
1543         struct bpf_dynptr clone2;
1544         char read_data[64];
1545
1546         bpf_ringbuf_reserve_dynptr(&ringbuf, val, 0, &ptr);
1547
1548         bpf_dynptr_clone(&ptr, &clone1);
1549
1550         bpf_dynptr_clone(&ptr, &clone2);
1551
1552         bpf_ringbuf_submit_dynptr(&clone2, 0);
1553
1554         /* this should fail */
1555         bpf_dynptr_read(read_data, sizeof(read_data), &clone1, 0, 0);
1556
1557         return 0;
1558 }
1559
1560 /* Invalidating a dynptr should invalidate any data slices
1561  * of its clones
1562  */
1563 SEC("?raw_tp")
1564 __failure __msg("invalid mem access 'scalar'")
1565 int clone_invalidate4(void *ctx)
1566 {
1567         struct bpf_dynptr ptr;
1568         struct bpf_dynptr clone;
1569         int *data;
1570
1571         bpf_ringbuf_reserve_dynptr(&ringbuf, val, 0, &ptr);
1572
1573         bpf_dynptr_clone(&ptr, &clone);
1574         data = bpf_dynptr_data(&clone, 0, sizeof(val));
1575         if (!data)
1576                 return 0;
1577
1578         bpf_ringbuf_submit_dynptr(&ptr, 0);
1579
1580         /* this should fail */
1581         *data = 123;
1582
1583         return 0;
1584 }
1585
1586 /* Invalidating a dynptr should invalidate any data slices
1587  * of its parent
1588  */
1589 SEC("?raw_tp")
1590 __failure __msg("invalid mem access 'scalar'")
1591 int clone_invalidate5(void *ctx)
1592 {
1593         struct bpf_dynptr ptr;
1594         struct bpf_dynptr clone;
1595         int *data;
1596
1597         bpf_ringbuf_reserve_dynptr(&ringbuf, val, 0, &ptr);
1598         data = bpf_dynptr_data(&ptr, 0, sizeof(val));
1599         if (!data)
1600                 return 0;
1601
1602         bpf_dynptr_clone(&ptr, &clone);
1603
1604         bpf_ringbuf_submit_dynptr(&clone, 0);
1605
1606         /* this should fail */
1607         *data = 123;
1608
1609         return 0;
1610 }
1611
1612 /* Invalidating a dynptr should invalidate any data slices
1613  * of its sibling
1614  */
1615 SEC("?raw_tp")
1616 __failure __msg("invalid mem access 'scalar'")
1617 int clone_invalidate6(void *ctx)
1618 {
1619         struct bpf_dynptr ptr;
1620         struct bpf_dynptr clone1;
1621         struct bpf_dynptr clone2;
1622         int *data;
1623
1624         bpf_ringbuf_reserve_dynptr(&ringbuf, val, 0, &ptr);
1625
1626         bpf_dynptr_clone(&ptr, &clone1);
1627
1628         bpf_dynptr_clone(&ptr, &clone2);
1629
1630         data = bpf_dynptr_data(&clone1, 0, sizeof(val));
1631         if (!data)
1632                 return 0;
1633
1634         bpf_ringbuf_submit_dynptr(&clone2, 0);
1635
1636         /* this should fail */
1637         *data = 123;
1638
1639         return 0;
1640 }
1641
1642 /* A skb clone's data slices should be invalid anytime packet data changes */
1643 SEC("?tc")
1644 __failure __msg("invalid mem access 'scalar'")
1645 int clone_skb_packet_data(struct __sk_buff *skb)
1646 {
1647         char buffer[sizeof(__u32)] = {};
1648         struct bpf_dynptr clone;
1649         struct bpf_dynptr ptr;
1650         __u32 *data;
1651
1652         bpf_dynptr_from_skb(skb, 0, &ptr);
1653
1654         bpf_dynptr_clone(&ptr, &clone);
1655         data = bpf_dynptr_slice_rdwr(&clone, 0, buffer, sizeof(buffer));
1656         if (!data)
1657                 return XDP_DROP;
1658
1659         if (bpf_skb_pull_data(skb, skb->len))
1660                 return SK_DROP;
1661
1662         /* this should fail */
1663         *data = 123;
1664
1665         return 0;
1666 }
1667
1668 /* A xdp clone's data slices should be invalid anytime packet data changes */
1669 SEC("?xdp")
1670 __failure __msg("invalid mem access 'scalar'")
1671 int clone_xdp_packet_data(struct xdp_md *xdp)
1672 {
1673         char buffer[sizeof(__u32)] = {};
1674         struct bpf_dynptr clone;
1675         struct bpf_dynptr ptr;
1676         struct ethhdr *hdr;
1677         __u32 *data;
1678
1679         bpf_dynptr_from_xdp(xdp, 0, &ptr);
1680
1681         bpf_dynptr_clone(&ptr, &clone);
1682         data = bpf_dynptr_slice_rdwr(&clone, 0, buffer, sizeof(buffer));
1683         if (!data)
1684                 return XDP_DROP;
1685
1686         if (bpf_xdp_adjust_head(xdp, 0 - (int)sizeof(*hdr)))
1687                 return XDP_DROP;
1688
1689         /* this should fail */
1690         *data = 123;
1691
1692         return 0;
1693 }
1694
1695 /* Buffers that are provided must be sufficiently long */
1696 SEC("?cgroup_skb/egress")
1697 __failure __msg("memory, len pair leads to invalid memory access")
1698 int test_dynptr_skb_small_buff(struct __sk_buff *skb)
1699 {
1700         struct bpf_dynptr ptr;
1701         char buffer[8] = {};
1702         __u64 *data;
1703
1704         if (bpf_dynptr_from_skb(skb, 0, &ptr)) {
1705                 err = 1;
1706                 return 1;
1707         }
1708
1709         /* This may return NULL. SKB may require a buffer */
1710         data = bpf_dynptr_slice(&ptr, 0, buffer, 9);
1711
1712         return !!data;
1713 }
1714
1715 __noinline long global_call_bpf_dynptr(const struct bpf_dynptr *dynptr)
1716 {
1717         long ret = 0;
1718         /* Avoid leaving this global function empty to avoid having the compiler
1719          * optimize away the call to this global function.
1720          */
1721         __sink(ret);
1722         return ret;
1723 }
1724
1725 SEC("?raw_tp")
1726 __failure __msg("arg#0 expected pointer to stack or const struct bpf_dynptr")
1727 int test_dynptr_reg_type(void *ctx)
1728 {
1729         struct task_struct *current = NULL;
1730         /* R1 should be holding a PTR_TO_BTF_ID, so this shouldn't be a
1731          * reg->type that can be passed to a function accepting a
1732          * ARG_PTR_TO_DYNPTR | MEM_RDONLY. process_dynptr_func() should catch
1733          * this.
1734          */
1735         global_call_bpf_dynptr((const struct bpf_dynptr *)current);
1736         return 0;
1737 }