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