~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/arch/powerpc/util/skip-callchain-idx.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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  */
238 int arch_skip_callchain_idx(struct thread *thread, struct ip_callchain *chain)
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_addr_location(thread, PERF_RECORD_MISC_USER,
252                         MAP__FUNCTION, ip, &al);
253 
254         if (al.map)
255                 dso = al.map->dso;
256 
257         if (!dso) {
258                 pr_debug("%" PRIx64 " dso is NULL\n", ip);
259                 return skip_slot;
260         }
261 
262         rc = check_return_addr(dso, al.map->start, ip);
263 
264         pr_debug("[DSO %s, sym %s, ip 0x%" PRIx64 "] rc %d\n",
265                                 dso->long_name, al.sym->name, ip, rc);
266 
267         if (rc == 0) {
268                 /*
269                  * Return address on stack. Ignore LR value in callchain
270                  */
271                 skip_slot = 2;
272         } else if (rc == 2) {
273                 /*
274                  * New frame allocated but return address still in LR.
275                  * Ignore the caller's caller entry in callchain.
276                  */
277                 skip_slot = 3;
278         }
279         return skip_slot;
280 }
281 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp