1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2 /* Copyright (C) 2018 Netronome Systems, Inc. */ 3 4 #ifndef _GNU_SOURCE 5 #define _GNU_SOURCE 6 #endif 7 #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 20 static 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 26 void 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) { 41 out: 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 if (sscanf(buff, "%p %*c %s", &address, sym->name) != 2) 50 continue; 51 sym->address = (unsigned long)address; 52 if (!strcmp(sym->name, "__bpf_call_base")) { 53 dd->address_call_base = sym->address; 54 /* sysctl kernel.kptr_restrict was set */ 55 if (!sym->address) 56 goto out; 57 } 58 if (sym->address) 59 dd->sym_count++; 60 } 61 62 fclose(fp); 63 64 qsort(dd->sym_mapping, dd->sym_count, 65 sizeof(*dd->sym_mapping), kernel_syms_cmp); 66 } 67 68 void kernel_syms_destroy(struct dump_data *dd) 69 { 70 free(dd->sym_mapping); 71 } 72 73 struct kernel_sym *kernel_syms_search(struct dump_data *dd, 74 unsigned long key) 75 { 76 struct kernel_sym sym = { 77 .address = key, 78 }; 79 80 return dd->sym_mapping ? 81 bsearch(&sym, dd->sym_mapping, dd->sym_count, 82 sizeof(*dd->sym_mapping), kernel_syms_cmp) : NULL; 83 } 84 85 static void __printf(2, 3) print_insn(void *private_data, const char *fmt, ...) 86 { 87 va_list args; 88 89 va_start(args, fmt); 90 vprintf(fmt, args); 91 va_end(args); 92 } 93 94 static void __printf(2, 3) 95 print_insn_for_graph(void *private_data, const char *fmt, ...) 96 { 97 char buf[64], *p; 98 va_list args; 99 100 va_start(args, fmt); 101 vsnprintf(buf, sizeof(buf), fmt, args); 102 va_end(args); 103 104 p = buf; 105 while (*p != '\0') { 106 if (*p == '\n') { 107 memmove(p + 3, p, strlen(buf) + 1 - (p - buf)); 108 /* Align each instruction dump row left. */ 109 *p++ = '\\'; 110 *p++ = 'l'; 111 /* Output multiline concatenation. */ 112 *p++ = '\\'; 113 } else if (*p == '<' || *p == '>' || *p == '|' || *p == '&') { 114 memmove(p + 1, p, strlen(buf) + 1 - (p - buf)); 115 /* Escape special character. */ 116 *p++ = '\\'; 117 } 118 119 p++; 120 } 121 122 printf("%s", buf); 123 } 124 125 static void __printf(2, 3) 126 print_insn_json(void *private_data, const char *fmt, ...) 127 { 128 unsigned int l = strlen(fmt); 129 char chomped_fmt[l]; 130 va_list args; 131 132 va_start(args, fmt); 133 if (l > 0) { 134 strncpy(chomped_fmt, fmt, l - 1); 135 chomped_fmt[l - 1] = '\0'; 136 } 137 jsonw_vprintf_enquote(json_wtr, chomped_fmt, args); 138 va_end(args); 139 } 140 141 static const char *print_call_pcrel(struct dump_data *dd, 142 struct kernel_sym *sym, 143 unsigned long address, 144 const struct bpf_insn *insn) 145 { 146 if (!dd->nr_jited_ksyms) 147 /* Do not show address for interpreted programs */ 148 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff), 149 "%+d", insn->off); 150 else if (sym) 151 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff), 152 "%+d#%s", insn->off, sym->name); 153 else 154 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff), 155 "%+d#0x%lx", insn->off, address); 156 return dd->scratch_buff; 157 } 158 159 static const char *print_call_helper(struct dump_data *dd, 160 struct kernel_sym *sym, 161 unsigned long address) 162 { 163 if (sym) 164 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff), 165 "%s", sym->name); 166 else 167 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff), 168 "0x%lx", address); 169 return dd->scratch_buff; 170 } 171 172 static const char *print_call(void *private_data, 173 const struct bpf_insn *insn) 174 { 175 struct dump_data *dd = private_data; 176 unsigned long address = dd->address_call_base + insn->imm; 177 struct kernel_sym *sym; 178 179 if (insn->src_reg == BPF_PSEUDO_CALL && 180 (__u32) insn->imm < dd->nr_jited_ksyms && dd->jited_ksyms) 181 address = dd->jited_ksyms[insn->imm]; 182 183 sym = kernel_syms_search(dd, address); 184 if (insn->src_reg == BPF_PSEUDO_CALL) 185 return print_call_pcrel(dd, sym, address, insn); 186 else 187 return print_call_helper(dd, sym, address); 188 } 189 190 static const char *print_imm(void *private_data, 191 const struct bpf_insn *insn, 192 __u64 full_imm) 193 { 194 struct dump_data *dd = private_data; 195 196 if (insn->src_reg == BPF_PSEUDO_MAP_FD) 197 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff), 198 "map[id:%u]", insn->imm); 199 else if (insn->src_reg == BPF_PSEUDO_MAP_VALUE) 200 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff), 201 "map[id:%u][0]+%u", insn->imm, (insn + 1)->imm); 202 else if (insn->src_reg == BPF_PSEUDO_MAP_IDX_VALUE) 203 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff), 204 "map[idx:%u]+%u", insn->imm, (insn + 1)->imm); 205 else if (insn->src_reg == BPF_PSEUDO_FUNC) 206 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff), 207 "subprog[%+d]", insn->imm); 208 else 209 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff), 210 "0x%llx", (unsigned long long)full_imm); 211 return dd->scratch_buff; 212 } 213 214 void dump_xlated_json(struct dump_data *dd, void *buf, unsigned int len, 215 bool opcodes, bool linum) 216 { 217 const struct bpf_prog_linfo *prog_linfo = dd->prog_linfo; 218 const struct bpf_insn_cbs cbs = { 219 .cb_print = print_insn_json, 220 .cb_call = print_call, 221 .cb_imm = print_imm, 222 .private_data = dd, 223 }; 224 struct bpf_func_info *record; 225 struct bpf_insn *insn = buf; 226 struct btf *btf = dd->btf; 227 bool double_insn = false; 228 unsigned int nr_skip = 0; 229 char func_sig[1024]; 230 unsigned int i; 231 232 jsonw_start_array(json_wtr); 233 record = dd->func_info; 234 for (i = 0; i < len / sizeof(*insn); i++) { 235 if (double_insn) { 236 double_insn = false; 237 continue; 238 } 239 double_insn = insn[i].code == (BPF_LD | BPF_IMM | BPF_DW); 240 241 jsonw_start_object(json_wtr); 242 243 if (btf && record) { 244 if (record->insn_off == i) { 245 btf_dumper_type_only(btf, record->type_id, 246 func_sig, 247 sizeof(func_sig)); 248 if (func_sig[0] != '\0') { 249 jsonw_name(json_wtr, "proto"); 250 jsonw_string(json_wtr, func_sig); 251 } 252 record = (void *)record + dd->finfo_rec_size; 253 } 254 } 255 256 if (prog_linfo) { 257 const struct bpf_line_info *linfo; 258 259 linfo = bpf_prog_linfo__lfind(prog_linfo, i, nr_skip); 260 if (linfo) { 261 btf_dump_linfo_json(btf, linfo, linum); 262 nr_skip++; 263 } 264 } 265 266 jsonw_name(json_wtr, "disasm"); 267 print_bpf_insn(&cbs, insn + i, true); 268 269 if (opcodes) { 270 jsonw_name(json_wtr, "opcodes"); 271 jsonw_start_object(json_wtr); 272 273 jsonw_name(json_wtr, "code"); 274 jsonw_printf(json_wtr, "\"0x%02hhx\"", insn[i].code); 275 276 jsonw_name(json_wtr, "src_reg"); 277 jsonw_printf(json_wtr, "\"0x%hhx\"", insn[i].src_reg); 278 279 jsonw_name(json_wtr, "dst_reg"); 280 jsonw_printf(json_wtr, "\"0x%hhx\"", insn[i].dst_reg); 281 282 jsonw_name(json_wtr, "off"); 283 print_hex_data_json((uint8_t *)(&insn[i].off), 2); 284 285 jsonw_name(json_wtr, "imm"); 286 if (double_insn && i < len - 1) 287 print_hex_data_json((uint8_t *)(&insn[i].imm), 288 12); 289 else 290 print_hex_data_json((uint8_t *)(&insn[i].imm), 291 4); 292 jsonw_end_object(json_wtr); 293 } 294 jsonw_end_object(json_wtr); 295 } 296 jsonw_end_array(json_wtr); 297 } 298 299 void dump_xlated_plain(struct dump_data *dd, void *buf, unsigned int len, 300 bool opcodes, bool linum) 301 { 302 const struct bpf_prog_linfo *prog_linfo = dd->prog_linfo; 303 const struct bpf_insn_cbs cbs = { 304 .cb_print = print_insn, 305 .cb_call = print_call, 306 .cb_imm = print_imm, 307 .private_data = dd, 308 }; 309 struct bpf_func_info *record; 310 struct bpf_insn *insn = buf; 311 struct btf *btf = dd->btf; 312 unsigned int nr_skip = 0; 313 bool double_insn = false; 314 char func_sig[1024]; 315 unsigned int i; 316 317 record = dd->func_info; 318 for (i = 0; i < len / sizeof(*insn); i++) { 319 if (double_insn) { 320 double_insn = false; 321 continue; 322 } 323 324 if (btf && record) { 325 if (record->insn_off == i) { 326 btf_dumper_type_only(btf, record->type_id, 327 func_sig, 328 sizeof(func_sig)); 329 if (func_sig[0] != '\0') 330 printf("%s:\n", func_sig); 331 record = (void *)record + dd->finfo_rec_size; 332 } 333 } 334 335 if (prog_linfo) { 336 const struct bpf_line_info *linfo; 337 338 linfo = bpf_prog_linfo__lfind(prog_linfo, i, nr_skip); 339 if (linfo) { 340 btf_dump_linfo_plain(btf, linfo, "; ", 341 linum); 342 nr_skip++; 343 } 344 } 345 346 double_insn = insn[i].code == (BPF_LD | BPF_IMM | BPF_DW); 347 348 printf("% 4d: ", i); 349 print_bpf_insn(&cbs, insn + i, true); 350 351 if (opcodes) { 352 printf(" "); 353 fprint_hex(stdout, insn + i, 8, " "); 354 if (double_insn && i < len - 1) { 355 printf(" "); 356 fprint_hex(stdout, insn + i + 1, 8, " "); 357 } 358 printf("\n"); 359 } 360 } 361 } 362 363 void dump_xlated_for_graph(struct dump_data *dd, void *buf_start, void *buf_end, 364 unsigned int start_idx, 365 bool opcodes, bool linum) 366 { 367 const struct bpf_insn_cbs cbs = { 368 .cb_print = print_insn_for_graph, 369 .cb_call = print_call, 370 .cb_imm = print_imm, 371 .private_data = dd, 372 }; 373 const struct bpf_prog_linfo *prog_linfo = dd->prog_linfo; 374 const struct bpf_line_info *last_linfo = NULL; 375 struct bpf_func_info *record = dd->func_info; 376 struct bpf_insn *insn_start = buf_start; 377 struct bpf_insn *insn_end = buf_end; 378 struct bpf_insn *cur = insn_start; 379 struct btf *btf = dd->btf; 380 bool double_insn = false; 381 char func_sig[1024]; 382 383 for (; cur <= insn_end; cur++) { 384 unsigned int insn_off; 385 386 if (double_insn) { 387 double_insn = false; 388 continue; 389 } 390 double_insn = cur->code == (BPF_LD | BPF_IMM | BPF_DW); 391 392 insn_off = (unsigned int)(cur - insn_start + start_idx); 393 if (btf && record) { 394 if (record->insn_off == insn_off) { 395 btf_dumper_type_only(btf, record->type_id, 396 func_sig, 397 sizeof(func_sig)); 398 if (func_sig[0] != '\0') 399 printf("; %s:\\l\\\n", func_sig); 400 record = (void *)record + dd->finfo_rec_size; 401 } 402 } 403 404 if (prog_linfo) { 405 const struct bpf_line_info *linfo; 406 407 linfo = bpf_prog_linfo__lfind(prog_linfo, insn_off, 0); 408 if (linfo && linfo != last_linfo) { 409 btf_dump_linfo_dotlabel(btf, linfo, linum); 410 last_linfo = linfo; 411 } 412 } 413 414 printf("%d: ", insn_off); 415 print_bpf_insn(&cbs, cur, true); 416 417 if (opcodes) { 418 printf("\\ \\ \\ \\ "); 419 fprint_hex(stdout, cur, 8, " "); 420 if (double_insn && cur <= insn_end - 1) { 421 printf(" "); 422 fprint_hex(stdout, cur + 1, 8, " "); 423 } 424 printf("\\l\\\n"); 425 } 426 427 if (cur != insn_end) 428 printf("| "); 429 } 430 } 431