tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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
17static 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
23void 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) {
40out:
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
67void kernel_syms_destroy(struct dump_data *dd)
68{
69 free(dd->sym_mapping);
70}
71
72struct 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
84static 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
93static void __printf(2, 3)
94print_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
124static void __printf(2, 3)
125print_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
140static 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
158static 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
171static 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
189static 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 if (insn->src_reg == BPF_PSEUDO_MAP_VALUE)
199 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
200 "map[id:%u][0]+%u", insn->imm, (insn + 1)->imm);
201 else
202 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
203 "0x%llx", (unsigned long long)full_imm);
204 return dd->scratch_buff;
205}
206
207void dump_xlated_json(struct dump_data *dd, void *buf, unsigned int len,
208 bool opcodes, bool linum)
209{
210 const struct bpf_prog_linfo *prog_linfo = dd->prog_linfo;
211 const struct bpf_insn_cbs cbs = {
212 .cb_print = print_insn_json,
213 .cb_call = print_call,
214 .cb_imm = print_imm,
215 .private_data = dd,
216 };
217 struct bpf_func_info *record;
218 struct bpf_insn *insn = buf;
219 struct btf *btf = dd->btf;
220 bool double_insn = false;
221 unsigned int nr_skip = 0;
222 char func_sig[1024];
223 unsigned int i;
224
225 jsonw_start_array(json_wtr);
226 record = dd->func_info;
227 for (i = 0; i < len / sizeof(*insn); i++) {
228 if (double_insn) {
229 double_insn = false;
230 continue;
231 }
232 double_insn = insn[i].code == (BPF_LD | BPF_IMM | BPF_DW);
233
234 jsonw_start_object(json_wtr);
235
236 if (btf && record) {
237 if (record->insn_off == i) {
238 btf_dumper_type_only(btf, record->type_id,
239 func_sig,
240 sizeof(func_sig));
241 if (func_sig[0] != '\0') {
242 jsonw_name(json_wtr, "proto");
243 jsonw_string(json_wtr, func_sig);
244 }
245 record = (void *)record + dd->finfo_rec_size;
246 }
247 }
248
249 if (prog_linfo) {
250 const struct bpf_line_info *linfo;
251
252 linfo = bpf_prog_linfo__lfind(prog_linfo, i, nr_skip);
253 if (linfo) {
254 btf_dump_linfo_json(btf, linfo, linum);
255 nr_skip++;
256 }
257 }
258
259 jsonw_name(json_wtr, "disasm");
260 print_bpf_insn(&cbs, insn + i, true);
261
262 if (opcodes) {
263 jsonw_name(json_wtr, "opcodes");
264 jsonw_start_object(json_wtr);
265
266 jsonw_name(json_wtr, "code");
267 jsonw_printf(json_wtr, "\"0x%02hhx\"", insn[i].code);
268
269 jsonw_name(json_wtr, "src_reg");
270 jsonw_printf(json_wtr, "\"0x%hhx\"", insn[i].src_reg);
271
272 jsonw_name(json_wtr, "dst_reg");
273 jsonw_printf(json_wtr, "\"0x%hhx\"", insn[i].dst_reg);
274
275 jsonw_name(json_wtr, "off");
276 print_hex_data_json((uint8_t *)(&insn[i].off), 2);
277
278 jsonw_name(json_wtr, "imm");
279 if (double_insn && i < len - 1)
280 print_hex_data_json((uint8_t *)(&insn[i].imm),
281 12);
282 else
283 print_hex_data_json((uint8_t *)(&insn[i].imm),
284 4);
285 jsonw_end_object(json_wtr);
286 }
287 jsonw_end_object(json_wtr);
288 }
289 jsonw_end_array(json_wtr);
290}
291
292void dump_xlated_plain(struct dump_data *dd, void *buf, unsigned int len,
293 bool opcodes, bool linum)
294{
295 const struct bpf_prog_linfo *prog_linfo = dd->prog_linfo;
296 const struct bpf_insn_cbs cbs = {
297 .cb_print = print_insn,
298 .cb_call = print_call,
299 .cb_imm = print_imm,
300 .private_data = dd,
301 };
302 struct bpf_func_info *record;
303 struct bpf_insn *insn = buf;
304 struct btf *btf = dd->btf;
305 unsigned int nr_skip = 0;
306 bool double_insn = false;
307 char func_sig[1024];
308 unsigned int i;
309
310 record = dd->func_info;
311 for (i = 0; i < len / sizeof(*insn); i++) {
312 if (double_insn) {
313 double_insn = false;
314 continue;
315 }
316
317 if (btf && record) {
318 if (record->insn_off == i) {
319 btf_dumper_type_only(btf, record->type_id,
320 func_sig,
321 sizeof(func_sig));
322 if (func_sig[0] != '\0')
323 printf("%s:\n", func_sig);
324 record = (void *)record + dd->finfo_rec_size;
325 }
326 }
327
328 if (prog_linfo) {
329 const struct bpf_line_info *linfo;
330
331 linfo = bpf_prog_linfo__lfind(prog_linfo, i, nr_skip);
332 if (linfo) {
333 btf_dump_linfo_plain(btf, linfo, "; ",
334 linum);
335 nr_skip++;
336 }
337 }
338
339 double_insn = insn[i].code == (BPF_LD | BPF_IMM | BPF_DW);
340
341 printf("% 4d: ", i);
342 print_bpf_insn(&cbs, insn + i, true);
343
344 if (opcodes) {
345 printf(" ");
346 fprint_hex(stdout, insn + i, 8, " ");
347 if (double_insn && i < len - 1) {
348 printf(" ");
349 fprint_hex(stdout, insn + i + 1, 8, " ");
350 }
351 printf("\n");
352 }
353 }
354}
355
356void dump_xlated_for_graph(struct dump_data *dd, void *buf_start, void *buf_end,
357 unsigned int start_idx)
358{
359 const struct bpf_insn_cbs cbs = {
360 .cb_print = print_insn_for_graph,
361 .cb_call = print_call,
362 .cb_imm = print_imm,
363 .private_data = dd,
364 };
365 struct bpf_insn *insn_start = buf_start;
366 struct bpf_insn *insn_end = buf_end;
367 struct bpf_insn *cur = insn_start;
368
369 for (; cur <= insn_end; cur++) {
370 printf("% 4d: ", (int)(cur - insn_start + start_idx));
371 print_bpf_insn(&cbs, cur, true);
372 if (cur != insn_end)
373 printf(" | ");
374 }
375}