Quelle  jit_disasm.c   Sprache: C

// 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)
 */

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <stdio.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <limits.h>
#include <bpf/libbpf.h>

#ifdef HAVE_LLVM_SUPPORT
#include <llvm-c/Core.h>
#include <llvm-c/Disassembler.h>
#include <llvm-c/Target.h>
#include <llvm-c/TargetMachine.h>
#endif

#ifdef HAVE_LIBBFD_SUPPORT
#include <bfd.h>
#include <dis-asm.h>
#include <tools/dis-asm-compat.h>
#endif

#include "json_writer.h"
#include "main.h"

static int oper_count;

#ifdef HAVE_LLVM_SUPPORT
#define DISASM_SPACER

typedef LLVMDisasmContextRef disasm_ctx_t;

static int printf_json(char *s)
{
 s = strtok(s, " \t");
 jsonw_string_field(json_wtr, "operation", s);

 jsonw_name(json_wtr, "operands");
 jsonw_start_array(json_wtr);
 oper_count = 1;

 while ((s = strtok(NULL, " \t,()")) != 0) {
  jsonw_string(json_wtr, s);
  oper_count++;
 }
 return 0;
}

/* This callback to set the ref_type is necessary to have the LLVM disassembler
 * print PC-relative addresses instead of byte offsets for branch instruction
 * targets.
 */
static const char *
symbol_lookup_callback(__maybe_unused void *disasm_info,
         __maybe_unused uint64_t ref_value,
         uint64_t *ref_type, __maybe_unused uint64_t ref_PC,
         __maybe_unused const char **ref_name)
{
 *ref_type = LLVMDisassembler_ReferenceType_InOut_None;
 return NULL;
}

static int
init_context(disasm_ctx_t *ctx, const char *arch,
      __maybe_unused const char *disassembler_options,
      __maybe_unused unsigned char *image, __maybe_unused ssize_t len,
      __maybe_unused __u64 func_ksym)
{
 char *triple;

 if (arch)
  triple = LLVMNormalizeTargetTriple(arch);
 else
  triple = LLVMGetDefaultTargetTriple();
 if (!triple) {
  p_err("Failed to retrieve triple");
  return -1;
 }
 *ctx = LLVMCreateDisasm(triple, NULL, 0, NULL, symbol_lookup_callback);
 LLVMDisposeMessage(triple);

 if (!*ctx) {
  p_err("Failed to create disassembler");
  return -1;
 }

 return 0;
}

static void destroy_context(disasm_ctx_t *ctx)
{
 LLVMDisposeMessage(*ctx);
}

static int
disassemble_insn(disasm_ctx_t *ctx, unsigned char *image, ssize_t len, int pc,
   __u64 func_ksym)
{
 char buf[256];
 int count;

 count = LLVMDisasmInstruction(*ctx, image + pc, len - pc, func_ksym + pc,
          buf, sizeof(buf));
 if (json_output)
  printf_json(buf);
 else
  printf("%s", buf);

 return count;
}

int disasm_init(void)
{
 LLVMInitializeAllTargetInfos();
 LLVMInitializeAllTargetMCs();
 LLVMInitializeAllDisassemblers();
 return 0;
}
#endif /* HAVE_LLVM_SUPPORT */

#ifdef HAVE_LIBBFD_SUPPORT
#define DISASM_SPACER "\t"

struct disasm_info {
 struct disassemble_info info;
 __u64 func_ksym;
};

static void disasm_print_addr(bfd_vma addr, struct disassemble_info *info)
{
 struct disasm_info *dinfo = container_of(info, struct disasm_info, info);

 addr += dinfo->func_ksym;
 generic_print_address(addr, info);
}

typedef struct {
 struct disasm_info *info;
 disassembler_ftype disassemble;
 bfd *bfdf;
} disasm_ctx_t;

