1 // SPDX-License-Identifier: GPL-2.0
2 
3 #include <linux/bpf.h>
4 #include <bpf/bpf_helpers.h>
5 
6 /* Permit pretty deep stack traces */
7 #define MAX_STACK_RAWTP 100
8 struct stack_trace_t {
9 	int pid;
10 	int kern_stack_size;
11 	int user_stack_size;
12 	int user_stack_buildid_size;
13 	__u64 kern_stack[MAX_STACK_RAWTP];
14 	__u64 user_stack[MAX_STACK_RAWTP];
15 	struct bpf_stack_build_id user_stack_buildid[MAX_STACK_RAWTP];
16 };
17 
18 struct {
19 	__uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);
20 	__uint(max_entries, 2);
21 	__uint(key_size, sizeof(int));
22 	__uint(value_size, sizeof(__u32));
23 } perfmap SEC(".maps");
24 
25 struct {
26 	__uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
27 	__uint(max_entries, 1);
28 	__type(key, __u32);
29 	__type(value, struct stack_trace_t);
30 } stackdata_map SEC(".maps");
31 
32 /* Allocate per-cpu space twice the needed. For the code below
33  *   usize = bpf_get_stack(ctx, raw_data, max_len, BPF_F_USER_STACK);
34  *   if (usize < 0)
35  *     return 0;
36  *   ksize = bpf_get_stack(ctx, raw_data + usize, max_len - usize, 0);
37  *
38  * If we have value_size = MAX_STACK_RAWTP * sizeof(__u64),
39  * verifier will complain that access "raw_data + usize"
40  * with size "max_len - usize" may be out of bound.
41  * The maximum "raw_data + usize" is "raw_data + max_len"
42  * and the maximum "max_len - usize" is "max_len", verifier
43  * concludes that the maximum buffer access range is
44  * "raw_data[0...max_len * 2 - 1]" and hence reject the program.
45  *
46  * Doubling the to-be-used max buffer size can fix this verifier
47  * issue and avoid complicated C programming massaging.
48  * This is an acceptable workaround since there is one entry here.
49  */
50 struct {
51 	__uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
52 	__uint(max_entries, 1);
53 	__type(key, __u32);
54 	__type(value, __u64[2 * MAX_STACK_RAWTP]);
55 } rawdata_map SEC(".maps");
56 
57 SEC("raw_tracepoint/sys_enter")
58 int bpf_prog1(void *ctx)
59 {
60 	int max_len, max_buildid_len, total_size;
61 	struct stack_trace_t *data;
62 	long usize, ksize;
63 	void *raw_data;
64 	__u32 key = 0;
65 
66 	data = bpf_map_lookup_elem(&stackdata_map, &key);
67 	if (!data)
68 		return 0;
69 
70 	max_len = MAX_STACK_RAWTP * sizeof(__u64);
71 	max_buildid_len = MAX_STACK_RAWTP * sizeof(struct bpf_stack_build_id);
72 	data->pid = bpf_get_current_pid_tgid();
73 	data->kern_stack_size = bpf_get_stack(ctx, data->kern_stack,
74 					      max_len, 0);
75 	data->user_stack_size = bpf_get_stack(ctx, data->user_stack, max_len,
76 					    BPF_F_USER_STACK);
77 	data->user_stack_buildid_size = bpf_get_stack(
78 		ctx, data->user_stack_buildid, max_buildid_len,
79 		BPF_F_USER_STACK | BPF_F_USER_BUILD_ID);
80 	bpf_perf_event_output(ctx, &perfmap, 0, data, sizeof(*data));
81 
82 	/* write both kernel and user stacks to the same buffer */
83 	raw_data = bpf_map_lookup_elem(&rawdata_map, &key);
84 	if (!raw_data)
85 		return 0;
86 
87 	usize = bpf_get_stack(ctx, raw_data, max_len, BPF_F_USER_STACK);
88 	if (usize < 0)
89 		return 0;
90 
91 	ksize = bpf_get_stack(ctx, raw_data + usize, max_len - usize, 0);
92 	if (ksize < 0)
93 		return 0;
94 
95 	total_size = usize + ksize;
96 	if (total_size > 0 && total_size <= max_len)
97 		bpf_perf_event_output(ctx, &perfmap, 0, raw_data, total_size);
98 
99 	return 0;
100 }
101 
102 char _license[] SEC("license") = "GPL";
103