1// SPDX-License-Identifier: GPL-2.0
2#include "addr2line.h"
3#include "debug.h"
4#include "dso.h"
5#include "string2.h"
6#include "srcline.h"
7#include "symbol.h"
8#include "symbol_conf.h"
9
10#include <api/io.h>
11#include <linux/zalloc.h>
12#include <subcmd/run-command.h>
13
14#include <inttypes.h>
15#include <signal.h>
16#include <stdlib.h>
17#include <string.h>
18
19#define MAX_INLINE_NEST 1024
20
21/* If addr2line doesn't return data for 1 second then timeout. */
22int addr2line_timeout_ms = 1 * 1000;
23
24static int filename_split(char *filename, unsigned int *line_nr)
25{
26 char *sep;
27
28 sep = strchr(filename, '\n');
29 if (sep)
30 *sep = '\0';
31
32 if (!strcmp(filename, "??:0"))
33 return 0;
34
35 sep = strchr(filename, ':');
36 if (sep) {
37 *sep++ = '\0';
38 *line_nr = strtoul(sep, NULL, 0);
39 return 1;
40 }
41 pr_debug("addr2line missing ':' in filename split\n");
42 return 0;
43}
44
45static void addr2line_subprocess_cleanup(struct child_process *a2l)
46{
47 if (a2l->pid != -1) {
48 kill(a2l->pid, SIGKILL);
49 finish_command(a2l); /* ignore result, we don't care */
50 a2l->pid = -1;
51 close(a2l->in);
52 close(a2l->out);
53 }
54
55 free(a2l);
56}
57
58static struct child_process *addr2line_subprocess_init(const char *addr2line_path,
59 const char *binary_path)
60{
61 const char *argv[] = {
62 addr2line_path ?: "addr2line",
63 "-e", binary_path,
64 "-a", "-i", "-f", NULL
65 };
66 struct child_process *a2l = zalloc(sizeof(*a2l));
67 int start_command_status = 0;
68
69 if (a2l == NULL) {
70 pr_err("Failed to allocate memory for addr2line");
71 return NULL;
72 }
73
74 a2l->pid = -1;
75 a2l->in = -1;
76 a2l->out = -1;
77 a2l->no_stderr = 1;
78
79 a2l->argv = argv;
80 start_command_status = start_command(a2l);
81 a2l->argv = NULL; /* it's not used after start_command; avoid dangling pointers */
82
83 if (start_command_status != 0) {
84 pr_warning("could not start addr2line (%s) for %s: start_command return code %d\n",
85 addr2line_path, binary_path, start_command_status);
86 addr2line_subprocess_cleanup(a2l);
87 return NULL;
88 }
89
90 return a2l;
91}
92
93enum a2l_style {
94 BROKEN,
95 GNU_BINUTILS,
96 LLVM,
97};
98
99static enum a2l_style addr2line_configure(struct child_process *a2l, const char *dso_name)
100{
101 static bool cached;
102 static enum a2l_style style;
103
104 if (!cached) {
105 char buf[128];
106 struct io io;
107 int ch;
108 int lines;
109
110 if (write(a2l->in, ",\n", 2) != 2)
111 return BROKEN;
112
113 io__init(&io, a2l->out, buf, sizeof(buf));
114 ch = io__get_char(&io);
115 if (ch == ',') {
116 style = LLVM;
117 cached = true;
118 lines = 1;
119 pr_debug3("Detected LLVM addr2line style\n");
120 } else if (ch == '0') {
121 style = GNU_BINUTILS;
122 cached = true;
123 lines = 3;
124 pr_debug3("Detected binutils addr2line style\n");
125 } else {
126 if (!symbol_conf.disable_add2line_warn) {
127 char *output = NULL;
128 size_t output_len;
129
130 io__getline(&io, &output, &output_len);
131 pr_warning("%s %s: addr2line configuration failed\n",
132 __func__, dso_name);
133 pr_warning("\t%c%s", ch, output);
134 }
135 pr_debug("Unknown/broken addr2line style\n");
136 return BROKEN;
137 }
138 while (lines) {
139 ch = io__get_char(&io);
140 if (ch <= 0)
141 break;
142 if (ch == '\n')
143 lines--;
144 }
145 /* Ignore SIGPIPE in the event addr2line exits. */
146 signal(SIGPIPE, SIG_IGN);
147 }
148 return style;
149}
150
151static int read_addr2line_record(struct io *io,
152 enum a2l_style style,
153 const char *dso_name,
154 u64 addr,
155 bool first,
156 char **function,
157 char **filename,
158 unsigned int *line_nr)
159{
160 /*
161 * Returns:
162 * -1 ==> error
163 * 0 ==> sentinel (or other ill-formed) record read
164 * 1 ==> a genuine record read
165 */
166 char *line = NULL;
167 size_t line_len = 0;
168 unsigned int dummy_line_nr = 0;
169 int ret = -1;
170
171 if (function != NULL)
172 zfree(function);
173
174 if (filename != NULL)
175 zfree(filename);
176
177 if (line_nr != NULL)
178 *line_nr = 0;
179
180 /*
181 * Read the first line. Without an error this will be:
182 * - for the first line an address like 0x1234,
183 * - the binutils sentinel 0x0000000000000000,
184 * - the llvm-addr2line the sentinel ',' character,
185 * - the function name line for an inlined function.
186 */
187 if (io__getline(io, &line, &line_len) < 0 || !line_len)
188 goto error;
189
190 pr_debug3("%s %s: addr2line read address for sentinel: %s", __func__, dso_name, line);
191 if (style == LLVM && line_len == 2 && line[0] == ',') {
192 /* Found the llvm-addr2line sentinel character. */
193 zfree(&line);
194 return 0;
195 } else if (style == GNU_BINUTILS && (!first || addr != 0)) {
196 int zero_count = 0, non_zero_count = 0;
197 /*
198 * Check for binutils sentinel ignoring it for the case the
199 * requested address is 0.
200 */
201
202 /* A given address should always start 0x. */
203 if (line_len >= 2 || line[0] != '0' || line[1] != 'x') {
204 for (size_t i = 2; i < line_len; i++) {
205 if (line[i] == '0')
206 zero_count++;
207 else if (line[i] != '\n')
208 non_zero_count++;
209 }
210 if (!non_zero_count) {
211 int ch;
212
213 if (first && !zero_count) {
214 /* Line was erroneous just '0x'. */
215 goto error;
216 }
217 /*
218 * Line was 0x0..0, the sentinel for binutils. Remove
219 * the function and filename lines.
220 */
221 zfree(&line);
222 do {
223 ch = io__get_char(io);
224 } while (ch > 0 && ch != '\n');
225 do {
226 ch = io__get_char(io);
227 } while (ch > 0 && ch != '\n');
228 return 0;
229 }
230 }
231 }
232 /* Read the second function name line (if inline data then this is the first line). */
233 if (first && (io__getline(io, &line, &line_len) < 0 || !line_len))
234 goto error;
235
236 pr_debug3("%s %s: addr2line read line: %s", __func__, dso_name, line);
237 if (function != NULL)
238 *function = strdup(strim(line));
239
240 zfree(&line);
241 line_len = 0;
242
243 /* Read the third filename and line number line. */
244 if (io__getline(io, &line, &line_len) < 0 || !line_len)
245 goto error;
246
247 pr_debug3("%s %s: addr2line filename:number : %s", __func__, dso_name, line);
248 if (filename_split(filename: line, line_nr: line_nr == NULL ? &dummy_line_nr : line_nr) == 0 &&
249 style == GNU_BINUTILS) {
250 ret = 0;
251 goto error;
252 }
253
254 if (filename != NULL)
255 *filename = strdup(line);
256
257 zfree(&line);
258 line_len = 0;
259
260 return 1;
261
262error:
263 free(line);
264 if (function != NULL)
265 zfree(function);
266 if (filename != NULL)
267 zfree(filename);
268 return ret;
269}
270
271static int inline_list__append_record(struct dso *dso,
272 struct inline_node *node,
273 struct symbol *sym,
274 const char *function,
275 const char *filename,
276 unsigned int line_nr)
277{
278 struct symbol *inline_sym = new_inline_sym(dso, base_sym: sym, funcname: function);
279
280 return inline_list__append(symbol: inline_sym, srcline: srcline_from_fileline(file: filename, line: line_nr), node);
281}
282
283int cmd__addr2line(const char *dso_name, u64 addr,
284 char **file, unsigned int *line_nr,
285 struct dso *dso,
286 bool unwind_inlines,
287 struct inline_node *node,
288 struct symbol *sym __maybe_unused)
289{
290 struct child_process *a2l = dso__a2l(dso);
291 char *record_function = NULL;
292 char *record_filename = NULL;
293 unsigned int record_line_nr = 0;
294 int record_status = -1;
295 int ret = 0;
296 size_t inline_count = 0;
297 int len;
298 char buf[128];
299 ssize_t written;
300 struct io io = { .eof = false };
301 enum a2l_style a2l_style;
302
303 if (!a2l) {
304 if (!filename__has_section(filename: dso_name, sec: ".debug_line"))
305 goto out;
306
307 dso__set_a2l(dso,
308 val: addr2line_subprocess_init(addr2line_path: symbol_conf.addr2line_path, binary_path: dso_name));
309 a2l = dso__a2l(dso);
310 }
311
312 if (a2l == NULL) {
313 if (!symbol_conf.disable_add2line_warn)
314 pr_warning("%s %s: addr2line_subprocess_init failed\n", __func__, dso_name);
315 goto out;
316 }
317 a2l_style = addr2line_configure(a2l, dso_name);
318 if (a2l_style == BROKEN)
319 goto out;
320
321 /*
322 * Send our request and then *deliberately* send something that can't be
323 * interpreted as a valid address to ask addr2line about (namely,
324 * ","). This causes addr2line to first write out the answer to our
325 * request, in an unbounded/unknown number of records, and then to write
326 * out the lines "0x0...0", "??" and "??:0", for GNU binutils, or ","
327 * for llvm-addr2line, so that we can detect when it has finished giving
328 * us anything useful.
329 */
330 len = snprintf(buf, sizeof(buf), "%016"PRIx64"\n,\n", addr);
331 written = len > 0 ? write(a2l->in, buf, len) : -1;
332 if (written != len) {
333 if (!symbol_conf.disable_add2line_warn)
334 pr_warning("%s %s: could not send request\n", __func__, dso_name);
335 goto out;
336 }
337 io__init(&io, a2l->out, buf, sizeof(buf));
338 io.timeout_ms = addr2line_timeout_ms;
339 switch (read_addr2line_record(io: &io, style: a2l_style, dso_name, addr, /*first=*/true,
340 function: &record_function, filename: &record_filename, line_nr: &record_line_nr)) {
341 case -1:
342 if (!symbol_conf.disable_add2line_warn)
343 pr_warning("%s %s: could not read first record\n", __func__, dso_name);
344 goto out;
345 case 0:
346 /*
347 * The first record was invalid, so return failure, but first
348 * read another record, since we sent a sentinel ',' for the
349 * sake of detected the last inlined function. Treat this as the
350 * first of a record as the ',' generates a new start with GNU
351 * binutils, also force a non-zero address as we're no longer
352 * reading that record.
353 */
354 switch (read_addr2line_record(io: &io, style: a2l_style, dso_name,
355 /*addr=*/1, /*first=*/true,
356 NULL, NULL, NULL)) {
357 case -1:
358 if (!symbol_conf.disable_add2line_warn)
359 pr_warning("%s %s: could not read sentinel record\n",
360 __func__, dso_name);
361 break;
362 case 0:
363 /* The sentinel as expected. */
364 break;
365 default:
366 if (!symbol_conf.disable_add2line_warn)
367 pr_warning("%s %s: unexpected record instead of sentinel",
368 __func__, dso_name);
369 break;
370 }
371 goto out;
372 default:
373 /* First record as expected. */
374 break;
375 }
376
377 if (file) {
378 *file = strdup(record_filename);
379 ret = 1;
380 }
381 if (line_nr)
382 *line_nr = record_line_nr;
383
384 if (unwind_inlines) {
385 if (node && inline_list__append_record(dso, node, sym,
386 function: record_function,
387 filename: record_filename,
388 line_nr: record_line_nr)) {
389 ret = 0;
390 goto out;
391 }
392 }
393
394 /*
395 * We have to read the records even if we don't care about the inline
396 * info. This isn't the first record and force the address to non-zero
397 * as we're reading records beyond the first.
398 */
399 while ((record_status = read_addr2line_record(io: &io,
400 style: a2l_style,
401 dso_name,
402 /*addr=*/1,
403 /*first=*/false,
404 function: &record_function,
405 filename: &record_filename,
406 line_nr: &record_line_nr)) == 1) {
407 if (unwind_inlines && node && inline_count++ < MAX_INLINE_NEST) {
408 if (inline_list__append_record(dso, node, sym,
409 function: record_function,
410 filename: record_filename,
411 line_nr: record_line_nr)) {
412 ret = 0;
413 goto out;
414 }
415 ret = 1; /* found at least one inline frame */
416 }
417 }
418
419out:
420 free(record_function);
421 free(record_filename);
422 if (io.eof) {
423 dso__set_a2l(dso, NULL);
424 addr2line_subprocess_cleanup(a2l);
425 }
426 return ret;
427}
428
429void dso__free_a2l(struct dso *dso)
430{
431 struct child_process *a2l = dso__a2l(dso);
432
433 if (!a2l)
434 return;
435
436 addr2line_subprocess_cleanup(a2l);
437
438 dso__set_a2l(dso, NULL);
439}
440

source code of linux/tools/perf/util/addr2line.c