static int get_exec_path(char *tpath, size_t size)
{
 const char *path = "/proc/self/exe";
 ssize_t len;

 len = readlink(path, tpath, size - 1);
 if (len <= 0)
  return -1;

 tpath[len] = 0;

 return 0;
}

static int printf_json(void *out, const char *fmt, va_list ap)
{
 char *s;
 int err;

 err = vasprintf(&s, fmt, ap);
 if (err < 0)
  return -1;

 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;
}

static int fprintf_json(void *out, const char *fmt, ...)
{
 va_list ap;
 int r;

 va_start(ap, fmt);
 r = printf_json(out, fmt, ap);
 va_end(ap);

 return r;
}

static int fprintf_json_styled(void *out,
          enum disassembler_style style __maybe_unused,
          const char *fmt, ...)
{
 va_list ap;
 int r;

 va_start(ap, fmt);
 r = printf_json(out, fmt, ap);
 va_end(ap);

 return r;
}

static int init_context(disasm_ctx_t *ctx, const char *arch,
   const char *disassembler_options,
   unsigned char *image, ssize_t len, __u64 func_ksym)
{
 struct disassemble_info *info;
 char tpath[PATH_MAX];
 bfd *bfdf;

 memset(tpath, 0, sizeof(tpath));
 if (get_exec_path(tpath, sizeof(tpath))) {
  p_err("failed to create disassembler (get_exec_path)");
  return -1;
 }

 ctx->bfdf = bfd_openr(tpath, NULL);
 if (!ctx->bfdf) {
  p_err("failed to create disassembler (bfd_openr)");
  return -1;
 }
 if (!bfd_check_format(ctx->bfdf, bfd_object)) {
  p_err("failed to create disassembler (bfd_check_format)");
  goto err_close;
 }
 bfdf = ctx->bfdf;

 ctx->info = malloc(sizeof(struct disasm_info));
 if (!ctx->info) {
  p_err("mem alloc failed");
  goto err_close;
 }
 ctx->info->func_ksym = func_ksym;
 info = &ctx->info->info;

 if (json_output)
  init_disassemble_info_compat(info, stdout,
          (fprintf_ftype) fprintf_json,
          fprintf_json_styled);
 else
  init_disassemble_info_compat(info, stdout,
          (fprintf_ftype) fprintf,
          fprintf_styled);

 /* 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);
   goto err_free;
  }
 }

 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;
 info->print_address_func = disasm_print_addr;

 disassemble_init_for_target(info);

#ifdef DISASM_FOUR_ARGS_SIGNATURE
 ctx->disassemble = disassembler(info->arch,
     bfd_big_endian(bfdf),
     info->mach,
     bfdf);
#else
 ctx->disassemble = disassembler(bfdf);
#endif
 if (!ctx->disassemble) {
  p_err("failed to create disassembler");
  goto err_free;
 }
 return 0;

err_free:
 free(info);
err_close:
 bfd_close(ctx->bfdf);
 return -1;
}

static void destroy_context(disasm_ctx_t *ctx)
{
 free(ctx->info);
 bfd_close(ctx->bfdf);
}

static int
disassemble_insn(disasm_ctx_t *ctx, __maybe_unused unsigned char *image,
   __maybe_unused ssize_t len, int pc,
   __maybe_unused __u64 func_ksym)
{
 return ctx->disassemble(pc, &ctx->info->info);
}

int disasm_init(void)
{
 bfd_init();
 return 0;
}
#endif /* HAVE_LIBBPFD_SUPPORT */

int 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;
 unsigned int nr_skip = 0;
 int count, i;
 unsigned int pc = 0;
 disasm_ctx_t ctx;

 if (!len)
  return -1;

 if (init_context(&ctx, arch, disassembler_options, image, len, func_ksym))
  return -1;

 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:" DISASM_SPACER, pc);
  }

  count = disassemble_insn(&ctx, image, len, pc, func_ksym);

  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);

 destroy_context(&ctx);

 return 0;
}