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 8char _license[] SEC("license") = "GPL"; 9 10struct callback_ctx { 11 int output; 12}; 13 14struct { 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 */ 22u32 nested_callback_nr_loops; 23u32 stop_index = -1; 24u32 nr_loops; 25int pid; 26int callback_selector; 27 28/* Making these global variables so that the userspace program 29 * can verify the output through the skeleton 30 */ 31int nr_loops_returned; 32int g_output; 33int err; 34 35static 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 47static int empty_callback(__u32 index, void *data) 48{ 49 return 0; 50} 51 52static 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 59static int nested_callback1(__u32 index, void *data) 60{ 61 bpf_loop(nested_callback_nr_loops, nested_callback2, data, 0); 62 return 0; 63} 64 65SEC("fentry/" SYS_PREFIX "sys_nanosleep") 66int 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 83SEC("fentry/" SYS_PREFIX "sys_nanosleep") 84int 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 94SEC("fentry/" SYS_PREFIX "sys_nanosleep") 95int 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 107SEC("fentry/" SYS_PREFIX "sys_nanosleep") 108int 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 123static int callback_set_f0(int i, void *ctx) 124{ 125 g_output = 0xF0; 126 return 0; 127} 128 129static 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 */ 138SEC("fentry/" SYS_PREFIX "sys_nanosleep") 139int 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 158static int stack_check_inner_callback(void *ctx) 159{ 160 return 0; 161} 162 163static int map1_lookup_elem(int key) 164{ 165 int *val = bpf_map_lookup_elem(&map1, &key); 166 167 return val ? *val : -1; 168} 169 170static void map1_update_elem(int key, int val) 171{ 172 bpf_map_update_elem(&map1, &key, &val, BPF_ANY); 173} 174 175static 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 */ 202SEC("fentry/" SYS_PREFIX "sys_nanosleep") 203int 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} 226