Linux Perf
skip-callchain-idx.c
Go to the documentation of this file.
1 /*
2  * Use DWARF Debug information to skip unnecessary callchain entries.
3  *
4  * Copyright (C) 2014 Sukadev Bhattiprolu, IBM Corporation.
5  * Copyright (C) 2014 Ulrich Weigand, IBM Corporation.
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version
10  * 2 of the License, or (at your option) any later version.
11  */
12 #include <inttypes.h>
13 #include <dwarf.h>
14 #include <elfutils/libdwfl.h>
15 
16 #include "util/thread.h"
17 #include "util/callchain.h"
18 #include "util/debug.h"
19 
20 /*
21  * When saving the callchain on Power, the kernel conservatively saves
22  * excess entries in the callchain. A few of these entries are needed
23  * in some cases but not others. If the unnecessary entries are not
24  * ignored, we end up with duplicate arcs in the call-graphs. Use
25  * DWARF debug information to skip over any unnecessary callchain
26  * entries.
27  *
28  * See function header for arch_adjust_callchain() below for more details.
29  *
30  * The libdwfl code in this file is based on code from elfutils
31  * (libdwfl/argp-std.c, libdwfl/tests/addrcfi.c, etc).
32  */
33 static char *debuginfo_path;
34 
35 static const Dwfl_Callbacks offline_callbacks = {
36  .debuginfo_path = &debuginfo_path,
37  .find_debuginfo = dwfl_standard_find_debuginfo,
38  .section_address = dwfl_offline_section_address,
39 };
40 
41 
42 /*
43  * Use the DWARF expression for the Call-frame-address and determine
44  * if return address is in LR and if a new frame was allocated.
45  */
46 static int check_return_reg(int ra_regno, Dwarf_Frame *frame)
47 {
48  Dwarf_Op ops_mem[2];
49  Dwarf_Op dummy;
50  Dwarf_Op *ops = &dummy;
51  size_t nops;
52  int result;
53 
54  result = dwarf_frame_register(frame, ra_regno, ops_mem, &ops, &nops);
55  if (result < 0) {
56  pr_debug("dwarf_frame_register() %s\n", dwarf_errmsg(-1));
57  return -1;
58  }
59 
60  /*
61  * Check if return address is on the stack.
62  */
63  if (nops != 0 || ops != NULL)
64  return 0;
65 
66  /*
67  * Return address is in LR. Check if a frame was allocated
68  * but not-yet used.
69  */
70  result = dwarf_frame_cfa(frame, &ops, &nops);
71  if (result < 0) {
72  pr_debug("dwarf_frame_cfa() returns %d, %s\n", result,
73  dwarf_errmsg(-1));
74  return -1;
75  }
76 
77  /*
78  * If call frame address is in r1, no new frame was allocated.
79  */
80  if (nops == 1 && ops[0].atom == DW_OP_bregx && ops[0].number == 1 &&
81  ops[0].number2 == 0)
82  return 1;
83 
84  /*
85  * A new frame was allocated but has not yet been used.
86  */
87  return 2;
88 }
89 
90 /*
91  * Get the DWARF frame from the .eh_frame section.
92  */
93 static Dwarf_Frame *get_eh_frame(Dwfl_Module *mod, Dwarf_Addr pc)
94 {
95  int result;
96  Dwarf_Addr bias;
97  Dwarf_CFI *cfi;
98  Dwarf_Frame *frame;
99 
100  cfi = dwfl_module_eh_cfi(mod, &bias);
101  if (!cfi) {
102  pr_debug("%s(): no CFI - %s\n", __func__, dwfl_errmsg(-1));
103  return NULL;
104  }
105 
106  result = dwarf_cfi_addrframe(cfi, pc-bias, &frame);
107  if (result) {
108  pr_debug("%s(): %s\n", __func__, dwfl_errmsg(-1));
109  return NULL;
110  }
111 
112  return frame;
113 }
114 
115 /*
116  * Get the DWARF frame from the .debug_frame section.
117  */
118 static Dwarf_Frame *get_dwarf_frame(Dwfl_Module *mod, Dwarf_Addr pc)
119 {
120  Dwarf_CFI *cfi;
121  Dwarf_Addr bias;
122  Dwarf_Frame *frame;
123  int result;
124 
125  cfi = dwfl_module_dwarf_cfi(mod, &bias);
126  if (!cfi) {
127  pr_debug("%s(): no CFI - %s\n", __func__, dwfl_errmsg(-1));
128  return NULL;
129  }
130 
131  result = dwarf_cfi_addrframe(cfi, pc-bias, &frame);
132  if (result) {
133  pr_debug("%s(): %s\n", __func__, dwfl_errmsg(-1));
134  return NULL;
135  }
136 
137  return frame;
138 }
139 
140 /*
141  * Return:
142  * 0 if return address for the program counter @pc is on stack
143  * 1 if return address is in LR and no new stack frame was allocated
144  * 2 if return address is in LR and a new frame was allocated (but not
145  * yet used)
146  * -1 in case of errors
147  */
148 static int check_return_addr(struct dso *dso, u64 map_start, Dwarf_Addr pc)
149 {
150  int rc = -1;
151  Dwfl *dwfl;
152  Dwfl_Module *mod;
153  Dwarf_Frame *frame;
154  int ra_regno;
155  Dwarf_Addr start = pc;
156  Dwarf_Addr end = pc;
157  bool signalp;
158  const char *exec_file = dso->long_name;
159 
160  dwfl = dso->dwfl;
161 
162  if (!dwfl) {
163  dwfl = dwfl_begin(&offline_callbacks);
164  if (!dwfl) {
165  pr_debug("dwfl_begin() failed: %s\n", dwarf_errmsg(-1));
166  return -1;
167  }
168 
169  mod = dwfl_report_elf(dwfl, exec_file, exec_file, -1,
170  map_start, false);
171  if (!mod) {
172  pr_debug("dwfl_report_elf() failed %s\n",
173  dwarf_errmsg(-1));
174  /*
175  * We normally cache the DWARF debug info and never
176  * call dwfl_end(). But to prevent fd leak, free in
177  * case of error.
178  */
179  dwfl_end(dwfl);
180  goto out;
181  }
182  dso->dwfl = dwfl;
183  }
184 
185  mod = dwfl_addrmodule(dwfl, pc);
186  if (!mod) {
187  pr_debug("dwfl_addrmodule() failed, %s\n", dwarf_errmsg(-1));
188  goto out;
189  }
190 
191  /*
192  * To work with split debug info files (eg: glibc), check both
193  * .eh_frame and .debug_frame sections of the ELF header.
194  */
195  frame = get_eh_frame(mod, pc);
196  if (!frame) {
197  frame = get_dwarf_frame(mod, pc);
198  if (!frame)
199  goto out;
200  }
201 
202  ra_regno = dwarf_frame_info(frame, &start, &end, &signalp);
203  if (ra_regno < 0) {
204  pr_debug("Return address register unavailable: %s\n",
205  dwarf_errmsg(-1));
206  goto out;
207  }
208 
209  rc = check_return_reg(ra_regno, frame);
210 
211 out:
212  return rc;
213 }
214 
215 /*
216  * The callchain saved by the kernel always includes the link register (LR).
217  *
218  * 0: PERF_CONTEXT_USER
219  * 1: Program counter (Next instruction pointer)
220  * 2: LR value
221  * 3: Caller's caller
222  * 4: ...
223  *
224  * The value in LR is only needed when it holds a return address. If the
225  * return address is on the stack, we should ignore the LR value.
226  *
227  * Further, when the return address is in the LR, if a new frame was just
228  * allocated but the LR was not saved into it, then the LR contains the
229  * caller, slot 4: contains the caller's caller and the contents of slot 3:
230  * (chain->ips[3]) is undefined and must be ignored.
231  *
232  * Use DWARF debug information to determine if any entries need to be skipped.
233  *
234  * Return:
235  * index: of callchain entry that needs to be ignored (if any)
236  * -1 if no entry needs to be ignored or in case of errors
237  */
239 {
240  struct addr_location al;
241  struct dso *dso = NULL;
242  int rc;
243  u64 ip;
244  u64 skip_slot = -1;
245 
246  if (chain->nr < 3)
247  return skip_slot;
248 
249  ip = chain->ips[2];
250 
251  thread__find_symbol(thread, PERF_RECORD_MISC_USER, ip, &al);
252 
253  if (al.map)
254  dso = al.map->dso;
255 
256  if (!dso) {
257  pr_debug("%" PRIx64 " dso is NULL\n", ip);
258  return skip_slot;
259  }
260 
261  rc = check_return_addr(dso, al.map->start, ip);
262 
263  pr_debug("[DSO %s, sym %s, ip 0x%" PRIx64 "] rc %d\n",
264  dso->long_name, al.sym->name, ip, rc);
265 
266  if (rc == 0) {
267  /*
268  * Return address on stack. Ignore LR value in callchain
269  */
270  skip_slot = 2;
271  } else if (rc == 2) {
272  /*
273  * New frame allocated but return address still in LR.
274  * Ignore the caller's caller entry in callchain.
275  */
276  skip_slot = 3;
277  }
278  return skip_slot;
279 }
const char * long_name
Definition: dso.h:173
u64 ips[0]
Definition: event.h:137
u64 start
Definition: map.h:28
static int check_return_addr(struct dso *dso, u64 map_start, Dwarf_Addr pc)
static const Dwfl_Callbacks offline_callbacks
int arch_skip_callchain_idx(struct thread *thread, struct ip_callchain *chain)
struct map * map
Definition: symbol.h:210
Definition: thread.h:18
#define pr_debug(fmt,...)
Definition: json.h:27
u64 nr
Definition: event.h:136
struct dso * dso
Definition: map.h:45
char name[0]
Definition: symbol.h:66
struct symbol * sym
Definition: symbol.h:211
static char * debuginfo_path
Definition: dso.h:138
static struct rb_root result
Definition: builtin-lock.c:248
u64 start
Definition: hists_common.c:25
void * dwfl
Definition: dso.h:176
static Dwarf_Frame * get_dwarf_frame(Dwfl_Module *mod, Dwarf_Addr pc)
static Dwarf_Frame * get_eh_frame(Dwfl_Module *mod, Dwarf_Addr pc)
struct symbol * thread__find_symbol(struct thread *thread, u8 cpumode, u64 addr, struct addr_location *al)
Definition: event.c:1588
static int check_return_reg(int ra_regno, Dwarf_Frame *frame)