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

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (c) 2019 Facebook
   3
   4 #include <linux/ptrace.h>
   5 #include <linux/bpf.h>
   6 #include <bpf/bpf_helpers.h>
   7
   8 static volatile const struct {
   9         unsigned a[4];
  10         /*
  11          * if the struct's size is multiple of 16, compiler will put it into
  12          * .rodata.cst16 section, which is not recognized by libbpf; work
  13          * around this by ensuring we don't have 16-aligned struct
  14          */
  15         char _y;
  16 } rdonly_values = { .a = {2, 3, 4, 5} };
  17
  18 static volatile struct {
  19         unsigned did_run;
  20         unsigned iters;
  21         unsigned sum;
  22 } res;
  23
  24 SEC("raw_tracepoint/sys_enter:skip_loop")
  25 int skip_loop(struct pt_regs *ctx)
  26 {
  27         /* prevent compiler to optimize everything out */
  28         unsigned * volatile p = (void *)&rdonly_values.a;
  29         unsigned iters = 0, sum = 0;
  30
  31         /* we should never enter this loop */
  32         while (*p & 1) {
  33                 iters++;
  34                 sum += *p;
  35                 p++;
  36         }
  37         res.did_run = 1;
  38         res.iters = iters;
  39         res.sum = sum;
  40         return 0;
  41 }
  42
  43 SEC("raw_tracepoint/sys_enter:part_loop")
  44 int part_loop(struct pt_regs *ctx)
  45 {
  46         /* prevent compiler to optimize everything out */
  47         unsigned * volatile p = (void *)&rdonly_values.a;
  48         unsigned iters = 0, sum = 0;
  49
  50         /* validate verifier can derive loop termination */
  51         while (*p < 5) {
  52                 iters++;
  53                 sum += *p;
  54                 p++;
  55         }
  56         res.did_run = 1;
  57         res.iters = iters;
  58         res.sum = sum;
  59         return 0;
  60 }
  61
  62 SEC("raw_tracepoint/sys_enter:full_loop")
  63 int full_loop(struct pt_regs *ctx)
  64 {
  65         /* prevent compiler to optimize everything out */
  66         unsigned * volatile p = (void *)&rdonly_values.a;
  67         int i = sizeof(rdonly_values.a) / sizeof(rdonly_values.a[0]);
  68         unsigned iters = 0, sum = 0;
  69
  70         /* validate verifier can allow full loop as well */
  71         while (i > 0 ) {
  72                 iters++;
  73                 sum += *p;
  74                 p++;
  75                 i--;
  76         }
  77         res.did_run = 1;
  78         res.iters = iters;
  79         res.sum = sum;
  80         return 0;
  81 }
  82
  83 char _license[] SEC("license") = "GPL";