Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0
2#include <pthread.h>
3#include <bpf/btf.h>
4#include <test_progs.h>
5
6#define TLD_FREE_DATA_ON_THREAD_EXIT
7#define TLD_DYN_DATA_SIZE (getpagesize() - 8)
8#include "task_local_data.h"
9
10struct test_tld_struct {
11 __u64 a;
12 __u64 b;
13 __u64 c;
14 __u64 d;
15};
16
17#include "test_task_local_data.skel.h"
18
19TLD_DEFINE_KEY(value0_key, "value0", sizeof(int));
20
21/*
22 * Reset task local data between subtests by clearing metadata other
23 * than the statically defined value0. This is safe as subtests run
24 * sequentially. Users of task local data library should not touch
25 * library internal.
26 */
27static void reset_tld(void)
28{
29 if (TLD_READ_ONCE(tld_meta_p)) {
30 /* Remove TLDs created by tld_create_key() */
31 tld_meta_p->cnt = 1;
32 tld_meta_p->size = TLD_DYN_DATA_SIZE;
33 memset(&tld_meta_p->metadata[1], 0,
34 (TLD_MAX_DATA_CNT - 1) * sizeof(struct tld_metadata));
35 }
36}
37
38/* Serialize access to bpf program's global variables */
39static pthread_mutex_t global_mutex;
40
41static tld_key_t *tld_keys;
42
43#define TEST_BASIC_THREAD_NUM 32
44
45void *test_task_local_data_basic_thread(void *arg)
46{
47 LIBBPF_OPTS(bpf_test_run_opts, opts);
48 struct test_task_local_data *skel = (struct test_task_local_data *)arg;
49 int fd, err, tid, *value0, *value1;
50 struct test_tld_struct *value2;
51
52 fd = bpf_map__fd(skel->maps.tld_data_map);
53
54 value0 = tld_get_data(fd, value0_key);
55 if (!ASSERT_OK_PTR(value0, "tld_get_data"))
56 goto out;
57
58 value1 = tld_get_data(fd, tld_keys[1]);
59 if (!ASSERT_OK_PTR(value1, "tld_get_data"))
60 goto out;
61
62 value2 = tld_get_data(fd, tld_keys[2]);
63 if (!ASSERT_OK_PTR(value2, "tld_get_data"))
64 goto out;
65
66 tid = sys_gettid();
67
68 *value0 = tid + 0;
69 *value1 = tid + 1;
70 value2->a = tid + 2;
71 value2->b = tid + 3;
72 value2->c = tid + 4;
73 value2->d = tid + 5;
74
75 pthread_mutex_lock(&global_mutex);
76 /* Run task_main that read task local data and save to global variables */
77 err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.task_main), &opts);
78 ASSERT_OK(err, "run task_main");
79 ASSERT_OK(opts.retval, "task_main retval");
80
81 ASSERT_EQ(skel->bss->test_value0, tid + 0, "tld_get_data value0");
82 ASSERT_EQ(skel->bss->test_value1, tid + 1, "tld_get_data value1");
83 ASSERT_EQ(skel->bss->test_value2.a, tid + 2, "tld_get_data value2.a");
84 ASSERT_EQ(skel->bss->test_value2.b, tid + 3, "tld_get_data value2.b");
85 ASSERT_EQ(skel->bss->test_value2.c, tid + 4, "tld_get_data value2.c");
86 ASSERT_EQ(skel->bss->test_value2.d, tid + 5, "tld_get_data value2.d");
87 pthread_mutex_unlock(&global_mutex);
88
89 /* Make sure valueX are indeed local to threads */
90 ASSERT_EQ(*value0, tid + 0, "value0");
91 ASSERT_EQ(*value1, tid + 1, "value1");
92 ASSERT_EQ(value2->a, tid + 2, "value2.a");
93 ASSERT_EQ(value2->b, tid + 3, "value2.b");
94 ASSERT_EQ(value2->c, tid + 4, "value2.c");
95 ASSERT_EQ(value2->d, tid + 5, "value2.d");
96
97 *value0 = tid + 5;
98 *value1 = tid + 4;
99 value2->a = tid + 3;
100 value2->b = tid + 2;
101 value2->c = tid + 1;
102 value2->d = tid + 0;
103
104 /* Run task_main again */
105 pthread_mutex_lock(&global_mutex);
106 err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.task_main), &opts);
107 ASSERT_OK(err, "run task_main");
108 ASSERT_OK(opts.retval, "task_main retval");
109
110 ASSERT_EQ(skel->bss->test_value0, tid + 5, "tld_get_data value0");
111 ASSERT_EQ(skel->bss->test_value1, tid + 4, "tld_get_data value1");
112 ASSERT_EQ(skel->bss->test_value2.a, tid + 3, "tld_get_data value2.a");
113 ASSERT_EQ(skel->bss->test_value2.b, tid + 2, "tld_get_data value2.b");
114 ASSERT_EQ(skel->bss->test_value2.c, tid + 1, "tld_get_data value2.c");
115 ASSERT_EQ(skel->bss->test_value2.d, tid + 0, "tld_get_data value2.d");
116 pthread_mutex_unlock(&global_mutex);
117
118out:
119 pthread_exit(NULL);
120}
121
122static void test_task_local_data_basic(void)
123{
124 struct test_task_local_data *skel;
125 pthread_t thread[TEST_BASIC_THREAD_NUM];
126 char dummy_key_name[TLD_NAME_LEN];
127 tld_key_t key;
128 int i, err;
129
130 reset_tld();
131
132 ASSERT_OK(pthread_mutex_init(&global_mutex, NULL), "pthread_mutex_init");
133
134 skel = test_task_local_data__open_and_load();
135 if (!ASSERT_OK_PTR(skel, "skel_open_and_load"))
136 return;
137
138 tld_keys = calloc(TLD_MAX_DATA_CNT, sizeof(tld_key_t));
139 if (!ASSERT_OK_PTR(tld_keys, "calloc tld_keys"))
140 goto out;
141
142 ASSERT_FALSE(tld_key_is_err(value0_key), "TLD_DEFINE_KEY");
143 tld_keys[1] = tld_create_key("value1", sizeof(int));
144 ASSERT_FALSE(tld_key_is_err(tld_keys[1]), "tld_create_key");
145 tld_keys[2] = tld_create_key("value2", sizeof(struct test_tld_struct));
146 ASSERT_FALSE(tld_key_is_err(tld_keys[2]), "tld_create_key");
147
148 /*
149 * Shouldn't be able to store data exceed a page. Create a TLD just big
150 * enough to exceed a page. TLDs already created are int value0, int
151 * value1, and struct test_tld_struct value2.
152 */
153 key = tld_create_key("value_not_exist",
154 TLD_PAGE_SIZE - 2 * sizeof(int) - sizeof(struct test_tld_struct) + 1);
155 ASSERT_EQ(tld_key_err_or_zero(key), -E2BIG, "tld_create_key");
156
157 key = tld_create_key("value2", sizeof(struct test_tld_struct));
158 ASSERT_EQ(tld_key_err_or_zero(key), -EEXIST, "tld_create_key");
159
160 /* Shouldn't be able to create the (TLD_MAX_DATA_CNT+1)-th TLD */
161 for (i = 3; i < TLD_MAX_DATA_CNT; i++) {
162 snprintf(dummy_key_name, TLD_NAME_LEN, "dummy_value%d", i);
163 tld_keys[i] = tld_create_key(dummy_key_name, sizeof(int));
164 ASSERT_FALSE(tld_key_is_err(tld_keys[i]), "tld_create_key");
165 }
166 key = tld_create_key("value_not_exist", sizeof(struct test_tld_struct));
167 ASSERT_EQ(tld_key_err_or_zero(key), -ENOSPC, "tld_create_key");
168
169 /* Access TLDs from multiple threads and check if they are thread-specific */
170 for (i = 0; i < TEST_BASIC_THREAD_NUM; i++) {
171 err = pthread_create(&thread[i], NULL, test_task_local_data_basic_thread, skel);
172 if (!ASSERT_OK(err, "pthread_create"))
173 goto out;
174 }
175
176out:
177 for (i = 0; i < TEST_BASIC_THREAD_NUM; i++)
178 pthread_join(thread[i], NULL);
179
180 if (tld_keys) {
181 free(tld_keys);
182 tld_keys = NULL;
183 }
184 tld_free();
185 test_task_local_data__destroy(skel);
186}
187
188#define TEST_RACE_THREAD_NUM (TLD_MAX_DATA_CNT - 3)
189
190void *test_task_local_data_race_thread(void *arg)
191{
192 int err = 0, id = (intptr_t)arg;
193 char key_name[32];
194 tld_key_t key;
195
196 key = tld_create_key("value_not_exist", TLD_PAGE_SIZE + 1);
197 if (tld_key_err_or_zero(key) != -E2BIG) {
198 err = 1;
199 goto out;
200 }
201
202 /* Only one thread will succeed in creating value1 */
203 key = tld_create_key("value1", sizeof(int));
204 if (!tld_key_is_err(key))
205 tld_keys[1] = key;
206
207 /* Only one thread will succeed in creating value2 */
208 key = tld_create_key("value2", sizeof(struct test_tld_struct));
209 if (!tld_key_is_err(key))
210 tld_keys[2] = key;
211
212 snprintf(key_name, 32, "thread_%d", id);
213 tld_keys[id] = tld_create_key(key_name, sizeof(int));
214 if (tld_key_is_err(tld_keys[id]))
215 err = 2;
216out:
217 return (void *)(intptr_t)err;
218}
219
220static void test_task_local_data_race(void)
221{
222 LIBBPF_OPTS(bpf_test_run_opts, opts);
223 pthread_t thread[TEST_RACE_THREAD_NUM];
224 struct test_task_local_data *skel;
225 int fd, i, j, err, *data;
226 void *ret = NULL;
227
228 skel = test_task_local_data__open_and_load();
229 if (!ASSERT_OK_PTR(skel, "skel_open_and_load"))
230 return;
231
232 tld_keys = calloc(TLD_MAX_DATA_CNT, sizeof(tld_key_t));
233 if (!ASSERT_OK_PTR(tld_keys, "calloc tld_keys"))
234 goto out;
235
236 fd = bpf_map__fd(skel->maps.tld_data_map);
237
238 ASSERT_FALSE(tld_key_is_err(value0_key), "TLD_DEFINE_KEY");
239 tld_keys[0] = value0_key;
240
241 for (j = 0; j < 100; j++) {
242 reset_tld();
243
244 for (i = 0; i < TEST_RACE_THREAD_NUM; i++) {
245 /*
246 * Try to make tld_create_key() race with each other. Call
247 * tld_create_key(), both valid and invalid, from different threads.
248 */
249 err = pthread_create(&thread[i], NULL, test_task_local_data_race_thread,
250 (void *)(intptr_t)(i + 3));
251 if (CHECK_FAIL(err))
252 break;
253 }
254
255 /* Wait for all tld_create_key() to return */
256 for (i = 0; i < TEST_RACE_THREAD_NUM; i++) {
257 pthread_join(thread[i], &ret);
258 if (CHECK_FAIL(ret))
259 break;
260 }
261
262 /* Write a unique number to each TLD */
263 for (i = 0; i < TLD_MAX_DATA_CNT; i++) {
264 data = tld_get_data(fd, tld_keys[i]);
265 if (CHECK_FAIL(!data))
266 break;
267 *data = i;
268 }
269
270 /* Read TLDs and check the value to see if any address collides with another */
271 for (i = 0; i < TLD_MAX_DATA_CNT; i++) {
272 data = tld_get_data(fd, tld_keys[i]);
273 if (CHECK_FAIL(*data != i))
274 break;
275 }
276
277 /* Run task_main to make sure no invalid TLDs are added */
278 err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.task_main), &opts);
279 ASSERT_OK(err, "run task_main");
280 ASSERT_OK(opts.retval, "task_main retval");
281 }
282out:
283 if (tld_keys) {
284 free(tld_keys);
285 tld_keys = NULL;
286 }
287 tld_free();
288 test_task_local_data__destroy(skel);
289}
290
291void test_task_local_data(void)
292{
293 if (test__start_subtest("task_local_data_basic"))
294 test_task_local_data_basic();
295 if (test__start_subtest("task_local_data_race"))
296 test_task_local_data_race();
297}