| // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) |
| /* |
| * Based on: |
| * |
| * Minimal BPF JIT image disassembler |
| * |
| * Disassembles BPF JIT compiler emitted opcodes back to asm insn's for |
| * debugging or verification purposes. |
| * |
| * Copyright 2013 Daniel Borkmann <daniel@iogearbox.net> |
| * Licensed under the GNU General Public License, version 2.0 (GPLv2) |
| */ |
| |
| #define _GNU_SOURCE |
| #include <stdio.h> |
| #include <stdarg.h> |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <assert.h> |
| #include <unistd.h> |
| #include <string.h> |
| #include <bfd.h> |
| #include <dis-asm.h> |
| #include <sys/stat.h> |
| #include <limits.h> |
| #include <libbpf.h> |
| |
| #include "json_writer.h" |
| #include "main.h" |
| |
| static void get_exec_path(char *tpath, size_t size) |
| { |
| const char *path = "/proc/self/exe"; |
| ssize_t len; |
| |
| len = readlink(path, tpath, size - 1); |
| assert(len > 0); |
| tpath[len] = 0; |
| } |
| |
| static int oper_count; |
| static int fprintf_json(void *out, const char *fmt, ...) |
| { |
| va_list ap; |
| char *s; |
| |
| va_start(ap, fmt); |
| if (vasprintf(&s, fmt, ap) < 0) |
| return -1; |
| va_end(ap); |
| |
| if (!oper_count) { |
| int i; |
| |
| /* Strip trailing spaces */ |
| i = strlen(s) - 1; |
| while (s[i] == ' ') |
| s[i--] = '\0'; |
| |
| jsonw_string_field(json_wtr, "operation", s); |
| jsonw_name(json_wtr, "operands"); |
| jsonw_start_array(json_wtr); |
| oper_count++; |
| } else if (!strcmp(fmt, ",")) { |
| /* Skip */ |
| } else { |
| jsonw_string(json_wtr, s); |
| oper_count++; |
| } |
| free(s); |
| return 0; |
| } |
| |
| void disasm_print_insn(unsigned char *image, ssize_t len, int opcodes, |
| const char *arch, const char *disassembler_options, |
| const struct btf *btf, |
| const struct bpf_prog_linfo *prog_linfo, |
| __u64 func_ksym, unsigned int func_idx, |
| bool linum) |
| { |
| const struct bpf_line_info *linfo = NULL; |
| disassembler_ftype disassemble; |
| struct disassemble_info info; |
| unsigned int nr_skip = 0; |
| int count, i, pc = 0; |
| char tpath[PATH_MAX]; |
| bfd *bfdf; |
| |
| if (!len) |
| return; |
| |
| memset(tpath, 0, sizeof(tpath)); |
| get_exec_path(tpath, sizeof(tpath)); |
| |
| bfdf = bfd_openr(tpath, NULL); |
| assert(bfdf); |
| assert(bfd_check_format(bfdf, bfd_object)); |
| |
| if (json_output) |
| init_disassemble_info(&info, stdout, |
| (fprintf_ftype) fprintf_json); |
| else |
| init_disassemble_info(&info, stdout, |
| (fprintf_ftype) fprintf); |
| |
| /* Update architecture info for offload. */ |
| if (arch) { |
| const bfd_arch_info_type *inf = bfd_scan_arch(arch); |
| |
| if (inf) { |
| bfdf->arch_info = inf; |
| } else { |
| p_err("No libbfd support for %s", arch); |
| return; |
| } |
| } |
| |
| info.arch = bfd_get_arch(bfdf); |
| info.mach = bfd_get_mach(bfdf); |
| if (disassembler_options) |
| info.disassembler_options = disassembler_options; |
| info.buffer = image; |
| info.buffer_length = len; |
| |
| disassemble_init_for_target(&info); |
| |
| #ifdef DISASM_FOUR_ARGS_SIGNATURE |
| disassemble = disassembler(info.arch, |
| bfd_big_endian(bfdf), |
| info.mach, |
| bfdf); |
| #else |
| disassemble = disassembler(bfdf); |
| #endif |
| assert(disassemble); |
| |
| if (json_output) |
| jsonw_start_array(json_wtr); |
| do { |
| if (prog_linfo) { |
| linfo = bpf_prog_linfo__lfind_addr_func(prog_linfo, |
| func_ksym + pc, |
| func_idx, |
| nr_skip); |
| if (linfo) |
| nr_skip++; |
| } |
| |
| if (json_output) { |
| jsonw_start_object(json_wtr); |
| oper_count = 0; |
| if (linfo) |
| btf_dump_linfo_json(btf, linfo, linum); |
| jsonw_name(json_wtr, "pc"); |
| jsonw_printf(json_wtr, "\"0x%x\"", pc); |
| } else { |
| if (linfo) |
| btf_dump_linfo_plain(btf, linfo, "; ", |
| linum); |
| printf("%4x:\t", pc); |
| } |
| |
| count = disassemble(pc, &info); |
| if (json_output) { |
| /* Operand array, was started in fprintf_json. Before |
| * that, make sure we have a _null_ value if no operand |
| * other than operation code was present. |
| */ |
| if (oper_count == 1) |
| jsonw_null(json_wtr); |
| jsonw_end_array(json_wtr); |
| } |
| |
| if (opcodes) { |
| if (json_output) { |
| jsonw_name(json_wtr, "opcodes"); |
| jsonw_start_array(json_wtr); |
| for (i = 0; i < count; ++i) |
| jsonw_printf(json_wtr, "\"0x%02hhx\"", |
| (uint8_t)image[pc + i]); |
| jsonw_end_array(json_wtr); |
| } else { |
| printf("\n\t"); |
| for (i = 0; i < count; ++i) |
| printf("%02x ", |
| (uint8_t)image[pc + i]); |
| } |
| } |
| if (json_output) |
| jsonw_end_object(json_wtr); |
| else |
| printf("\n"); |
| |
| pc += count; |
| } while (count > 0 && pc < len); |
| if (json_output) |
| jsonw_end_array(json_wtr); |
| |
| bfd_close(bfdf); |
| } |
| |
| int disasm_init(void) |
| { |
| bfd_init(); |
| return 0; |
| } |