1 // SPDX-License-Identifier: GPL-2.0
2 
3 #include <limits.h>
4 #include <stdio.h>
5 #include <string.h>
6 #include <ctype.h>
7 #include <regex.h>
8 #include <test_progs.h>
9 
10 #include "bpf/btf.h"
11 #include "bpf_util.h"
12 #include "linux/filter.h"
13 #include "linux/kernel.h"
14 #include "disasm_helpers.h"
15 
16 #define MAX_PROG_TEXT_SZ (32 * 1024)
17 
18 /* The code in this file serves the sole purpose of executing test cases
19  * specified in the test_cases array. Each test case specifies a program
20  * type, context field offset, and disassembly patterns that correspond
21  * to read and write instructions generated by
22  * verifier.c:convert_ctx_access() for accessing that field.
23  *
24  * For each test case, up to three programs are created:
25  * - One that uses BPF_LDX_MEM to read the context field.
26  * - One that uses BPF_STX_MEM to write to the context field.
27  * - One that uses BPF_ST_MEM to write to the context field.
28  *
29  * The disassembly of each program is then compared with the pattern
30  * specified in the test case.
31  */
32 struct test_case {
33 	char *name;
34 	enum bpf_prog_type prog_type;
35 	enum bpf_attach_type expected_attach_type;
36 	int field_offset;
37 	int field_sz;
38 	/* Program generated for BPF_ST_MEM uses value 42 by default,
39 	 * this field allows to specify custom value.
40 	 */
41 	struct {
42 		bool use;
43 		int value;
44 	} st_value;
45 	/* Pattern for BPF_LDX_MEM(field_sz, dst, ctx, field_offset) */
46 	char *read;
47 	/* Pattern for BPF_STX_MEM(field_sz, ctx, src, field_offset) and
48 	 *             BPF_ST_MEM (field_sz, ctx, src, field_offset)
49 	 */
50 	char *write;
51 	/* Pattern for BPF_ST_MEM(field_sz, ctx, src, field_offset),
52 	 * takes priority over `write`.
53 	 */
54 	char *write_st;
55 	/* Pattern for BPF_STX_MEM (field_sz, ctx, src, field_offset),
56 	 * takes priority over `write`.
57 	 */
58 	char *write_stx;
59 };
60 
61 #define N(_prog_type, type, field, name_extra...)	\
62 	.name = #_prog_type "." #field name_extra,	\
63 	.prog_type = BPF_PROG_TYPE_##_prog_type,	\
64 	.field_offset = offsetof(type, field),		\
65 	.field_sz = sizeof(typeof(((type *)NULL)->field))
66 
67 static struct test_case test_cases[] = {
68 /* Sign extension on s390 changes the pattern */
69 #if defined(__x86_64__) || defined(__aarch64__)
70 	{
71 		N(SCHED_CLS, struct __sk_buff, tstamp),
72 		.read  = "r11 = *(u8 *)($ctx + sk_buff::__mono_tc_offset);"
73 			 "if w11 & 0x4 goto pc+1;"
74 			 "goto pc+4;"
75 			 "if w11 & 0x3 goto pc+1;"
76 			 "goto pc+2;"
77 			 "$dst = 0;"
78 			 "goto pc+1;"
79 			 "$dst = *(u64 *)($ctx + sk_buff::tstamp);",
80 		.write = "r11 = *(u8 *)($ctx + sk_buff::__mono_tc_offset);"
81 			 "if w11 & 0x4 goto pc+1;"
82 			 "goto pc+2;"
83 			 "w11 &= -4;"
84 			 "*(u8 *)($ctx + sk_buff::__mono_tc_offset) = r11;"
85 			 "*(u64 *)($ctx + sk_buff::tstamp) = $src;",
86 	},
87 #endif
88 	{
89 		N(SCHED_CLS, struct __sk_buff, priority),
90 		.read  = "$dst = *(u32 *)($ctx + sk_buff::priority);",
91 		.write = "*(u32 *)($ctx + sk_buff::priority) = $src;",
92 	},
93 	{
94 		N(SCHED_CLS, struct __sk_buff, mark),
95 		.read  = "$dst = *(u32 *)($ctx + sk_buff::mark);",
96 		.write = "*(u32 *)($ctx + sk_buff::mark) = $src;",
97 	},
98 	{
99 		N(SCHED_CLS, struct __sk_buff, cb[0]),
100 		.read  = "$dst = *(u32 *)($ctx + $(sk_buff::cb + qdisc_skb_cb::data));",
101 		.write = "*(u32 *)($ctx + $(sk_buff::cb + qdisc_skb_cb::data)) = $src;",
102 	},
103 	{
104 		N(SCHED_CLS, struct __sk_buff, tc_classid),
105 		.read  = "$dst = *(u16 *)($ctx + $(sk_buff::cb + qdisc_skb_cb::tc_classid));",
106 		.write = "*(u16 *)($ctx + $(sk_buff::cb + qdisc_skb_cb::tc_classid)) = $src;",
107 	},
108 	{
109 		N(SCHED_CLS, struct __sk_buff, tc_index),
110 		.read  = "$dst = *(u16 *)($ctx + sk_buff::tc_index);",
111 		.write = "*(u16 *)($ctx + sk_buff::tc_index) = $src;",
112 	},
113 	{
114 		N(SCHED_CLS, struct __sk_buff, queue_mapping),
115 		.read      = "$dst = *(u16 *)($ctx + sk_buff::queue_mapping);",
116 		.write_stx = "if $src >= 0xffff goto pc+1;"
117 			     "*(u16 *)($ctx + sk_buff::queue_mapping) = $src;",
118 		.write_st  = "*(u16 *)($ctx + sk_buff::queue_mapping) = $src;",
119 	},
120 	{
121 		/* This is a corner case in filter.c:bpf_convert_ctx_access() */
122 		N(SCHED_CLS, struct __sk_buff, queue_mapping, ".ushrt_max"),
123 		.st_value = { true, USHRT_MAX },
124 		.write_st = "goto pc+0;",
125 	},
126 	{
127 		N(CGROUP_SOCK, struct bpf_sock, bound_dev_if),
128 		.read  = "$dst = *(u32 *)($ctx + sock_common::skc_bound_dev_if);",
129 		.write = "*(u32 *)($ctx + sock_common::skc_bound_dev_if) = $src;",
130 	},
131 	{
132 		N(CGROUP_SOCK, struct bpf_sock, mark),
133 		.read  = "$dst = *(u32 *)($ctx + sock::sk_mark);",
134 		.write = "*(u32 *)($ctx + sock::sk_mark) = $src;",
135 	},
136 	{
137 		N(CGROUP_SOCK, struct bpf_sock, priority),
138 		.read  = "$dst = *(u32 *)($ctx + sock::sk_priority);",
139 		.write = "*(u32 *)($ctx + sock::sk_priority) = $src;",
140 	},
141 	{
142 		N(SOCK_OPS, struct bpf_sock_ops, replylong[0]),
143 		.read  = "$dst = *(u32 *)($ctx + bpf_sock_ops_kern::replylong);",
144 		.write = "*(u32 *)($ctx + bpf_sock_ops_kern::replylong) = $src;",
145 	},
146 	{
147 		N(CGROUP_SYSCTL, struct bpf_sysctl, file_pos),
148 #if __BYTE_ORDER == __LITTLE_ENDIAN
149 		.read  = "$dst = *(u64 *)($ctx + bpf_sysctl_kern::ppos);"
150 			 "$dst = *(u32 *)($dst +0);",
151 		.write = "*(u64 *)($ctx + bpf_sysctl_kern::tmp_reg) = r9;"
152 			 "r9 = *(u64 *)($ctx + bpf_sysctl_kern::ppos);"
153 			 "*(u32 *)(r9 +0) = $src;"
154 			 "r9 = *(u64 *)($ctx + bpf_sysctl_kern::tmp_reg);",
155 #else
156 		.read  = "$dst = *(u64 *)($ctx + bpf_sysctl_kern::ppos);"
157 			 "$dst = *(u32 *)($dst +4);",
158 		.write = "*(u64 *)($ctx + bpf_sysctl_kern::tmp_reg) = r9;"
159 			 "r9 = *(u64 *)($ctx + bpf_sysctl_kern::ppos);"
160 			 "*(u32 *)(r9 +4) = $src;"
161 			 "r9 = *(u64 *)($ctx + bpf_sysctl_kern::tmp_reg);",
162 #endif
163 	},
164 	{
165 		N(CGROUP_SOCKOPT, struct bpf_sockopt, sk),
166 		.read  = "$dst = *(u64 *)($ctx + bpf_sockopt_kern::sk);",
167 		.expected_attach_type = BPF_CGROUP_GETSOCKOPT,
168 	},
169 	{
170 		N(CGROUP_SOCKOPT, struct bpf_sockopt, level),
171 		.read  = "$dst = *(u32 *)($ctx + bpf_sockopt_kern::level);",
172 		.write = "*(u32 *)($ctx + bpf_sockopt_kern::level) = $src;",
173 		.expected_attach_type = BPF_CGROUP_SETSOCKOPT,
174 	},
175 	{
176 		N(CGROUP_SOCKOPT, struct bpf_sockopt, optname),
177 		.read  = "$dst = *(u32 *)($ctx + bpf_sockopt_kern::optname);",
178 		.write = "*(u32 *)($ctx + bpf_sockopt_kern::optname) = $src;",
179 		.expected_attach_type = BPF_CGROUP_SETSOCKOPT,
180 	},
181 	{
182 		N(CGROUP_SOCKOPT, struct bpf_sockopt, optlen),
183 		.read  = "$dst = *(u32 *)($ctx + bpf_sockopt_kern::optlen);",
184 		.write = "*(u32 *)($ctx + bpf_sockopt_kern::optlen) = $src;",
185 		.expected_attach_type = BPF_CGROUP_SETSOCKOPT,
186 	},
187 	{
188 		N(CGROUP_SOCKOPT, struct bpf_sockopt, retval),
189 		.read  = "$dst = *(u64 *)($ctx + bpf_sockopt_kern::current_task);"
190 			 "$dst = *(u64 *)($dst + task_struct::bpf_ctx);"
191 			 "$dst = *(u32 *)($dst + bpf_cg_run_ctx::retval);",
192 		.write = "*(u64 *)($ctx + bpf_sockopt_kern::tmp_reg) = r9;"
193 			 "r9 = *(u64 *)($ctx + bpf_sockopt_kern::current_task);"
194 			 "r9 = *(u64 *)(r9 + task_struct::bpf_ctx);"
195 			 "*(u32 *)(r9 + bpf_cg_run_ctx::retval) = $src;"
196 			 "r9 = *(u64 *)($ctx + bpf_sockopt_kern::tmp_reg);",
197 		.expected_attach_type = BPF_CGROUP_GETSOCKOPT,
198 	},
199 	{
200 		N(CGROUP_SOCKOPT, struct bpf_sockopt, optval),
201 		.read  = "$dst = *(u64 *)($ctx + bpf_sockopt_kern::optval);",
202 		.expected_attach_type = BPF_CGROUP_GETSOCKOPT,
203 	},
204 	{
205 		N(CGROUP_SOCKOPT, struct bpf_sockopt, optval_end),
206 		.read  = "$dst = *(u64 *)($ctx + bpf_sockopt_kern::optval_end);",
207 		.expected_attach_type = BPF_CGROUP_GETSOCKOPT,
208 	},
209 };
210 
211 #undef N
212 
213 static regex_t *ident_regex;
214 static regex_t *field_regex;
215 
skip_space(char * str)216 static char *skip_space(char *str)
217 {
218 	while (*str && isspace(*str))
219 		++str;
220 	return str;
221 }
222 
skip_space_and_semi(char * str)223 static char *skip_space_and_semi(char *str)
224 {
225 	while (*str && (isspace(*str) || *str == ';'))
226 		++str;
227 	return str;
228 }
229 
match_str(char * str,char * prefix)230 static char *match_str(char *str, char *prefix)
231 {
232 	while (*str && *prefix && *str == *prefix) {
233 		++str;
234 		++prefix;
235 	}
236 	if (*prefix)
237 		return NULL;
238 	return str;
239 }
240 
match_number(char * str,int num)241 static char *match_number(char *str, int num)
242 {
243 	char *next;
244 	int snum = strtol(str, &next, 10);
245 
246 	if (next - str == 0 || num != snum)
247 		return NULL;
248 
249 	return next;
250 }
251 
find_field_offset_aux(struct btf * btf,int btf_id,char * field_name,int off)252 static int find_field_offset_aux(struct btf *btf, int btf_id, char *field_name, int off)
253 {
254 	const struct btf_type *type = btf__type_by_id(btf, btf_id);
255 	const struct btf_member *m;
256 	__u16 mnum;
257 	int i;
258 
259 	if (!type) {
260 		PRINT_FAIL("Can't find btf_type for id %d\n", btf_id);
261 		return -1;
262 	}
263 
264 	if (!btf_is_struct(type) && !btf_is_union(type)) {
265 		PRINT_FAIL("BTF id %d is not struct or union\n", btf_id);
266 		return -1;
267 	}
268 
269 	m = btf_members(type);
270 	mnum = btf_vlen(type);
271 
272 	for (i = 0; i < mnum; ++i, ++m) {
273 		const char *mname = btf__name_by_offset(btf, m->name_off);
274 
275 		if (strcmp(mname, "") == 0) {
276 			int msize = find_field_offset_aux(btf, m->type, field_name,
277 							  off + m->offset);
278 			if (msize >= 0)
279 				return msize;
280 		}
281 
282 		if (strcmp(mname, field_name))
283 			continue;
284 
285 		return (off + m->offset) / 8;
286 	}
287 
288 	return -1;
289 }
290 
find_field_offset(struct btf * btf,char * pattern,regmatch_t * matches)291 static int find_field_offset(struct btf *btf, char *pattern, regmatch_t *matches)
292 {
293 	int type_sz  = matches[1].rm_eo - matches[1].rm_so;
294 	int field_sz = matches[2].rm_eo - matches[2].rm_so;
295 	char *type   = pattern + matches[1].rm_so;
296 	char *field  = pattern + matches[2].rm_so;
297 	char field_str[128] = {};
298 	char type_str[128] = {};
299 	int btf_id, field_offset;
300 
301 	if (type_sz >= sizeof(type_str)) {
302 		PRINT_FAIL("Malformed pattern: type ident is too long: %d\n", type_sz);
303 		return -1;
304 	}
305 
306 	if (field_sz >= sizeof(field_str)) {
307 		PRINT_FAIL("Malformed pattern: field ident is too long: %d\n", field_sz);
308 		return -1;
309 	}
310 
311 	strncpy(type_str, type, type_sz);
312 	strncpy(field_str, field, field_sz);
313 	btf_id = btf__find_by_name(btf, type_str);
314 	if (btf_id < 0) {
315 		PRINT_FAIL("No BTF info for type %s\n", type_str);
316 		return -1;
317 	}
318 
319 	field_offset = find_field_offset_aux(btf, btf_id, field_str, 0);
320 	if (field_offset < 0) {
321 		PRINT_FAIL("No BTF info for field %s::%s\n", type_str, field_str);
322 		return -1;
323 	}
324 
325 	return field_offset;
326 }
327 
compile_regex(char * pat)328 static regex_t *compile_regex(char *pat)
329 {
330 	regex_t *re;
331 	int err;
332 
333 	re = malloc(sizeof(regex_t));
334 	if (!re) {
335 		PRINT_FAIL("Can't alloc regex\n");
336 		return NULL;
337 	}
338 
339 	err = regcomp(re, pat, REG_EXTENDED);
340 	if (err) {
341 		char errbuf[512];
342 
343 		regerror(err, re, errbuf, sizeof(errbuf));
344 		PRINT_FAIL("Can't compile regex: %s\n", errbuf);
345 		free(re);
346 		return NULL;
347 	}
348 
349 	return re;
350 }
351 
free_regex(regex_t * re)352 static void free_regex(regex_t *re)
353 {
354 	if (!re)
355 		return;
356 
357 	regfree(re);
358 	free(re);
359 }
360 
max_line_len(char * str)361 static u32 max_line_len(char *str)
362 {
363 	u32 max_line = 0;
364 	char *next = str;
365 
366 	while (next) {
367 		next = strchr(str, '\n');
368 		if (next) {
369 			max_line = max_t(u32, max_line, (next - str));
370 			str = next + 1;
371 		} else {
372 			max_line = max_t(u32, max_line, strlen(str));
373 		}
374 	}
375 
376 	return min(max_line, 60u);
377 }
378 
379 /* Print strings `pattern_origin` and `text_origin` side by side,
380  * assume `pattern_pos` and `text_pos` designate location within
381  * corresponding origin string where match diverges.
382  * The output should look like:
383  *
384  *   Can't match disassembly(left) with pattern(right):
385  *   r2 = *(u64 *)(r1 +0)  ;  $dst = *(u64 *)($ctx + bpf_sockopt_kern::sk1)
386  *                     ^                             ^
387  *   r0 = 0                ;
388  *   exit                  ;
389  */
print_match_error(FILE * out,char * pattern_origin,char * text_origin,char * pattern_pos,char * text_pos)390 static void print_match_error(FILE *out,
391 			      char *pattern_origin, char *text_origin,
392 			      char *pattern_pos, char *text_pos)
393 {
394 	char *pattern = pattern_origin;
395 	char *text = text_origin;
396 	int middle = max_line_len(text) + 2;
397 
398 	fprintf(out, "Can't match disassembly(left) with pattern(right):\n");
399 	while (*pattern || *text) {
400 		int column = 0;
401 		int mark1 = -1;
402 		int mark2 = -1;
403 
404 		/* Print one line from text */
405 		while (*text && *text != '\n') {
406 			if (text == text_pos)
407 				mark1 = column;
408 			fputc(*text, out);
409 			++text;
410 			++column;
411 		}
412 		if (text == text_pos)
413 			mark1 = column;
414 
415 		/* Pad to the middle */
416 		while (column < middle) {
417 			fputc(' ', out);
418 			++column;
419 		}
420 		fputs(";  ", out);
421 		column += 3;
422 
423 		/* Print one line from pattern, pattern lines are terminated by ';' */
424 		while (*pattern && *pattern != ';') {
425 			if (pattern == pattern_pos)
426 				mark2 = column;
427 			fputc(*pattern, out);
428 			++pattern;
429 			++column;
430 		}
431 		if (pattern == pattern_pos)
432 			mark2 = column;
433 
434 		fputc('\n', out);
435 		if (*pattern)
436 			++pattern;
437 		if (*text)
438 			++text;
439 
440 		/* If pattern and text diverge at this line, print an
441 		 * additional line with '^' marks, highlighting
442 		 * positions where match fails.
443 		 */
444 		if (mark1 > 0 || mark2 > 0) {
445 			for (column = 0; column <= max(mark1, mark2); ++column) {
446 				if (column == mark1 || column == mark2)
447 					fputc('^', out);
448 				else
449 					fputc(' ', out);
450 			}
451 			fputc('\n', out);
452 		}
453 	}
454 }
455 
456 /* Test if `text` matches `pattern`. Pattern consists of the following elements:
457  *
458  * - Field offset references:
459  *
460  *     <type>::<field>
461  *
462  *   When such reference is encountered BTF is used to compute numerical
463  *   value for the offset of <field> in <type>. The `text` is expected to
464  *   contain matching numerical value.
465  *
466  * - Field groups:
467  *
468  *     $(<type>::<field> [+ <type>::<field>]*)
469  *
470  *   Allows to specify an offset that is a sum of multiple field offsets.
471  *   The `text` is expected to contain matching numerical value.
472  *
473  * - Variable references, e.g. `$src`, `$dst`, `$ctx`.
474  *   These are substitutions specified in `reg_map` array.
475  *   If a substring of pattern is equal to `reg_map[i][0]` the `text` is
476  *   expected to contain `reg_map[i][1]` in the matching position.
477  *
478  * - Whitespace is ignored, ';' counts as whitespace for `pattern`.
479  *
480  * - Any other characters, `pattern` and `text` should match one-to-one.
481  *
482  * Example of a pattern:
483  *
484  *                    __________ fields group ________________
485  *                   '                                        '
486  *   *(u16 *)($ctx + $(sk_buff::cb + qdisc_skb_cb::tc_classid)) = $src;
487  *            ^^^^                   '______________________'
488  *     variable reference             field offset reference
489  */
match_pattern(struct btf * btf,char * pattern,char * text,char * reg_map[][2])490 static bool match_pattern(struct btf *btf, char *pattern, char *text, char *reg_map[][2])
491 {
492 	char *pattern_origin = pattern;
493 	char *text_origin = text;
494 	regmatch_t matches[3];
495 
496 _continue:
497 	while (*pattern) {
498 		if (!*text)
499 			goto err;
500 
501 		/* Skip whitespace */
502 		if (isspace(*pattern) || *pattern == ';') {
503 			if (!isspace(*text) && text != text_origin && isalnum(text[-1]))
504 				goto err;
505 			pattern = skip_space_and_semi(pattern);
506 			text = skip_space(text);
507 			continue;
508 		}
509 
510 		/* Check for variable references */
511 		for (int i = 0; reg_map[i][0]; ++i) {
512 			char *pattern_next, *text_next;
513 
514 			pattern_next = match_str(pattern, reg_map[i][0]);
515 			if (!pattern_next)
516 				continue;
517 
518 			text_next = match_str(text, reg_map[i][1]);
519 			if (!text_next)
520 				goto err;
521 
522 			pattern = pattern_next;
523 			text = text_next;
524 			goto _continue;
525 		}
526 
527 		/* Match field group:
528 		 *   $(sk_buff::cb + qdisc_skb_cb::tc_classid)
529 		 */
530 		if (strncmp(pattern, "$(", 2) == 0) {
531 			char *group_start = pattern, *text_next;
532 			int acc_offset = 0;
533 
534 			pattern += 2;
535 
536 			for (;;) {
537 				int field_offset;
538 
539 				pattern = skip_space(pattern);
540 				if (!*pattern) {
541 					PRINT_FAIL("Unexpected end of pattern\n");
542 					goto err;
543 				}
544 
545 				if (*pattern == ')') {
546 					++pattern;
547 					break;
548 				}
549 
550 				if (*pattern == '+') {
551 					++pattern;
552 					continue;
553 				}
554 
555 				printf("pattern: %s\n", pattern);
556 				if (regexec(field_regex, pattern, 3, matches, 0) != 0) {
557 					PRINT_FAIL("Field reference expected\n");
558 					goto err;
559 				}
560 
561 				field_offset = find_field_offset(btf, pattern, matches);
562 				if (field_offset < 0)
563 					goto err;
564 
565 				pattern += matches[0].rm_eo;
566 				acc_offset += field_offset;
567 			}
568 
569 			text_next = match_number(text, acc_offset);
570 			if (!text_next) {
571 				PRINT_FAIL("No match for group offset %.*s (%d)\n",
572 					   (int)(pattern - group_start),
573 					   group_start,
574 					   acc_offset);
575 				goto err;
576 			}
577 			text = text_next;
578 		}
579 
580 		/* Match field reference:
581 		 *   sk_buff::cb
582 		 */
583 		if (regexec(field_regex, pattern, 3, matches, 0) == 0) {
584 			int field_offset;
585 			char *text_next;
586 
587 			field_offset = find_field_offset(btf, pattern, matches);
588 			if (field_offset < 0)
589 				goto err;
590 
591 			text_next = match_number(text, field_offset);
592 			if (!text_next) {
593 				PRINT_FAIL("No match for field offset %.*s (%d)\n",
594 					   (int)matches[0].rm_eo, pattern, field_offset);
595 				goto err;
596 			}
597 
598 			pattern += matches[0].rm_eo;
599 			text = text_next;
600 			continue;
601 		}
602 
603 		/* If pattern points to identifier not followed by '::'
604 		 * skip the identifier to avoid n^2 application of the
605 		 * field reference rule.
606 		 */
607 		if (regexec(ident_regex, pattern, 1, matches, 0) == 0) {
608 			if (strncmp(pattern, text, matches[0].rm_eo) != 0)
609 				goto err;
610 
611 			pattern += matches[0].rm_eo;
612 			text += matches[0].rm_eo;
613 			continue;
614 		}
615 
616 		/* Match literally */
617 		if (*pattern != *text)
618 			goto err;
619 
620 		++pattern;
621 		++text;
622 	}
623 
624 	return true;
625 
626 err:
627 	test__fail();
628 	print_match_error(stdout, pattern_origin, text_origin, pattern, text);
629 	return false;
630 }
631 
632 struct prog_info {
633 	char *prog_kind;
634 	enum bpf_prog_type prog_type;
635 	enum bpf_attach_type expected_attach_type;
636 	struct bpf_insn *prog;
637 	u32 prog_len;
638 };
639 
match_program(struct btf * btf,struct prog_info * pinfo,char * pattern,char * reg_map[][2],bool skip_first_insn)640 static void match_program(struct btf *btf,
641 			  struct prog_info *pinfo,
642 			  char *pattern,
643 			  char *reg_map[][2],
644 			  bool skip_first_insn)
645 {
646 	struct bpf_insn *buf = NULL, *insn, *insn_end;
647 	int err = 0, prog_fd = 0;
648 	FILE *prog_out = NULL;
649 	char insn_buf[64];
650 	char *text = NULL;
651 	__u32 cnt = 0;
652 
653 	text = calloc(MAX_PROG_TEXT_SZ, 1);
654 	if (!text) {
655 		PRINT_FAIL("Can't allocate %d bytes\n", MAX_PROG_TEXT_SZ);
656 		goto out;
657 	}
658 
659 	// TODO: log level
660 	LIBBPF_OPTS(bpf_prog_load_opts, opts);
661 	opts.log_buf = text;
662 	opts.log_size = MAX_PROG_TEXT_SZ;
663 	opts.log_level = 1 | 2 | 4;
664 	opts.expected_attach_type = pinfo->expected_attach_type;
665 
666 	prog_fd = bpf_prog_load(pinfo->prog_type, NULL, "GPL",
667 				pinfo->prog, pinfo->prog_len, &opts);
668 	if (prog_fd < 0) {
669 		PRINT_FAIL("Can't load program, errno %d (%s), verifier log:\n%s\n",
670 			   errno, strerror(errno), text);
671 		goto out;
672 	}
673 
674 	memset(text, 0, MAX_PROG_TEXT_SZ);
675 
676 	err = get_xlated_program(prog_fd, &buf, &cnt);
677 	if (err) {
678 		PRINT_FAIL("Can't load back BPF program\n");
679 		goto out;
680 	}
681 
682 	prog_out = fmemopen(text, MAX_PROG_TEXT_SZ - 1, "w");
683 	if (!prog_out) {
684 		PRINT_FAIL("Can't open memory stream\n");
685 		goto out;
686 	}
687 	insn_end = buf + cnt;
688 	insn = buf + (skip_first_insn ? 1 : 0);
689 	while (insn < insn_end) {
690 		insn = disasm_insn(insn, insn_buf, sizeof(insn_buf));
691 		fprintf(prog_out, "%s\n", insn_buf);
692 	}
693 	fclose(prog_out);
694 
695 	ASSERT_TRUE(match_pattern(btf, pattern, text, reg_map),
696 		    pinfo->prog_kind);
697 
698 out:
699 	if (prog_fd)
700 		close(prog_fd);
701 	free(buf);
702 	free(text);
703 }
704 
run_one_testcase(struct btf * btf,struct test_case * test)705 static void run_one_testcase(struct btf *btf, struct test_case *test)
706 {
707 	struct prog_info pinfo = {};
708 	int bpf_sz;
709 
710 	if (!test__start_subtest(test->name))
711 		return;
712 
713 	switch (test->field_sz) {
714 	case 8:
715 		bpf_sz = BPF_DW;
716 		break;
717 	case 4:
718 		bpf_sz = BPF_W;
719 		break;
720 	case 2:
721 		bpf_sz = BPF_H;
722 		break;
723 	case 1:
724 		bpf_sz = BPF_B;
725 		break;
726 	default:
727 		PRINT_FAIL("Unexpected field size: %d, want 8,4,2 or 1\n", test->field_sz);
728 		return;
729 	}
730 
731 	pinfo.prog_type = test->prog_type;
732 	pinfo.expected_attach_type = test->expected_attach_type;
733 
734 	if (test->read) {
735 		struct bpf_insn ldx_prog[] = {
736 			BPF_LDX_MEM(bpf_sz, BPF_REG_2, BPF_REG_1, test->field_offset),
737 			BPF_MOV64_IMM(BPF_REG_0, 0),
738 			BPF_EXIT_INSN(),
739 		};
740 		char *reg_map[][2] = {
741 			{ "$ctx", "r1" },
742 			{ "$dst", "r2" },
743 			{}
744 		};
745 
746 		pinfo.prog_kind = "LDX";
747 		pinfo.prog = ldx_prog;
748 		pinfo.prog_len = ARRAY_SIZE(ldx_prog);
749 		match_program(btf, &pinfo, test->read, reg_map, false);
750 	}
751 
752 	if (test->write || test->write_st || test->write_stx) {
753 		struct bpf_insn stx_prog[] = {
754 			BPF_MOV64_IMM(BPF_REG_2, 0),
755 			BPF_STX_MEM(bpf_sz, BPF_REG_1, BPF_REG_2, test->field_offset),
756 			BPF_MOV64_IMM(BPF_REG_0, 0),
757 			BPF_EXIT_INSN(),
758 		};
759 		char *stx_reg_map[][2] = {
760 			{ "$ctx", "r1" },
761 			{ "$src", "r2" },
762 			{}
763 		};
764 		struct bpf_insn st_prog[] = {
765 			BPF_ST_MEM(bpf_sz, BPF_REG_1, test->field_offset,
766 				   test->st_value.use ? test->st_value.value : 42),
767 			BPF_MOV64_IMM(BPF_REG_0, 0),
768 			BPF_EXIT_INSN(),
769 		};
770 		char *st_reg_map[][2] = {
771 			{ "$ctx", "r1" },
772 			{ "$src", "42" },
773 			{}
774 		};
775 
776 		if (test->write || test->write_stx) {
777 			char *pattern = test->write_stx ? test->write_stx : test->write;
778 
779 			pinfo.prog_kind = "STX";
780 			pinfo.prog = stx_prog;
781 			pinfo.prog_len = ARRAY_SIZE(stx_prog);
782 			match_program(btf, &pinfo, pattern, stx_reg_map, true);
783 		}
784 
785 		if (test->write || test->write_st) {
786 			char *pattern = test->write_st ? test->write_st : test->write;
787 
788 			pinfo.prog_kind = "ST";
789 			pinfo.prog = st_prog;
790 			pinfo.prog_len = ARRAY_SIZE(st_prog);
791 			match_program(btf, &pinfo, pattern, st_reg_map, false);
792 		}
793 	}
794 
795 	test__end_subtest();
796 }
797 
test_ctx_rewrite(void)798 void test_ctx_rewrite(void)
799 {
800 	struct btf *btf;
801 	int i;
802 
803 	field_regex = compile_regex("^([[:alpha:]_][[:alnum:]_]+)::([[:alpha:]_][[:alnum:]_]+)");
804 	ident_regex = compile_regex("^[[:alpha:]_][[:alnum:]_]+");
805 	if (!field_regex || !ident_regex)
806 		return;
807 
808 	btf = btf__load_vmlinux_btf();
809 	if (!btf) {
810 		PRINT_FAIL("Can't load vmlinux BTF, errno %d (%s)\n", errno, strerror(errno));
811 		goto out;
812 	}
813 
814 	for (i = 0; i < ARRAY_SIZE(test_cases); ++i)
815 		run_one_testcase(btf, &test_cases[i]);
816 
817 out:
818 	btf__free(btf);
819 	free_regex(field_regex);
820 	free_regex(ident_regex);
821 }
822