Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0
2/* Copyright (c) 2026, Oracle and/or its affiliates. */
3
4#include <test_progs.h>
5#include <bpf/btf.h>
6#include <bpf/libbpf.h>
7
8/* Verify kind encoding exists for each kind */
9static void test_btf_kind_encoding(void)
10{
11 LIBBPF_OPTS(btf_new_opts, opts);
12 const struct btf_header *hdr;
13 const void *raw_btf;
14 struct btf *btf;
15 __u32 raw_size;
16
17 opts.add_layout = true;
18 btf = btf__new_empty_opts(&opts);
19 if (!ASSERT_OK_PTR(btf, "btf_new"))
20 return;
21
22 raw_btf = btf__raw_data(btf, &raw_size);
23 if (!ASSERT_OK_PTR(raw_btf, "btf__raw_data"))
24 return;
25
26 hdr = raw_btf;
27
28 ASSERT_EQ(hdr->layout_off % 4, 0, "layout_aligned");
29 ASSERT_EQ(hdr->layout_len, sizeof(struct btf_layout) * NR_BTF_KINDS,
30 "layout_len");
31 ASSERT_EQ(hdr->str_off, hdr->layout_off + hdr->layout_len, "str_after_layout");
32 btf__free(btf);
33
34 opts.add_layout = false;
35 btf = btf__new_empty_opts(&opts);
36 if (!ASSERT_OK_PTR(btf, "btf_new"))
37 return;
38
39 raw_btf = btf__raw_data(btf, &raw_size);
40 if (!ASSERT_OK_PTR(raw_btf, "btf__raw_data"))
41 return;
42
43 hdr = raw_btf;
44
45 ASSERT_EQ(hdr->layout_off, 0, "no_layout_off");
46 ASSERT_EQ(hdr->layout_len, 0, "no_layout_len");
47 ASSERT_EQ(hdr->str_off, hdr->type_off + hdr->type_len, "strs_after_types");
48 btf__free(btf);
49}
50
51static int write_raw_btf(void *raw_btf, size_t raw_size, char *file)
52{
53 int fd = mkstemp(file);
54 ssize_t n;
55
56 if (!ASSERT_OK_FD(fd, "open_raw_btf"))
57 return -1;
58 n = write(fd, raw_btf, raw_size);
59 close(fd);
60 if (!ASSERT_EQ(n, (ssize_t)raw_size, "write_raw_btf"))
61 return -1;
62 return 0;
63}
64
65/*
66 * Fabricate an unrecognized kind at BTF_KIND_MAX + 1, and after adding
67 * the appropriate struct/typedefs to the BTF such that it recognizes
68 * this kind, ensure that parsing of BTF containing the unrecognized kind
69 * can succeed.
70 */
71void test_btf_kind_decoding(void)
72{
73 char btf_kind_file1[] = "/tmp/test_btf_kind.XXXXXX";
74 char btf_kind_file2[] = "/tmp/test_btf_kind.XXXXXX";
75 char btf_kind_file3[] = "/tmp/test_btf_kind.XXXXXX";
76 struct btf *btf = NULL, *new_btf = NULL;
77 __s32 int_id, unrec_id, id, id2;
78 LIBBPF_OPTS(btf_new_opts, opts);
79 struct btf_layout *l;
80 struct btf_header *hdr;
81 const void *raw_btf;
82 struct btf_type *t;
83 void *new_raw_btf;
84 void *str_data;
85 __u32 raw_size;
86
87 opts.add_layout = true;
88 btf = btf__new_empty_opts(&opts);
89 if (!ASSERT_OK_PTR(btf, "btf_new"))
90 return;
91
92 int_id = btf__add_int(btf, "test_char", 1, BTF_INT_CHAR);
93 if (!ASSERT_GT(int_id, 0, "add_int_id"))
94 return;
95
96 /*
97 * Create our type with unrecognized kind by adding a typedef kind
98 * we will overwrite it with our unrecognized kind value.
99 */
100 unrec_id = btf__add_typedef(btf, "unrec_kind", int_id);
101 if (!ASSERT_GT(unrec_id, 0, "add_unrec_id"))
102 return;
103
104 /*
105 * Add an id after it that we will look up to verify we can parse
106 * beyond unrecognized kinds.
107 */
108 id = btf__add_typedef(btf, "test_lookup", int_id);
109 if (!ASSERT_GT(id, 0, "add_test_lookup_id"))
110 return;
111 id2 = btf__add_typedef(btf, "test_lookup2", int_id);
112 if (!ASSERT_GT(id2, 0, "add_test_lookup_id2"))
113 return;
114
115 raw_btf = (void *)btf__raw_data(btf, &raw_size);
116 if (!ASSERT_OK_PTR(raw_btf, "btf__raw_data"))
117 return;
118
119 new_raw_btf = calloc(1, raw_size + sizeof(*l));
120 if (!ASSERT_OK_PTR(new_raw_btf, "calloc_raw_btf"))
121 return;
122 memcpy(new_raw_btf, raw_btf, raw_size);
123
124 hdr = new_raw_btf;
125
126 /* Move strings to make space for one new layout description */
127 raw_size += sizeof(*l);
128 str_data = new_raw_btf + hdr->hdr_len + hdr->str_off;
129 memmove(str_data + sizeof(*l), str_data, hdr->str_len);
130 hdr->str_off += sizeof(*l);
131
132 /* Add new layout description */
133 hdr->layout_len += sizeof(*l);
134 l = new_raw_btf + hdr->hdr_len + hdr->layout_off;
135 l[NR_BTF_KINDS].info_sz = 0;
136 l[NR_BTF_KINDS].elem_sz = 0;
137 l[NR_BTF_KINDS].flags = 0;
138
139 /* Now modify typedef added above to be an unrecognized kind. */
140 t = (void *)hdr + hdr->hdr_len + hdr->type_off + sizeof(struct btf_type) +
141 sizeof(__u32);
142 t->info = (NR_BTF_KINDS << 24);
143
144 /* Write BTF to a raw file, ready for parsing. */
145 if (write_raw_btf(new_raw_btf, raw_size, btf_kind_file1))
146 goto out;
147
148 /*
149 * Verify parsing succeeds, and that we can read type info past
150 * the unrecognized kind.
151 */
152 new_btf = btf__parse_raw(btf_kind_file1);
153 if (ASSERT_OK_PTR(new_btf, "btf__parse_raw")) {
154 ASSERT_EQ(btf__find_by_name(new_btf, "unrec_kind"), unrec_id,
155 "unrec_kind_found");
156 ASSERT_EQ(btf__find_by_name_kind(new_btf, "test_lookup",
157 BTF_KIND_TYPEDEF), id,
158 "verify_id_lookup");
159 ASSERT_EQ(btf__find_by_name_kind(new_btf, "test_lookup2",
160 BTF_KIND_TYPEDEF), id2,
161 "verify_id2_lookup");
162 }
163 btf__free(new_btf);
164 new_btf = NULL;
165
166 /*
167 * Next, change info_sz to equal sizeof(struct btf_type); this means the
168 * "test_lookup" kind will be reinterpreted as a singular info element
169 * following the unrecognized kind.
170 */
171 l[NR_BTF_KINDS].info_sz = sizeof(struct btf_type);
172 if (write_raw_btf(new_raw_btf, raw_size, btf_kind_file2))
173 goto out;
174
175 new_btf = btf__parse_raw(btf_kind_file2);
176 if (ASSERT_OK_PTR(new_btf, "btf__parse_raw")) {
177 ASSERT_EQ(btf__find_by_name_kind(new_btf, "test_lookup",
178 BTF_KIND_TYPEDEF), -ENOENT,
179 "verify_id_not_found");
180 /* id of "test_lookup2" will be id2 -1 as we have removed one type */
181 ASSERT_EQ(btf__find_by_name_kind(new_btf, "test_lookup2",
182 BTF_KIND_TYPEDEF), id2 - 1,
183 "verify_id_lookup2");
184
185 }
186 btf__free(new_btf);
187 new_btf = NULL;
188
189 /*
190 * Change elem_sz to equal sizeof(struct btf_type) and set vlen
191 * associated with unrecognized type to 1; this allows us to verify
192 * vlen-specified BTF can still be parsed.
193 */
194 l[NR_BTF_KINDS].info_sz = 0;
195 l[NR_BTF_KINDS].elem_sz = sizeof(struct btf_type);
196 t->info |= 1;
197 if (write_raw_btf(new_raw_btf, raw_size, btf_kind_file3))
198 goto out;
199
200 new_btf = btf__parse_raw(btf_kind_file3);
201 if (ASSERT_OK_PTR(new_btf, "btf__parse_raw")) {
202 ASSERT_EQ(btf__find_by_name_kind(new_btf, "test_lookup",
203 BTF_KIND_TYPEDEF), -ENOENT,
204 "verify_id_not_found");
205 /* id of "test_lookup2" will be id2 -1 as we have removed one type */
206 ASSERT_EQ(btf__find_by_name_kind(new_btf, "test_lookup2",
207 BTF_KIND_TYPEDEF), id2 - 1,
208 "verify_id_lookup2");
209
210 }
211out:
212 btf__free(new_btf);
213 free(new_raw_btf);
214 unlink(btf_kind_file1);
215 unlink(btf_kind_file2);
216 unlink(btf_kind_file3);
217 btf__free(btf);
218}
219
220void test_btf_kind(void)
221{
222 if (test__start_subtest("btf_kind_encoding"))
223 test_btf_kind_encoding();
224 if (test__start_subtest("btf_kind_decoding"))
225 test_btf_kind_decoding();
226}