435 lines · c
1// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)2/* Copyright (C) 2018 Netronome Systems, Inc. */3 4#ifndef _GNU_SOURCE5#define _GNU_SOURCE6#endif7#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 else158 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 else171 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 else191 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 else213 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 else294 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("%4u: ", 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("%u: ", 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