1/* fileline.c -- Get file and line number information in a backtrace.
2 Copyright (C) 2012-2023 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Google.
4
5Redistribution and use in source and binary forms, with or without
6modification, are permitted provided that the following conditions are
7met:
8
9 (1) Redistributions of source code must retain the above copyright
10 notice, this list of conditions and the following disclaimer.
11
12 (2) Redistributions in binary form must reproduce the above copyright
13 notice, this list of conditions and the following disclaimer in
14 the documentation and/or other materials provided with the
15 distribution.
16
17 (3) The name of the author may not be used to
18 endorse or promote products derived from this software without
19 specific prior written permission.
20
21THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
25INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
27SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
29STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
30IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31POSSIBILITY OF SUCH DAMAGE. */
32
33#include "config.h"
34
35#include <sys/types.h>
36#include <sys/stat.h>
37#include <errno.h>
38#include <fcntl.h>
39#include <stdlib.h>
40#include <unistd.h>
41
42#if defined (HAVE_KERN_PROC_ARGS) || defined (HAVE_KERN_PROC)
43#include <sys/sysctl.h>
44#endif
45
46#ifdef HAVE_MACH_O_DYLD_H
47#include <mach-o/dyld.h>
48#endif
49
50#include "backtrace.h"
51#include "internal.h"
52
53#ifndef HAVE_GETEXECNAME
54#define getexecname() NULL
55#endif
56
57#if !defined (HAVE_KERN_PROC_ARGS) && !defined (HAVE_KERN_PROC)
58
59#define sysctl_exec_name1(state, error_callback, data) NULL
60#define sysctl_exec_name2(state, error_callback, data) NULL
61
62#else /* defined (HAVE_KERN_PROC_ARGS) || |defined (HAVE_KERN_PROC) */
63
64static char *
65sysctl_exec_name (struct backtrace_state *state,
66 int mib0, int mib1, int mib2, int mib3,
67 backtrace_error_callback error_callback, void *data)
68{
69 int mib[4];
70 size_t len;
71 char *name;
72 size_t rlen;
73
74 mib[0] = mib0;
75 mib[1] = mib1;
76 mib[2] = mib2;
77 mib[3] = mib3;
78
79 if (sysctl (mib, 4, NULL, &len, NULL, 0) < 0)
80 return NULL;
81 name = (char *) backtrace_alloc (state, len, error_callback, data);
82 if (name == NULL)
83 return NULL;
84 rlen = len;
85 if (sysctl (mib, 4, name, &rlen, NULL, 0) < 0)
86 {
87 backtrace_free (state, name, len, error_callback, data);
88 return NULL;
89 }
90 return name;
91}
92
93#ifdef HAVE_KERN_PROC_ARGS
94
95static char *
96sysctl_exec_name1 (struct backtrace_state *state,
97 backtrace_error_callback error_callback, void *data)
98{
99 /* This variant is used on NetBSD. */
100 return sysctl_exec_name (state, CTL_KERN, KERN_PROC_ARGS, -1,
101 KERN_PROC_PATHNAME, error_callback, data);
102}
103
104#else
105
106#define sysctl_exec_name1(state, error_callback, data) NULL
107
108#endif
109
110#ifdef HAVE_KERN_PROC
111
112static char *
113sysctl_exec_name2 (struct backtrace_state *state,
114 backtrace_error_callback error_callback, void *data)
115{
116 /* This variant is used on FreeBSD. */
117 return sysctl_exec_name (state, CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1,
118 error_callback, data);
119}
120
121#else
122
123#define sysctl_exec_name2(state, error_callback, data) NULL
124
125#endif
126
127#endif /* defined (HAVE_KERN_PROC_ARGS) || |defined (HAVE_KERN_PROC) */
128
129#ifdef HAVE_MACH_O_DYLD_H
130
131static char *
132macho_get_executable_path (struct backtrace_state *state,
133 backtrace_error_callback error_callback, void *data)
134{
135 uint32_t len;
136 char *name;
137
138 len = 0;
139 if (_NSGetExecutablePath (NULL, &len) == 0)
140 return NULL;
141 name = (char *) backtrace_alloc (state, len, error_callback, data);
142 if (name == NULL)
143 return NULL;
144 if (_NSGetExecutablePath (name, &len) != 0)
145 {
146 backtrace_free (state, name, len, error_callback, data);
147 return NULL;
148 }
149 return name;
150}
151
152#else /* !defined (HAVE_MACH_O_DYLD_H) */
153
154#define macho_get_executable_path(state, error_callback, data) NULL
155
156#endif /* !defined (HAVE_MACH_O_DYLD_H) */
157
158#if HAVE_DECL__PGMPTR
159
160#define windows_executable_filename() _pgmptr
161
162#else /* !HAVE_DECL__PGMPTR */
163
164#define windows_executable_filename() NULL
165
166#endif /* !HAVE_DECL__PGMPTR */
167
168/* Initialize the fileline information from the executable. Returns 1
169 on success, 0 on failure. */
170
171static int
172fileline_initialize (struct backtrace_state *state,
173 backtrace_error_callback error_callback, void *data)
174{
175 int failed;
176 fileline fileline_fn;
177 int pass;
178 int called_error_callback;
179 int descriptor;
180 const char *filename;
181 char buf[64];
182
183 if (!state->threaded)
184 failed = state->fileline_initialization_failed;
185 else
186 failed = backtrace_atomic_load_int (&state->fileline_initialization_failed);
187
188 if (failed)
189 {
190 error_callback (data, "failed to read executable information", -1);
191 return 0;
192 }
193
194 if (!state->threaded)
195 fileline_fn = state->fileline_fn;
196 else
197 fileline_fn = backtrace_atomic_load_pointer (&state->fileline_fn);
198 if (fileline_fn != NULL)
199 return 1;
200
201 /* We have not initialized the information. Do it now. */
202
203 descriptor = -1;
204 called_error_callback = 0;
205 for (pass = 0; pass < 9; ++pass)
206 {
207 int does_not_exist;
208
209 switch (pass)
210 {
211 case 0:
212 filename = state->filename;
213 break;
214 case 1:
215 filename = getexecname ();
216 break;
217 case 2:
218 /* Test this before /proc/self/exe, as the latter exists but points
219 to the wine binary (and thus doesn't work). */
220 filename = windows_executable_filename ();
221 break;
222 case 3:
223 filename = "/proc/self/exe";
224 break;
225 case 4:
226 filename = "/proc/curproc/file";
227 break;
228 case 5:
229 snprintf (s: buf, maxlen: sizeof (buf), format: "/proc/%ld/object/a.out",
230 (long) getpid ());
231 filename = buf;
232 break;
233 case 6:
234 filename = sysctl_exec_name1 (state, error_callback, data);
235 break;
236 case 7:
237 filename = sysctl_exec_name2 (state, error_callback, data);
238 break;
239 case 8:
240 filename = macho_get_executable_path (state, error_callback, data);
241 break;
242 default:
243 abort ();
244 }
245
246 if (filename == NULL)
247 continue;
248
249 descriptor = backtrace_open (filename, error_callback, data,
250 does_not_exist: &does_not_exist);
251 if (descriptor < 0 && !does_not_exist)
252 {
253 called_error_callback = 1;
254 break;
255 }
256 if (descriptor >= 0)
257 break;
258 }
259
260 if (descriptor < 0)
261 {
262 if (!called_error_callback)
263 {
264 if (state->filename != NULL)
265 error_callback (data, state->filename, ENOENT);
266 else
267 error_callback (data,
268 "libbacktrace could not find executable to open",
269 0);
270 }
271 failed = 1;
272 }
273
274 if (!failed)
275 {
276 if (!backtrace_initialize (state, filename, descriptor, error_callback,
277 data, fileline_fn: &fileline_fn))
278 failed = 1;
279 }
280
281 if (failed)
282 {
283 if (!state->threaded)
284 state->fileline_initialization_failed = 1;
285 else
286 backtrace_atomic_store_int (&state->fileline_initialization_failed, 1);
287 return 0;
288 }
289
290 if (!state->threaded)
291 state->fileline_fn = fileline_fn;
292 else
293 {
294 backtrace_atomic_store_pointer (&state->fileline_fn, fileline_fn);
295
296 /* Note that if two threads initialize at once, one of the data
297 sets may be leaked. */
298 }
299
300 return 1;
301}
302
303/* Given a PC, find the file name, line number, and function name. */
304
305int
306backtrace_pcinfo (struct backtrace_state *state, uintptr_t pc,
307 backtrace_full_callback callback,
308 backtrace_error_callback error_callback, void *data)
309{
310 if (!fileline_initialize (state, error_callback, data))
311 return 0;
312
313 if (state->fileline_initialization_failed)
314 return 0;
315
316 return state->fileline_fn (state, pc, callback, error_callback, data);
317}
318
319/* Given a PC, find the symbol for it, and its value. */
320
321int
322backtrace_syminfo (struct backtrace_state *state, uintptr_t pc,
323 backtrace_syminfo_callback callback,
324 backtrace_error_callback error_callback, void *data)
325{
326 if (!fileline_initialize (state, error_callback, data))
327 return 0;
328
329 if (state->fileline_initialization_failed)
330 return 0;
331
332 state->syminfo_fn (state, pc, callback, error_callback, data);
333 return 1;
334}
335
336/* A backtrace_syminfo_callback that can call into a
337 backtrace_full_callback, used when we have a symbol table but no
338 debug info. */
339
340void
341backtrace_syminfo_to_full_callback (void *data, uintptr_t pc,
342 const char *symname,
343 uintptr_t symval ATTRIBUTE_UNUSED,
344 uintptr_t symsize ATTRIBUTE_UNUSED)
345{
346 struct backtrace_call_full *bdata = (struct backtrace_call_full *) data;
347
348 bdata->ret = bdata->full_callback (bdata->full_data, pc, NULL, 0, symname);
349}
350
351/* An error callback that corresponds to
352 backtrace_syminfo_to_full_callback. */
353
354void
355backtrace_syminfo_to_full_error_callback (void *data, const char *msg,
356 int errnum)
357{
358 struct backtrace_call_full *bdata = (struct backtrace_call_full *) data;
359
360 bdata->full_error_callback (bdata->full_data, msg, errnum);
361}
362

source code of libbacktrace/fileline.c