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

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2021 Facebook */
   3
   4 #include "vmlinux.h"
   5 #include <bpf/bpf_helpers.h>
   6 #include "bpf_misc.h"
   7
   8 char _license[] SEC("license") = "GPL";
   9
  10 struct callback_ctx {
  11         int output;
  12 };
  13
  14 struct {
  15         __uint(type, BPF_MAP_TYPE_HASH);
  16         __uint(max_entries, 32);
  17         __type(key, int);
  18         __type(value, int);
  19 } map1 SEC(".maps");
  20
  21 /* These should be set by the user program */
  22 u32 nested_callback_nr_loops;
  23 u32 stop_index = -1;
  24 u32 nr_loops;
  25 int pid;
  26 int callback_selector;
  27
  28 /* Making these global variables so that the userspace program
  29  * can verify the output through the skeleton
  30  */
  31 int nr_loops_returned;
  32 int g_output;
  33 int err;
  34
  35 static int callback(__u32 index, void *data)
  36 {
  37         struct callback_ctx *ctx = data;
  38
  39         if (index >= stop_index)
  40                 return 1;
  41
  42         ctx->output += index;
  43
  44         return 0;
  45 }
  46
  47 static int empty_callback(__u32 index, void *data)
  48 {
  49         return 0;
  50 }
  51
  52 static int nested_callback2(__u32 index, void *data)
  53 {
  54         nr_loops_returned += bpf_loop(nested_callback_nr_loops, callback, data, 0);
  55
  56         return 0;
  57 }
  58
  59 static int nested_callback1(__u32 index, void *data)
  60 {
  61         bpf_loop(nested_callback_nr_loops, nested_callback2, data, 0);
  62         return 0;
  63 }
  64
  65 SEC("fentry/" SYS_PREFIX "sys_nanosleep")
  66 int test_prog(void *ctx)
  67 {
  68         struct callback_ctx data = {};
  69
  70         if (bpf_get_current_pid_tgid() >> 32 != pid)
  71                 return 0;
  72
  73         nr_loops_returned = bpf_loop(nr_loops, callback, &data, 0);
  74
  75         if (nr_loops_returned < 0)
  76                 err = nr_loops_returned;
  77         else
  78                 g_output = data.output;
  79
  80         return 0;
  81 }
  82
  83 SEC("fentry/" SYS_PREFIX "sys_nanosleep")
  84 int prog_null_ctx(void *ctx)
  85 {
  86         if (bpf_get_current_pid_tgid() >> 32 != pid)
  87                 return 0;
  88
  89         nr_loops_returned = bpf_loop(nr_loops, empty_callback, NULL, 0);
  90
  91         return 0;
  92 }
  93
  94 SEC("fentry/" SYS_PREFIX "sys_nanosleep")
  95 int prog_invalid_flags(void *ctx)
  96 {
  97         struct callback_ctx data = {};
  98
  99         if (bpf_get_current_pid_tgid() >> 32 != pid)
 100                 return 0;
 101
 102         err = bpf_loop(nr_loops, callback, &data, 1);
 103
 104         return 0;
 105 }
 106
 107 SEC("fentry/" SYS_PREFIX "sys_nanosleep")
 108 int prog_nested_calls(void *ctx)
 109 {
 110         struct callback_ctx data = {};
 111
 112         if (bpf_get_current_pid_tgid() >> 32 != pid)
 113                 return 0;
 114
 115         nr_loops_returned = 0;
 116         bpf_loop(nr_loops, nested_callback1, &data, 0);
 117
 118         g_output = data.output;
 119
 120         return 0;
 121 }
 122
 123 static int callback_set_f0(int i, void *ctx)
 124 {
 125         g_output = 0xF0;
 126         return 0;
 127 }
 128
 129 static int callback_set_0f(int i, void *ctx)
 130 {
 131         g_output = 0x0F;
 132         return 0;
 133 }
 134
 135 /*
 136  * non-constant callback is a corner case for bpf_loop inline logic
 137  */
 138 SEC("fentry/" SYS_PREFIX "sys_nanosleep")
 139 int prog_non_constant_callback(void *ctx)
 140 {
 141         if (bpf_get_current_pid_tgid() >> 32 != pid)
 142                 return 0;
 143
 144         int (*callback)(int i, void *ctx);
 145
 146         g_output = 0;
 147
 148         if (callback_selector == 0x0F)
 149                 callback = callback_set_0f;
 150         else
 151                 callback = callback_set_f0;
 152
 153         bpf_loop(1, callback, NULL, 0);
 154
 155         return 0;
 156 }
 157
 158 static int stack_check_inner_callback(void *ctx)
 159 {
 160         return 0;
 161 }
 162
 163 static int map1_lookup_elem(int key)
 164 {
 165         int *val = bpf_map_lookup_elem(&map1, &key);
 166
 167         return val ? *val : -1;
 168 }
 169
 170 static void map1_update_elem(int key, int val)
 171 {
 172         bpf_map_update_elem(&map1, &key, &val, BPF_ANY);
 173 }
 174
 175 static int stack_check_outer_callback(void *ctx)
 176 {
 177         int a = map1_lookup_elem(1);
 178         int b = map1_lookup_elem(2);
 179         int c = map1_lookup_elem(3);
 180         int d = map1_lookup_elem(4);
 181         int e = map1_lookup_elem(5);
 182         int f = map1_lookup_elem(6);
 183
 184         bpf_loop(1, stack_check_inner_callback, NULL, 0);
 185
 186         map1_update_elem(1, a + 1);
 187         map1_update_elem(2, b + 1);
 188         map1_update_elem(3, c + 1);
 189         map1_update_elem(4, d + 1);
 190         map1_update_elem(5, e + 1);
 191         map1_update_elem(6, f + 1);
 192
 193         return 0;
 194 }
 195
 196 /* Some of the local variables in stack_check and
 197  * stack_check_outer_callback would be allocated on stack by
 198  * compiler. This test should verify that stack content for these
 199  * variables is preserved between calls to bpf_loop (might be an issue
 200  * if loop inlining allocates stack slots incorrectly).
 201  */
 202 SEC("fentry/" SYS_PREFIX "sys_nanosleep")
 203 int stack_check(void *ctx)
 204 {
 205         if (bpf_get_current_pid_tgid() >> 32 != pid)
 206                 return 0;
 207
 208         int a = map1_lookup_elem(7);
 209         int b = map1_lookup_elem(8);
 210         int c = map1_lookup_elem(9);
 211         int d = map1_lookup_elem(10);
 212         int e = map1_lookup_elem(11);
 213         int f = map1_lookup_elem(12);
 214
 215         bpf_loop(1, stack_check_outer_callback, NULL, 0);
 216
 217         map1_update_elem(7,  a + 1);
 218         map1_update_elem(8, b + 1);
 219         map1_update_elem(9, c + 1);
 220         map1_update_elem(10, d + 1);
 221         map1_update_elem(11, e + 1);
 222         map1_update_elem(12, f + 1);
 223
 224         return 0;
 225 }