1// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
  2/* Copyright (C) 2019 Netronome Systems, Inc. */
  3/* Copyright (C) 2020 Facebook, Inc. */
  4#include <ctype.h>
  5#include <stdlib.h>
  6#include <string.h>
  7#include <errno.h>
  8#include <bpf/bpf.h>
  9#include <bpf/libbpf.h>
 10#include "test_progs.h"
 11#include "testing_helpers.h"
 12#include <linux/membarrier.h>
 13
 14int parse_num_list(const char *s, bool **num_set, int *num_set_len)
 15{
 16	int i, set_len = 0, new_len, num, start = 0, end = -1;
 17	bool *set = NULL, *tmp, parsing_end = false;
 18	char *next;
 19
 20	while (s[0]) {
 21		errno = 0;
 22		num = strtol(s, &next, 10);
 23		if (errno)
 24			return -errno;
 25
 26		if (parsing_end)
 27			end = num;
 28		else
 29			start = num;
 30
 31		if (!parsing_end && *next == '-') {
 32			s = next + 1;
 33			parsing_end = true;
 34			continue;
 35		} else if (*next == ',') {
 36			parsing_end = false;
 37			s = next + 1;
 38			end = num;
 39		} else if (*next == '\0') {
 40			parsing_end = false;
 41			s = next;
 42			end = num;
 43		} else {
 44			return -EINVAL;
 45		}
 46
 47		if (start > end)
 48			return -EINVAL;
 49
 50		if (end + 1 > set_len) {
 51			new_len = end + 1;
 52			tmp = realloc(set, new_len);
 53			if (!tmp) {
 54				free(set);
 55				return -ENOMEM;
 56			}
 57			for (i = set_len; i < start; i++)
 58				tmp[i] = false;
 59			set = tmp;
 60			set_len = new_len;
 61		}
 62		for (i = start; i <= end; i++)
 63			set[i] = true;
 64	}
 65
 66	if (!set || parsing_end)
 67		return -EINVAL;
 68
 69	*num_set = set;
 70	*num_set_len = set_len;
 71
 72	return 0;
 73}
 74
 75static int do_insert_test(struct test_filter_set *set,
 76			  char *test_str,
 77			  char *subtest_str)
 78{
 79	struct test_filter *tmp, *test;
 80	char **ctmp;
 81	int i;
 82
 83	for (i = 0; i < set->cnt; i++) {
 84		test = &set->tests[i];
 85
 86		if (strcmp(test_str, test->name) == 0) {
 87			free(test_str);
 88			goto subtest;
 89		}
 90	}
 91
 92	tmp = realloc(set->tests, sizeof(*test) * (set->cnt + 1));
 93	if (!tmp)
 94		return -ENOMEM;
 95
 96	set->tests = tmp;
 97	test = &set->tests[set->cnt];
 98
 99	test->name = test_str;
100	test->subtests = NULL;
101	test->subtest_cnt = 0;
102
103	set->cnt++;
104
105subtest:
106	if (!subtest_str)
107		return 0;
108
109	for (i = 0; i < test->subtest_cnt; i++) {
110		if (strcmp(subtest_str, test->subtests[i]) == 0) {
111			free(subtest_str);
112			return 0;
113		}
114	}
115
116	ctmp = realloc(test->subtests,
117		       sizeof(*test->subtests) * (test->subtest_cnt + 1));
118	if (!ctmp)
119		return -ENOMEM;
120
121	test->subtests = ctmp;
122	test->subtests[test->subtest_cnt] = subtest_str;
123
124	test->subtest_cnt++;
125
126	return 0;
127}
128
129static int insert_test(struct test_filter_set *set,
130		       char *test_spec,
131		       bool is_glob_pattern)
132{
133	char *pattern, *subtest_str, *ext_test_str, *ext_subtest_str = NULL;
134	int glob_chars = 0;
135
136	if (is_glob_pattern) {
137		pattern = "%s";
138	} else {
139		pattern = "*%s*";
140		glob_chars = 2;
141	}
142
143	subtest_str = strchr(test_spec, '/');
144	if (subtest_str) {
145		*subtest_str = '\0';
146		subtest_str += 1;
147	}
148
149	ext_test_str = malloc(strlen(test_spec) + glob_chars + 1);
150	if (!ext_test_str)
151		goto err;
152
153	sprintf(ext_test_str, pattern, test_spec);
154
155	if (subtest_str) {
156		ext_subtest_str = malloc(strlen(subtest_str) + glob_chars + 1);
157		if (!ext_subtest_str)
158			goto err;
159
160		sprintf(ext_subtest_str, pattern, subtest_str);
161	}
162
163	return do_insert_test(set, ext_test_str, ext_subtest_str);
164
165err:
166	free(ext_test_str);
167	free(ext_subtest_str);
168
169	return -ENOMEM;
170}
171
172int parse_test_list_file(const char *path,
173			 struct test_filter_set *set,
174			 bool is_glob_pattern)
175{
176	char *buf = NULL, *capture_start, *capture_end, *scan_end;
177	size_t buflen = 0;
178	int err = 0;
179	FILE *f;
180
181	f = fopen(path, "r");
182	if (!f) {
183		err = -errno;
184		fprintf(stderr, "Failed to open '%s': %d\n", path, err);
185		return err;
186	}
187
188	while (getline(&buf, &buflen, f) != -1) {
189		capture_start = buf;
190
191		while (isspace(*capture_start))
192			++capture_start;
193
194		capture_end = capture_start;
195		scan_end = capture_start;
196
197		while (*scan_end && *scan_end != '#') {
198			if (!isspace(*scan_end))
199				capture_end = scan_end;
200
201			++scan_end;
202		}
203
204		if (capture_end == capture_start)
205			continue;
206
207		*(++capture_end) = '\0';
208
209		err = insert_test(set, capture_start, is_glob_pattern);
210		if (err)
211			break;
212	}
213
214	fclose(f);
215	return err;
216}
217
218int parse_test_list(const char *s,
219		    struct test_filter_set *set,
220		    bool is_glob_pattern)
221{
222	char *input, *state = NULL, *test_spec;
223	int err = 0;
224
225	input = strdup(s);
226	if (!input)
227		return -ENOMEM;
228
229	while ((test_spec = strtok_r(state ? NULL : input, ",", &state))) {
230		err = insert_test(set, test_spec, is_glob_pattern);
231		if (err)
232			break;
233	}
234
235	free(input);
236	return err;
237}
238
239__u32 link_info_prog_id(const struct bpf_link *link, struct bpf_link_info *info)
240{
241	__u32 info_len = sizeof(*info);
242	int err;
243
244	memset(info, 0, sizeof(*info));
245	err = bpf_link_get_info_by_fd(bpf_link__fd(link), info, &info_len);
246	if (err) {
247		printf("failed to get link info: %d\n", -errno);
248		return 0;
249	}
250	return info->prog_id;
251}
252
253int extra_prog_load_log_flags = 0;
254
255int bpf_prog_test_load(const char *file, enum bpf_prog_type type,
256		       struct bpf_object **pobj, int *prog_fd)
257{
258	LIBBPF_OPTS(bpf_object_open_opts, opts,
259		.kernel_log_level = extra_prog_load_log_flags,
260	);
261	struct bpf_object *obj;
262	struct bpf_program *prog;
263	__u32 flags;
264	int err;
265
266	obj = bpf_object__open_file(file, &opts);
267	if (!obj)
268		return -errno;
269
270	prog = bpf_object__next_program(obj, NULL);
271	if (!prog) {
272		err = -ENOENT;
273		goto err_out;
274	}
275
276	if (type != BPF_PROG_TYPE_UNSPEC && bpf_program__type(prog) != type)
277		bpf_program__set_type(prog, type);
278
279	flags = bpf_program__flags(prog) | BPF_F_TEST_RND_HI32 | BPF_F_TEST_REG_INVARIANTS;
280	bpf_program__set_flags(prog, flags);
281
282	err = bpf_object__load(obj);
283	if (err)
284		goto err_out;
285
286	*pobj = obj;
287	*prog_fd = bpf_program__fd(prog);
288
289	return 0;
290err_out:
291	bpf_object__close(obj);
292	return err;
293}
294
295int bpf_test_load_program(enum bpf_prog_type type, const struct bpf_insn *insns,
296			  size_t insns_cnt, const char *license,
297			  __u32 kern_version, char *log_buf,
298			  size_t log_buf_sz)
299{
300	LIBBPF_OPTS(bpf_prog_load_opts, opts,
301		.kern_version = kern_version,
302		.prog_flags = BPF_F_TEST_RND_HI32 | BPF_F_TEST_REG_INVARIANTS,
303		.log_level = extra_prog_load_log_flags,
304		.log_buf = log_buf,
305		.log_size = log_buf_sz,
306	);
307
308	return bpf_prog_load(type, NULL, license, insns, insns_cnt, &opts);
309}
310
311__u64 read_perf_max_sample_freq(void)
312{
313	__u64 sample_freq = 5000; /* fallback to 5000 on error */
314	FILE *f;
315
316	f = fopen("/proc/sys/kernel/perf_event_max_sample_rate", "r");
317	if (f == NULL) {
318		printf("Failed to open /proc/sys/kernel/perf_event_max_sample_rate: err %d\n"
319		       "return default value: 5000\n", -errno);
320		return sample_freq;
321	}
322	if (fscanf(f, "%llu", &sample_freq) != 1) {
323		printf("Failed to parse /proc/sys/kernel/perf_event_max_sample_rate: err %d\n"
324		       "return default value: 5000\n", -errno);
325	}
326
327	fclose(f);
328	return sample_freq;
329}
330
331static int finit_module(int fd, const char *param_values, int flags)
332{
333	return syscall(__NR_finit_module, fd, param_values, flags);
334}
335
336static int delete_module(const char *name, int flags)
337{
338	return syscall(__NR_delete_module, name, flags);
339}
340
341int unload_bpf_testmod(bool verbose)
342{
343	if (kern_sync_rcu())
344		fprintf(stdout, "Failed to trigger kernel-side RCU sync!\n");
345	if (delete_module("bpf_testmod", 0)) {
346		if (errno == ENOENT) {
347			if (verbose)
348				fprintf(stdout, "bpf_testmod.ko is already unloaded.\n");
349			return -1;
350		}
351		fprintf(stdout, "Failed to unload bpf_testmod.ko from kernel: %d\n", -errno);
352		return -1;
353	}
354	if (verbose)
355		fprintf(stdout, "Successfully unloaded bpf_testmod.ko.\n");
356	return 0;
357}
358
359int load_bpf_testmod(bool verbose)
360{
361	int fd;
362
363	if (verbose)
364		fprintf(stdout, "Loading bpf_testmod.ko...\n");
365
366	fd = open("bpf_testmod.ko", O_RDONLY);
367	if (fd < 0) {
368		fprintf(stdout, "Can't find bpf_testmod.ko kernel module: %d\n", -errno);
369		return -ENOENT;
370	}
371	if (finit_module(fd, "", 0)) {
372		fprintf(stdout, "Failed to load bpf_testmod.ko into the kernel: %d\n", -errno);
373		close(fd);
374		return -EINVAL;
375	}
376	close(fd);
377
378	if (verbose)
379		fprintf(stdout, "Successfully loaded bpf_testmod.ko.\n");
380	return 0;
381}
382
383/*
384 * Trigger synchronize_rcu() in kernel.
385 */
386int kern_sync_rcu(void)
387{
388	return syscall(__NR_membarrier, MEMBARRIER_CMD_SHARED, 0, 0);
389}