tools/bpf/bpftool/xlated_dumper.c

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