1275970Scy// SPDX-License-Identifier: GPL-2.0
2275970Scy/* Copyright (c) 2020, Oracle and/or its affiliates. */
3275970Scy
4275970Scy#include "btf_ptr.h"
5275970Scy#include <bpf/bpf_helpers.h>
6275970Scy#include <bpf/bpf_tracing.h>
7275970Scy#include <bpf/bpf_core_read.h>
8275970Scy
9275970Scy#include <errno.h>
10275970Scy
11275970Scylong ret = 0;
12275970Scyint num_subtests = 0;
13275970Scyint ran_subtests = 0;
14275970Scybool skip = false;
15275970Scy
16275970Scy#define STRSIZE			2048
17275970Scy#define EXPECTED_STRSIZE	256
18275970Scy
19275970Scy#if defined(bpf_target_s390)
20275970Scy/* NULL points to a readable struct lowcore on s390, so take the last page */
21275970Scy#define BADPTR			((void *)0xFFFFFFFFFFFFF000ULL)
22275970Scy#else
23275970Scy#define BADPTR			0
24275970Scy#endif
25275970Scy
26275970Scy#ifndef ARRAY_SIZE
27275970Scy#define ARRAY_SIZE(x)	(sizeof(x) / sizeof((x)[0]))
28275970Scy#endif
29275970Scy
30275970Scystruct {
31275970Scy	__uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
32275970Scy	__uint(max_entries, 1);
33275970Scy	__type(key, __u32);
34275970Scy	__type(value, char[STRSIZE]);
35275970Scy} strdata SEC(".maps");
36275970Scy
37275970Scystatic int __strncmp(const void *m1, const void *m2, size_t len)
38275970Scy{
39275970Scy	const unsigned char *s1 = m1;
40275970Scy	const unsigned char *s2 = m2;
41275970Scy	int i, delta = 0;
42275970Scy
43275970Scy	for (i = 0; i < len; i++) {
44275970Scy		delta = s1[i] - s2[i];
45275970Scy		if (delta || s1[i] == 0 || s2[i] == 0)
46275970Scy			break;
47275970Scy	}
48275970Scy	return delta;
49275970Scy}
50275970Scy
51275970Scy#if __has_builtin(__builtin_btf_type_id)
52275970Scy#define	TEST_BTF(_str, _type, _flags, _expected, ...)			\
53275970Scy	do {								\
54275970Scy		static const char _expectedval[EXPECTED_STRSIZE] =	\
55275970Scy							_expected;	\
56275970Scy		__u64 _hflags = _flags | BTF_F_COMPACT;			\
57275970Scy		static _type _ptrdata = __VA_ARGS__;			\
58275970Scy		static struct btf_ptr _ptr = { };			\
59275970Scy		int _cmp;						\
60275970Scy									\
61275970Scy		++num_subtests;						\
62275970Scy		if (ret < 0)						\
63275970Scy			break;						\
64275970Scy		++ran_subtests;						\
65275970Scy		_ptr.ptr = &_ptrdata;					\
66275970Scy		_ptr.type_id = bpf_core_type_id_kernel(_type);		\
67275970Scy		if (_ptr.type_id <= 0) {				\
68275970Scy			ret = -EINVAL;					\
69275970Scy			break;						\
70275970Scy		}							\
71275970Scy		ret = bpf_snprintf_btf(_str, STRSIZE,			\
72275970Scy				       &_ptr, sizeof(_ptr), _hflags);	\
73275970Scy		if (ret)						\
74275970Scy			break;						\
75275970Scy		_cmp = __strncmp(_str, _expectedval, EXPECTED_STRSIZE);	\
76275970Scy		if (_cmp != 0) {					\
77275970Scy			bpf_printk("(%d) got %s", _cmp, _str);		\
78275970Scy			bpf_printk("(%d) expected %s", _cmp,		\
79275970Scy				   _expectedval);			\
80275970Scy			ret = -EBADMSG;					\
81275970Scy			break;						\
82275970Scy		}							\
83275970Scy	} while (0)
84#endif
85
86/* Use where expected data string matches its stringified declaration */
87#define TEST_BTF_C(_str, _type, _flags, ...)				\
88	TEST_BTF(_str, _type, _flags, "(" #_type ")" #__VA_ARGS__,	\
89		 __VA_ARGS__)
90
91/* TRACE_EVENT(netif_receive_skb,
92 *	TP_PROTO(struct sk_buff *skb),
93 */
94SEC("tp_btf/netif_receive_skb")
95int BPF_PROG(trace_netif_receive_skb, struct sk_buff *skb)
96{
97	static __u64 flags[] = { 0, BTF_F_COMPACT, BTF_F_ZERO, BTF_F_PTR_RAW,
98				 BTF_F_NONAME, BTF_F_COMPACT | BTF_F_ZERO |
99				 BTF_F_PTR_RAW | BTF_F_NONAME };
100	static struct btf_ptr p = { };
101	__u32 key = 0;
102	int i, __ret;
103	char *str;
104
105#if __has_builtin(__builtin_btf_type_id)
106	str = bpf_map_lookup_elem(&strdata, &key);
107	if (!str)
108		return 0;
109
110	/* Ensure we can write skb string representation */
111	p.type_id = bpf_core_type_id_kernel(struct sk_buff);
112	p.ptr = skb;
113	for (i = 0; i < ARRAY_SIZE(flags); i++) {
114		++num_subtests;
115		ret = bpf_snprintf_btf(str, STRSIZE, &p, sizeof(p), 0);
116		if (ret < 0)
117			bpf_printk("returned %d when writing skb", ret);
118		++ran_subtests;
119	}
120
121	/* Check invalid ptr value */
122	p.ptr = BADPTR;
123	__ret = bpf_snprintf_btf(str, STRSIZE, &p, sizeof(p), 0);
124	if (__ret >= 0) {
125		bpf_printk("printing %llx should generate error, got (%d)",
126			   (unsigned long long)BADPTR, __ret);
127		ret = -ERANGE;
128	}
129
130	/* Verify type display for various types. */
131
132	/* simple int */
133	TEST_BTF_C(str, int, 0, 1234);
134	TEST_BTF(str, int, BTF_F_NONAME, "1234", 1234);
135	/* zero value should be printed at toplevel */
136	TEST_BTF(str, int, 0, "(int)0", 0);
137	TEST_BTF(str, int, BTF_F_NONAME, "0", 0);
138	TEST_BTF(str, int, BTF_F_ZERO, "(int)0", 0);
139	TEST_BTF(str, int, BTF_F_NONAME | BTF_F_ZERO, "0", 0);
140	TEST_BTF_C(str, int, 0, -4567);
141	TEST_BTF(str, int, BTF_F_NONAME, "-4567", -4567);
142
143	/* simple char */
144	TEST_BTF_C(str, char, 0, 100);
145	TEST_BTF(str, char, BTF_F_NONAME, "100", 100);
146	/* zero value should be printed at toplevel */
147	TEST_BTF(str, char, 0, "(char)0", 0);
148	TEST_BTF(str, char, BTF_F_NONAME, "0", 0);
149	TEST_BTF(str, char, BTF_F_ZERO, "(char)0", 0);
150	TEST_BTF(str, char, BTF_F_NONAME | BTF_F_ZERO, "0", 0);
151
152	/* simple typedef */
153	TEST_BTF_C(str, uint64_t, 0, 100);
154	TEST_BTF(str, u64, BTF_F_NONAME, "1", 1);
155	/* zero value should be printed at toplevel */
156	TEST_BTF(str, u64, 0, "(u64)0", 0);
157	TEST_BTF(str, u64, BTF_F_NONAME, "0", 0);
158	TEST_BTF(str, u64, BTF_F_ZERO, "(u64)0", 0);
159	TEST_BTF(str, u64, BTF_F_NONAME|BTF_F_ZERO, "0", 0);
160
161	/* typedef struct */
162	TEST_BTF_C(str, atomic_t, 0, {.counter = (int)1,});
163	TEST_BTF(str, atomic_t, BTF_F_NONAME, "{1,}", {.counter = 1,});
164	/* typedef with 0 value should be printed at toplevel */
165	TEST_BTF(str, atomic_t, 0, "(atomic_t){}", {.counter = 0,});
166	TEST_BTF(str, atomic_t, BTF_F_NONAME, "{}", {.counter = 0,});
167	TEST_BTF(str, atomic_t, BTF_F_ZERO, "(atomic_t){.counter = (int)0,}",
168		 {.counter = 0,});
169	TEST_BTF(str, atomic_t, BTF_F_NONAME|BTF_F_ZERO,
170		 "{0,}", {.counter = 0,});
171
172	/* enum where enum value does (and does not) exist */
173	TEST_BTF_C(str, enum bpf_cmd, 0, BPF_MAP_CREATE);
174	TEST_BTF(str, enum bpf_cmd, 0, "(enum bpf_cmd)BPF_MAP_CREATE", 0);
175	TEST_BTF(str, enum bpf_cmd, BTF_F_NONAME, "BPF_MAP_CREATE",
176		 BPF_MAP_CREATE);
177	TEST_BTF(str, enum bpf_cmd, BTF_F_NONAME|BTF_F_ZERO,
178		 "BPF_MAP_CREATE", 0);
179
180	TEST_BTF(str, enum bpf_cmd, BTF_F_ZERO, "(enum bpf_cmd)BPF_MAP_CREATE",
181		 BPF_MAP_CREATE);
182	TEST_BTF(str, enum bpf_cmd, BTF_F_NONAME|BTF_F_ZERO,
183		 "BPF_MAP_CREATE", BPF_MAP_CREATE);
184	TEST_BTF_C(str, enum bpf_cmd, 0, 2000);
185	TEST_BTF(str, enum bpf_cmd, BTF_F_NONAME, "2000", 2000);
186
187	/* simple struct */
188	TEST_BTF_C(str, struct btf_enum, 0,
189		   {.name_off = (__u32)3,.val = (__s32)-1,});
190	TEST_BTF(str, struct btf_enum, BTF_F_NONAME, "{3,-1,}",
191		 { .name_off = 3, .val = -1,});
192	TEST_BTF(str, struct btf_enum, BTF_F_NONAME, "{-1,}",
193		 { .name_off = 0, .val = -1,});
194	TEST_BTF(str, struct btf_enum, BTF_F_NONAME|BTF_F_ZERO, "{0,-1,}",
195		 { .name_off = 0, .val = -1,});
196	/* empty struct should be printed */
197	TEST_BTF(str, struct btf_enum, 0, "(struct btf_enum){}",
198		 { .name_off = 0, .val = 0,});
199	TEST_BTF(str, struct btf_enum, BTF_F_NONAME, "{}",
200		 { .name_off = 0, .val = 0,});
201	TEST_BTF(str, struct btf_enum, BTF_F_ZERO,
202		 "(struct btf_enum){.name_off = (__u32)0,.val = (__s32)0,}",
203		 { .name_off = 0, .val = 0,});
204
205	/* struct with pointers */
206	TEST_BTF(str, struct list_head, BTF_F_PTR_RAW,
207		 "(struct list_head){.next = (struct list_head *)0x0000000000000001,}",
208		 { .next = (struct list_head *)1 });
209	/* NULL pointer should not be displayed */
210	TEST_BTF(str, struct list_head, BTF_F_PTR_RAW,
211		 "(struct list_head){}",
212		 { .next = (struct list_head *)0 });
213
214	/* struct with char array */
215	TEST_BTF(str, struct bpf_prog_info, 0,
216		 "(struct bpf_prog_info){.name = (char[])['f','o','o',],}",
217		 { .name = "foo",});
218	TEST_BTF(str, struct bpf_prog_info, BTF_F_NONAME,
219		 "{['f','o','o',],}",
220		 {.name = "foo",});
221	/* leading null char means do not display string */
222	TEST_BTF(str, struct bpf_prog_info, 0,
223		 "(struct bpf_prog_info){}",
224		 {.name = {'\0', 'f', 'o', 'o'}});
225	/* handle non-printable characters */
226	TEST_BTF(str, struct bpf_prog_info, 0,
227		 "(struct bpf_prog_info){.name = (char[])[1,2,3,],}",
228		 { .name = {1, 2, 3, 0}});
229
230	/* struct with non-char array */
231	TEST_BTF(str, struct __sk_buff, 0,
232		 "(struct __sk_buff){.cb = (__u32[])[1,2,3,4,5,],}",
233		 { .cb = {1, 2, 3, 4, 5,},});
234	TEST_BTF(str, struct __sk_buff, BTF_F_NONAME,
235		 "{[1,2,3,4,5,],}",
236		 { .cb = { 1, 2, 3, 4, 5},});
237	/* For non-char, arrays, show non-zero values only */
238	TEST_BTF(str, struct __sk_buff, 0,
239		 "(struct __sk_buff){.cb = (__u32[])[1,],}",
240		 { .cb = { 0, 0, 1, 0, 0},});
241
242	/* struct with bitfields */
243	TEST_BTF_C(str, struct bpf_insn, 0,
244		   {.code = (__u8)1,.dst_reg = (__u8)0x2,.src_reg = (__u8)0x3,.off = (__s16)4,.imm = (__s32)5,});
245	TEST_BTF(str, struct bpf_insn, BTF_F_NONAME, "{1,0x2,0x3,4,5,}",
246		 {.code = 1, .dst_reg = 0x2, .src_reg = 0x3, .off = 4,
247		  .imm = 5,});
248#else
249	skip = true;
250#endif
251
252	return 0;
253}
254
255char _license[] SEC("license") = "GPL";
256