1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/compiler.h> 3 #include <elfutils/libdw.h> 4 #include <elfutils/libdwfl.h> 5 #include <inttypes.h> 6 #include <errno.h> 7 #include "debug.h" 8 #include "unwind.h" 9 #include "unwind-libdw.h" 10 #include "machine.h" 11 #include "thread.h" 12 #include <linux/types.h> 13 #include "event.h" 14 #include "perf_regs.h" 15 #include "callchain.h" 16 #include "util.h" 17 18 static char *debuginfo_path; 19 20 static const Dwfl_Callbacks offline_callbacks = { 21 .find_debuginfo = dwfl_standard_find_debuginfo, 22 .debuginfo_path = &debuginfo_path, 23 .section_address = dwfl_offline_section_address, 24 }; 25 26 static int __report_module(struct addr_location *al, u64 ip, 27 struct unwind_info *ui) 28 { 29 Dwfl_Module *mod; 30 struct dso *dso = NULL; 31 32 thread__find_addr_location(ui->thread, 33 PERF_RECORD_MISC_USER, 34 MAP__FUNCTION, ip, al); 35 36 if (al->map) 37 dso = al->map->dso; 38 39 if (!dso) 40 return 0; 41 42 mod = dwfl_addrmodule(ui->dwfl, ip); 43 if (mod) { 44 Dwarf_Addr s; 45 46 dwfl_module_info(mod, NULL, &s, NULL, NULL, NULL, NULL, NULL); 47 if (s != al->map->start) 48 mod = 0; 49 } 50 51 if (!mod) 52 mod = dwfl_report_elf(ui->dwfl, dso->short_name, 53 dso->long_name, -1, al->map->start, 54 false); 55 56 return mod && dwfl_addrmodule(ui->dwfl, ip) == mod ? 0 : -1; 57 } 58 59 static int report_module(u64 ip, struct unwind_info *ui) 60 { 61 struct addr_location al; 62 63 return __report_module(&al, ip, ui); 64 } 65 66 /* 67 * Store all entries within entries array, 68 * we will process it after we finish unwind. 69 */ 70 static int entry(u64 ip, struct unwind_info *ui) 71 72 { 73 struct unwind_entry *e = &ui->entries[ui->idx++]; 74 struct addr_location al; 75 76 if (__report_module(&al, ip, ui)) 77 return -1; 78 79 e->ip = al.addr; 80 e->map = al.map; 81 e->sym = al.sym; 82 83 pr_debug("unwind: %s:ip = 0x%" PRIx64 " (0x%" PRIx64 ")\n", 84 al.sym ? al.sym->name : "''", 85 ip, 86 al.map ? al.map->map_ip(al.map, ip) : (u64) 0); 87 return 0; 88 } 89 90 static pid_t next_thread(Dwfl *dwfl, void *arg, void **thread_argp) 91 { 92 /* We want only single thread to be processed. */ 93 if (*thread_argp != NULL) 94 return 0; 95 96 *thread_argp = arg; 97 return dwfl_pid(dwfl); 98 } 99 100 static int access_dso_mem(struct unwind_info *ui, Dwarf_Addr addr, 101 Dwarf_Word *data) 102 { 103 struct addr_location al; 104 ssize_t size; 105 106 thread__find_addr_map(ui->thread, PERF_RECORD_MISC_USER, 107 MAP__FUNCTION, addr, &al); 108 if (!al.map) { 109 /* 110 * We've seen cases (softice) where DWARF unwinder went 111 * through non executable mmaps, which we need to lookup 112 * in MAP__VARIABLE tree. 113 */ 114 thread__find_addr_map(ui->thread, PERF_RECORD_MISC_USER, 115 MAP__VARIABLE, addr, &al); 116 } 117 118 if (!al.map) { 119 pr_debug("unwind: no map for %lx\n", (unsigned long)addr); 120 return -1; 121 } 122 123 if (!al.map->dso) 124 return -1; 125 126 size = dso__data_read_addr(al.map->dso, al.map, ui->machine, 127 addr, (u8 *) data, sizeof(*data)); 128 129 return !(size == sizeof(*data)); 130 } 131 132 static bool memory_read(Dwfl *dwfl __maybe_unused, Dwarf_Addr addr, Dwarf_Word *result, 133 void *arg) 134 { 135 struct unwind_info *ui = arg; 136 struct stack_dump *stack = &ui->sample->user_stack; 137 u64 start, end; 138 int offset; 139 int ret; 140 141 ret = perf_reg_value(&start, &ui->sample->user_regs, PERF_REG_SP); 142 if (ret) 143 return false; 144 145 end = start + stack->size; 146 147 /* Check overflow. */ 148 if (addr + sizeof(Dwarf_Word) < addr) 149 return false; 150 151 if (addr < start || addr + sizeof(Dwarf_Word) > end) { 152 ret = access_dso_mem(ui, addr, result); 153 if (ret) { 154 pr_debug("unwind: access_mem 0x%" PRIx64 " not inside range" 155 " 0x%" PRIx64 "-0x%" PRIx64 "\n", 156 addr, start, end); 157 return false; 158 } 159 return true; 160 } 161 162 offset = addr - start; 163 *result = *(Dwarf_Word *)&stack->data[offset]; 164 pr_debug("unwind: access_mem addr 0x%" PRIx64 ", val %lx, offset %d\n", 165 addr, (unsigned long)*result, offset); 166 return true; 167 } 168 169 static const Dwfl_Thread_Callbacks callbacks = { 170 .next_thread = next_thread, 171 .memory_read = memory_read, 172 .set_initial_registers = libdw__arch_set_initial_registers, 173 }; 174 175 static int 176 frame_callback(Dwfl_Frame *state, void *arg) 177 { 178 struct unwind_info *ui = arg; 179 Dwarf_Addr pc; 180 bool isactivation; 181 182 if (!dwfl_frame_pc(state, &pc, NULL)) { 183 pr_err("%s", dwfl_errmsg(-1)); 184 return DWARF_CB_ABORT; 185 } 186 187 // report the module before we query for isactivation 188 report_module(pc, ui); 189 190 if (!dwfl_frame_pc(state, &pc, &isactivation)) { 191 pr_err("%s", dwfl_errmsg(-1)); 192 return DWARF_CB_ABORT; 193 } 194 195 if (!isactivation) 196 --pc; 197 198 return entry(pc, ui) || !(--ui->max_stack) ? 199 DWARF_CB_ABORT : DWARF_CB_OK; 200 } 201 202 int unwind__get_entries(unwind_entry_cb_t cb, void *arg, 203 struct thread *thread, 204 struct perf_sample *data, 205 int max_stack) 206 { 207 struct unwind_info *ui, ui_buf = { 208 .sample = data, 209 .thread = thread, 210 .machine = thread->mg->machine, 211 .cb = cb, 212 .arg = arg, 213 .max_stack = max_stack, 214 }; 215 Dwarf_Word ip; 216 int err = -EINVAL, i; 217 218 if (!data->user_regs.regs) 219 return -EINVAL; 220 221 ui = zalloc(sizeof(ui_buf) + sizeof(ui_buf.entries[0]) * max_stack); 222 if (!ui) 223 return -ENOMEM; 224 225 *ui = ui_buf; 226 227 ui->dwfl = dwfl_begin(&offline_callbacks); 228 if (!ui->dwfl) 229 goto out; 230 231 err = perf_reg_value(&ip, &data->user_regs, PERF_REG_IP); 232 if (err) 233 goto out; 234 235 err = report_module(ip, ui); 236 if (err) 237 goto out; 238 239 if (!dwfl_attach_state(ui->dwfl, EM_NONE, thread->tid, &callbacks, ui)) 240 goto out; 241 242 err = dwfl_getthread_frames(ui->dwfl, thread->tid, frame_callback, ui); 243 244 if (err && ui->max_stack != max_stack) 245 err = 0; 246 247 /* 248 * Display what we got based on the order setup. 249 */ 250 for (i = 0; i < ui->idx && !err; i++) { 251 int j = i; 252 253 if (callchain_param.order == ORDER_CALLER) 254 j = ui->idx - i - 1; 255 256 err = ui->entries[j].ip ? ui->cb(&ui->entries[j], ui->arg) : 0; 257 } 258 259 out: 260 if (err) 261 pr_debug("unwind: failed with '%s'\n", dwfl_errmsg(-1)); 262 263 dwfl_end(ui->dwfl); 264 free(ui); 265 return 0; 266 } 267