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