1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2 /* Copyright (C) 2018 Netronome Systems, Inc. */
3 
4 #define _GNU_SOURCE
5 #include <stdarg.h>
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <sys/types.h>
10 #include <libbpf.h>
11 
12 #include "disasm.h"
13 #include "json_writer.h"
14 #include "main.h"
15 #include "xlated_dumper.h"
16 
17 static int kernel_syms_cmp(const void *sym_a, const void *sym_b)
18 {
19 	return ((struct kernel_sym *)sym_a)->address -
20 	       ((struct kernel_sym *)sym_b)->address;
21 }
22 
23 void kernel_syms_load(struct dump_data *dd)
24 {
25 	struct kernel_sym *sym;
26 	char buff[256];
27 	void *tmp, *address;
28 	FILE *fp;
29 
30 	fp = fopen("/proc/kallsyms", "r");
31 	if (!fp)
32 		return;
33 
34 	while (!feof(fp)) {
35 		if (!fgets(buff, sizeof(buff), fp))
36 			break;
37 		tmp = reallocarray(dd->sym_mapping, dd->sym_count + 1,
38 				   sizeof(*dd->sym_mapping));
39 		if (!tmp) {
40 out:
41 			free(dd->sym_mapping);
42 			dd->sym_mapping = NULL;
43 			fclose(fp);
44 			return;
45 		}
46 		dd->sym_mapping = tmp;
47 		sym = &dd->sym_mapping[dd->sym_count];
48 		if (sscanf(buff, "%p %*c %s", &address, sym->name) != 2)
49 			continue;
50 		sym->address = (unsigned long)address;
51 		if (!strcmp(sym->name, "__bpf_call_base")) {
52 			dd->address_call_base = sym->address;
53 			/* sysctl kernel.kptr_restrict was set */
54 			if (!sym->address)
55 				goto out;
56 		}
57 		if (sym->address)
58 			dd->sym_count++;
59 	}
60 
61 	fclose(fp);
62 
63 	qsort(dd->sym_mapping, dd->sym_count,
64 	      sizeof(*dd->sym_mapping), kernel_syms_cmp);
65 }
66 
67 void kernel_syms_destroy(struct dump_data *dd)
68 {
69 	free(dd->sym_mapping);
70 }
71 
72 struct kernel_sym *kernel_syms_search(struct dump_data *dd,
73 				      unsigned long key)
74 {
75 	struct kernel_sym sym = {
76 		.address = key,
77 	};
78 
79 	return dd->sym_mapping ?
80 	       bsearch(&sym, dd->sym_mapping, dd->sym_count,
81 		       sizeof(*dd->sym_mapping), kernel_syms_cmp) : NULL;
82 }
83 
84 static void __printf(2, 3) print_insn(void *private_data, const char *fmt, ...)
85 {
86 	va_list args;
87 
88 	va_start(args, fmt);
89 	vprintf(fmt, args);
90 	va_end(args);
91 }
92 
93 static void __printf(2, 3)
94 print_insn_for_graph(void *private_data, const char *fmt, ...)
95 {
96 	char buf[64], *p;
97 	va_list args;
98 
99 	va_start(args, fmt);
100 	vsnprintf(buf, sizeof(buf), fmt, args);
101 	va_end(args);
102 
103 	p = buf;
104 	while (*p != '\0') {
105 		if (*p == '\n') {
106 			memmove(p + 3, p, strlen(buf) + 1 - (p - buf));
107 			/* Align each instruction dump row left. */
108 			*p++ = '\\';
109 			*p++ = 'l';
110 			/* Output multiline concatenation. */
111 			*p++ = '\\';
112 		} else if (*p == '<' || *p == '>' || *p == '|' || *p == '&') {
113 			memmove(p + 1, p, strlen(buf) + 1 - (p - buf));
114 			/* Escape special character. */
115 			*p++ = '\\';
116 		}
117 
118 		p++;
119 	}
120 
121 	printf("%s", buf);
122 }
123 
124 static void __printf(2, 3)
125 print_insn_json(void *private_data, const char *fmt, ...)
126 {
127 	unsigned int l = strlen(fmt);
128 	char chomped_fmt[l];
129 	va_list args;
130 
131 	va_start(args, fmt);
132 	if (l > 0) {
133 		strncpy(chomped_fmt, fmt, l - 1);
134 		chomped_fmt[l - 1] = '\0';
135 	}
136 	jsonw_vprintf_enquote(json_wtr, chomped_fmt, args);
137 	va_end(args);
138 }
139 
140 static const char *print_call_pcrel(struct dump_data *dd,
141 				    struct kernel_sym *sym,
142 				    unsigned long address,
143 				    const struct bpf_insn *insn)
144 {
145 	if (!dd->nr_jited_ksyms)
146 		/* Do not show address for interpreted programs */
147 		snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
148 			"%+d", insn->off);
149 	else if (sym)
150 		snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
151 			 "%+d#%s", insn->off, sym->name);
152 	else
153 		snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
154 			 "%+d#0x%lx", insn->off, address);
155 	return dd->scratch_buff;
156 }
157 
158 static const char *print_call_helper(struct dump_data *dd,
159 				     struct kernel_sym *sym,
160 				     unsigned long address)
161 {
162 	if (sym)
163 		snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
164 			 "%s", sym->name);
165 	else
166 		snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
167 			 "0x%lx", address);
168 	return dd->scratch_buff;
169 }
170 
171 static const char *print_call(void *private_data,
172 			      const struct bpf_insn *insn)
173 {
174 	struct dump_data *dd = private_data;
175 	unsigned long address = dd->address_call_base + insn->imm;
176 	struct kernel_sym *sym;
177 
178 	if (insn->src_reg == BPF_PSEUDO_CALL &&
179 	    (__u32) insn->imm < dd->nr_jited_ksyms)
180 		address = dd->jited_ksyms[insn->imm];
181 
182 	sym = kernel_syms_search(dd, address);
183 	if (insn->src_reg == BPF_PSEUDO_CALL)
184 		return print_call_pcrel(dd, sym, address, insn);
185 	else
186 		return print_call_helper(dd, sym, address);
187 }
188 
189 static const char *print_imm(void *private_data,
190 			     const struct bpf_insn *insn,
191 			     __u64 full_imm)
192 {
193 	struct dump_data *dd = private_data;
194 
195 	if (insn->src_reg == BPF_PSEUDO_MAP_FD)
196 		snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
197 			 "map[id:%u]", insn->imm);
198 	else
199 		snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
200 			 "0x%llx", (unsigned long long)full_imm);
201 	return dd->scratch_buff;
202 }
203 
204 void dump_xlated_json(struct dump_data *dd, void *buf, unsigned int len,
205 		      bool opcodes, bool linum)
206 {
207 	const struct bpf_prog_linfo *prog_linfo = dd->prog_linfo;
208 	const struct bpf_insn_cbs cbs = {
209 		.cb_print	= print_insn_json,
210 		.cb_call	= print_call,
211 		.cb_imm		= print_imm,
212 		.private_data	= dd,
213 	};
214 	struct bpf_func_info *record;
215 	struct bpf_insn *insn = buf;
216 	struct btf *btf = dd->btf;
217 	bool double_insn = false;
218 	unsigned int nr_skip = 0;
219 	char func_sig[1024];
220 	unsigned int i;
221 
222 	jsonw_start_array(json_wtr);
223 	record = dd->func_info;
224 	for (i = 0; i < len / sizeof(*insn); i++) {
225 		if (double_insn) {
226 			double_insn = false;
227 			continue;
228 		}
229 		double_insn = insn[i].code == (BPF_LD | BPF_IMM | BPF_DW);
230 
231 		jsonw_start_object(json_wtr);
232 
233 		if (btf && record) {
234 			if (record->insn_off == i) {
235 				btf_dumper_type_only(btf, record->type_id,
236 						     func_sig,
237 						     sizeof(func_sig));
238 				if (func_sig[0] != '\0') {
239 					jsonw_name(json_wtr, "proto");
240 					jsonw_string(json_wtr, func_sig);
241 				}
242 				record = (void *)record + dd->finfo_rec_size;
243 			}
244 		}
245 
246 		if (prog_linfo) {
247 			const struct bpf_line_info *linfo;
248 
249 			linfo = bpf_prog_linfo__lfind(prog_linfo, i, nr_skip);
250 			if (linfo) {
251 				btf_dump_linfo_json(btf, linfo, linum);
252 				nr_skip++;
253 			}
254 		}
255 
256 		jsonw_name(json_wtr, "disasm");
257 		print_bpf_insn(&cbs, insn + i, true);
258 
259 		if (opcodes) {
260 			jsonw_name(json_wtr, "opcodes");
261 			jsonw_start_object(json_wtr);
262 
263 			jsonw_name(json_wtr, "code");
264 			jsonw_printf(json_wtr, "\"0x%02hhx\"", insn[i].code);
265 
266 			jsonw_name(json_wtr, "src_reg");
267 			jsonw_printf(json_wtr, "\"0x%hhx\"", insn[i].src_reg);
268 
269 			jsonw_name(json_wtr, "dst_reg");
270 			jsonw_printf(json_wtr, "\"0x%hhx\"", insn[i].dst_reg);
271 
272 			jsonw_name(json_wtr, "off");
273 			print_hex_data_json((uint8_t *)(&insn[i].off), 2);
274 
275 			jsonw_name(json_wtr, "imm");
276 			if (double_insn && i < len - 1)
277 				print_hex_data_json((uint8_t *)(&insn[i].imm),
278 						    12);
279 			else
280 				print_hex_data_json((uint8_t *)(&insn[i].imm),
281 						    4);
282 			jsonw_end_object(json_wtr);
283 		}
284 		jsonw_end_object(json_wtr);
285 	}
286 	jsonw_end_array(json_wtr);
287 }
288 
289 void dump_xlated_plain(struct dump_data *dd, void *buf, unsigned int len,
290 		       bool opcodes, bool linum)
291 {
292 	const struct bpf_prog_linfo *prog_linfo = dd->prog_linfo;
293 	const struct bpf_insn_cbs cbs = {
294 		.cb_print	= print_insn,
295 		.cb_call	= print_call,
296 		.cb_imm		= print_imm,
297 		.private_data	= dd,
298 	};
299 	struct bpf_func_info *record;
300 	struct bpf_insn *insn = buf;
301 	struct btf *btf = dd->btf;
302 	unsigned int nr_skip = 0;
303 	bool double_insn = false;
304 	char func_sig[1024];
305 	unsigned int i;
306 
307 	record = dd->func_info;
308 	for (i = 0; i < len / sizeof(*insn); i++) {
309 		if (double_insn) {
310 			double_insn = false;
311 			continue;
312 		}
313 
314 		if (btf && record) {
315 			if (record->insn_off == i) {
316 				btf_dumper_type_only(btf, record->type_id,
317 						     func_sig,
318 						     sizeof(func_sig));
319 				if (func_sig[0] != '\0')
320 					printf("%s:\n", func_sig);
321 				record = (void *)record + dd->finfo_rec_size;
322 			}
323 		}
324 
325 		if (prog_linfo) {
326 			const struct bpf_line_info *linfo;
327 
328 			linfo = bpf_prog_linfo__lfind(prog_linfo, i, nr_skip);
329 			if (linfo) {
330 				btf_dump_linfo_plain(btf, linfo, "; ",
331 						     linum);
332 				nr_skip++;
333 			}
334 		}
335 
336 		double_insn = insn[i].code == (BPF_LD | BPF_IMM | BPF_DW);
337 
338 		printf("% 4d: ", i);
339 		print_bpf_insn(&cbs, insn + i, true);
340 
341 		if (opcodes) {
342 			printf("       ");
343 			fprint_hex(stdout, insn + i, 8, " ");
344 			if (double_insn && i < len - 1) {
345 				printf(" ");
346 				fprint_hex(stdout, insn + i + 1, 8, " ");
347 			}
348 			printf("\n");
349 		}
350 	}
351 }
352 
353 void dump_xlated_for_graph(struct dump_data *dd, void *buf_start, void *buf_end,
354 			   unsigned int start_idx)
355 {
356 	const struct bpf_insn_cbs cbs = {
357 		.cb_print	= print_insn_for_graph,
358 		.cb_call	= print_call,
359 		.cb_imm		= print_imm,
360 		.private_data	= dd,
361 	};
362 	struct bpf_insn *insn_start = buf_start;
363 	struct bpf_insn *insn_end = buf_end;
364 	struct bpf_insn *cur = insn_start;
365 
366 	for (; cur <= insn_end; cur++) {
367 		printf("% 4d: ", (int)(cur - insn_start + start_idx));
368 		print_bpf_insn(&cbs, cur, true);
369 		if (cur != insn_end)
370 			printf(" | ");
371 	}
372 }
373