Branch data Line data Source code
1 : : /* Get Dwarf Frame state for target PID or core file.
2 : : Copyright (C) 2013, 2014 Red Hat, Inc.
3 : : This file is part of elfutils.
4 : :
5 : : This file is free software; you can redistribute it and/or modify
6 : : it under the terms of either
7 : :
8 : : * the GNU Lesser General Public License as published by the Free
9 : : Software Foundation; either version 3 of the License, or (at
10 : : your option) any later version
11 : :
12 : : or
13 : :
14 : : * the GNU General Public License as published by the Free
15 : : Software Foundation; either version 2 of the License, or (at
16 : : your option) any later version
17 : :
18 : : or both in parallel, as here.
19 : :
20 : : elfutils is distributed in the hope that it will be useful, but
21 : : WITHOUT ANY WARRANTY; without even the implied warranty of
22 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 : : General Public License for more details.
24 : :
25 : : You should have received copies of the GNU General Public License and
26 : : the GNU Lesser General Public License along with this program. If
27 : : not, see <http://www.gnu.org/licenses/>. */
28 : :
29 : : #ifdef HAVE_CONFIG_H
30 : : # include <config.h>
31 : : #endif
32 : :
33 : : #include <system.h>
34 : :
35 : : #include "libdwflP.h"
36 : :
37 : : /* Set STATE->pc_set from STATE->regs according to the backend. Return true on
38 : : success, false on error. */
39 : : static bool
40 : 84 : state_fetch_pc (Dwfl_Frame *state)
41 : : {
42 [ - + - + ]: 84 : switch (state->pc_state)
43 : : {
44 : : case DWFL_FRAME_STATE_PC_SET:
45 : : return true;
46 : 0 : case DWFL_FRAME_STATE_PC_UNDEFINED:
47 : 0 : abort ();
48 : 54 : case DWFL_FRAME_STATE_ERROR:
49 : : {
50 : 54 : Ebl *ebl = state->thread->process->ebl;
51 : 54 : Dwarf_CIE abi_info;
52 [ - + ]: 54 : if (ebl_abi_cfi (ebl, &abi_info) != 0)
53 : : {
54 : 0 : __libdwfl_seterrno (DWFL_E_LIBEBL);
55 : 0 : return false;
56 : : }
57 : 54 : unsigned ra = abi_info.return_address_register;
58 : : /* dwarf_frame_state_reg_is_set is not applied here. */
59 [ - + ]: 54 : if (ra >= ebl_frame_nregs (ebl))
60 : : {
61 : 0 : __libdwfl_seterrno (DWFL_E_LIBEBL_BAD);
62 : 0 : return false;
63 : : }
64 : 54 : state->pc = state->regs[ra] + ebl_ra_offset (ebl);
65 : 54 : state->pc_state = DWFL_FRAME_STATE_PC_SET;
66 : : }
67 : 54 : return true;
68 : : }
69 : 0 : abort ();
70 : : }
71 : :
72 : : /* Do not call it on your own, to be used by thread_* functions only. */
73 : :
74 : : static void
75 : 0 : free_states (Dwfl_Frame *state)
76 : : {
77 [ - - - - : 144 : while (state)
+ + - + +
+ ]
78 : : {
79 : 62 : Dwfl_Frame *next = state->unwound;
80 : 62 : free(state);
81 : 62 : state = next;
82 : : }
83 : : }
84 : :
85 : : static Dwfl_Frame *
86 : 84 : state_alloc (Dwfl_Thread *thread)
87 : : {
88 [ - + ]: 84 : assert (thread->unwound == NULL);
89 : 84 : Ebl *ebl = thread->process->ebl;
90 : 84 : size_t nregs = ebl_frame_nregs (ebl);
91 [ - + ]: 84 : if (nregs == 0)
92 : : return NULL;
93 [ - + ]: 84 : assert (nregs < sizeof (((Dwfl_Frame *) NULL)->regs_set) * 8);
94 : 84 : Dwfl_Frame *state = malloc (sizeof (*state) + sizeof (*state->regs) * nregs);
95 [ - + ]: 84 : if (state == NULL)
96 : : return NULL;
97 : 84 : state->thread = thread;
98 : 84 : state->signal_frame = false;
99 : 84 : state->initial_frame = true;
100 : 84 : state->pc_state = DWFL_FRAME_STATE_ERROR;
101 : 84 : memset (state->regs_set, 0, sizeof (state->regs_set));
102 : 84 : thread->unwound = state;
103 : 84 : state->unwound = NULL;
104 : 84 : return state;
105 : : }
106 : :
107 : : void
108 : : internal_function
109 : 100 : __libdwfl_process_free (Dwfl_Process *process)
110 : : {
111 : 100 : Dwfl *dwfl = process->dwfl;
112 [ + + ]: 100 : if (process->callbacks->detach != NULL)
113 : 98 : process->callbacks->detach (dwfl, process->callbacks_arg);
114 [ - + ]: 100 : assert (dwfl->process == process);
115 : 100 : dwfl->process = NULL;
116 [ + + ]: 100 : if (process->ebl_close)
117 : 98 : ebl_closebackend (process->ebl);
118 : 100 : free (process);
119 : 100 : dwfl->attacherr = DWFL_E_NOERROR;
120 : 100 : }
121 : :
122 : : /* Allocate new Dwfl_Process for DWFL. */
123 : : static void
124 : 102 : process_alloc (Dwfl *dwfl)
125 : : {
126 : 102 : Dwfl_Process *process = malloc (sizeof (*process));
127 [ + - ]: 102 : if (process == NULL)
128 : : return;
129 : 102 : process->dwfl = dwfl;
130 : 102 : dwfl->process = process;
131 : : }
132 : :
133 : : bool
134 : 102 : dwfl_attach_state (Dwfl *dwfl, Elf *elf, pid_t pid,
135 : : const Dwfl_Thread_Callbacks *thread_callbacks, void *arg)
136 : : {
137 [ - + ]: 102 : if (dwfl->process != NULL)
138 : : {
139 : 0 : __libdwfl_seterrno (DWFL_E_ATTACH_STATE_CONFLICT);
140 : 0 : return false;
141 : : }
142 : :
143 : : /* Reset any previous error, we are just going to try again. */
144 : 102 : dwfl->attacherr = DWFL_E_NOERROR;
145 : : /* thread_callbacks is declared NN */
146 [ + - ]: 102 : if (thread_callbacks->next_thread == NULL
147 [ - + ]: 102 : || thread_callbacks->set_initial_registers == NULL)
148 : : {
149 : 0 : dwfl->attacherr = DWFL_E_INVALID_ARGUMENT;
150 : 0 : fail:
151 : 0 : dwfl->attacherr = __libdwfl_canon_error (dwfl->attacherr);
152 : 0 : __libdwfl_seterrno (dwfl->attacherr);
153 : 0 : return false;
154 : : }
155 : :
156 : 102 : Ebl *ebl;
157 : 102 : bool ebl_close;
158 [ + + ]: 102 : if (elf != NULL)
159 : : {
160 : 100 : ebl = ebl_openbackend (elf);
161 : 100 : ebl_close = true;
162 : : }
163 : : else
164 : : {
165 : 2 : ebl = NULL;
166 [ + - ]: 2 : for (Dwfl_Module *mod = dwfl->modulelist; mod != NULL; mod = mod->next)
167 : : {
168 : : /* Reading of the vDSO or (deleted) modules may fail as
169 : : /proc/PID/mem is unreadable without PTRACE_ATTACH and
170 : : we may not be PTRACE_ATTACH-ed now. MOD would not be
171 : : re-read later to unwind it when we are already
172 : : PTRACE_ATTACH-ed to PID. This happens when this function
173 : : is called from dwfl_linux_proc_attach with elf == NULL.
174 : : __libdwfl_module_getebl will call __libdwfl_getelf which
175 : : will call the find_elf callback. */
176 [ + - ]: 2 : if (startswith (mod->name, "[vdso: ")
177 [ + - - + ]: 4 : || strcmp (strrchr (mod->name, ' ') ?: "",
178 : : " (deleted)") == 0)
179 : 0 : continue;
180 : 2 : Dwfl_Error error = __libdwfl_module_getebl (mod);
181 [ - + ]: 2 : if (error != DWFL_E_NOERROR)
182 : 0 : continue;
183 : 2 : ebl = mod->ebl;
184 : 2 : break;
185 : : }
186 : : ebl_close = false;
187 : : }
188 [ - + ]: 102 : if (ebl == NULL)
189 : : {
190 : : /* Not identified EBL from any of the modules. */
191 : 0 : dwfl->attacherr = DWFL_E_PROCESS_NO_ARCH;
192 : 0 : goto fail;
193 : : }
194 : 102 : process_alloc (dwfl);
195 : 102 : Dwfl_Process *process = dwfl->process;
196 [ - + ]: 102 : if (process == NULL)
197 : : {
198 [ # # ]: 0 : if (ebl_close)
199 : 0 : ebl_closebackend (ebl);
200 : 0 : dwfl->attacherr = DWFL_E_NOMEM;
201 : 0 : goto fail;
202 : : }
203 : 102 : process->ebl = ebl;
204 : 102 : process->ebl_close = ebl_close;
205 : 102 : process->pid = pid;
206 : 102 : process->callbacks = thread_callbacks;
207 : 102 : process->callbacks_arg = arg;
208 : 102 : return true;
209 : : }
210 : : INTDEF(dwfl_attach_state)
211 : :
212 : : pid_t
213 : 134 : dwfl_pid (Dwfl *dwfl)
214 : : {
215 [ - + ]: 134 : if (dwfl->attacherr != DWFL_E_NOERROR)
216 : : {
217 : 0 : __libdwfl_seterrno (dwfl->attacherr);
218 : 0 : return -1;
219 : : }
220 : :
221 [ - + ]: 134 : if (dwfl->process == NULL)
222 : : {
223 : 0 : __libdwfl_seterrno (DWFL_E_NO_ATTACH_STATE);
224 : 0 : return -1;
225 : : }
226 : 134 : return dwfl->process->pid;
227 : : }
228 : : INTDEF(dwfl_pid)
229 : :
230 : : Dwfl *
231 : 332 : dwfl_thread_dwfl (Dwfl_Thread *thread)
232 : : {
233 : 332 : return thread->process->dwfl;
234 : : }
235 : : INTDEF(dwfl_thread_dwfl)
236 : :
237 : : pid_t
238 : 480 : dwfl_thread_tid (Dwfl_Thread *thread)
239 : : {
240 : 480 : return thread->tid;
241 : : }
242 : : INTDEF(dwfl_thread_tid)
243 : :
244 : : Dwfl_Thread *
245 : 330 : dwfl_frame_thread (Dwfl_Frame *state)
246 : : {
247 : 330 : return state->thread;
248 : : }
249 : : INTDEF(dwfl_frame_thread)
250 : :
251 : : int
252 : 60 : dwfl_getthreads (Dwfl *dwfl, int (*callback) (Dwfl_Thread *thread, void *arg),
253 : : void *arg)
254 : : {
255 [ - + ]: 60 : if (dwfl->attacherr != DWFL_E_NOERROR)
256 : : {
257 : 0 : __libdwfl_seterrno (dwfl->attacherr);
258 : 0 : return -1;
259 : : }
260 : :
261 : 60 : Dwfl_Process *process = dwfl->process;
262 [ - + ]: 60 : if (process == NULL)
263 : : {
264 : 0 : __libdwfl_seterrno (DWFL_E_NO_ATTACH_STATE);
265 : 0 : return -1;
266 : : }
267 : :
268 : 60 : Dwfl_Thread thread;
269 : 60 : thread.process = process;
270 : 60 : thread.unwound = NULL;
271 : 60 : thread.callbacks_arg = NULL;
272 : 60 : thread.aarch64.pauth_insn_mask = 0;
273 : :
274 : 148 : for (;;)
275 : : {
276 : 148 : thread.tid = process->callbacks->next_thread (dwfl,
277 : : process->callbacks_arg,
278 : : &thread.callbacks_arg);
279 [ + - ]: 148 : if (thread.tid < 0)
280 : : return -1;
281 [ + + ]: 148 : if (thread.tid == 0)
282 : : {
283 : 58 : __libdwfl_seterrno (DWFL_E_NOERROR);
284 : 58 : return 0;
285 : : }
286 : 90 : int err = callback (&thread, arg);
287 [ - + ]: 88 : if (err != DWARF_CB_OK)
288 : 0 : return err;
289 [ + - ]: 88 : assert (thread.unwound == NULL);
290 : : }
291 : : /* NOTREACHED */
292 : : }
293 : : INTDEF(dwfl_getthreads)
294 : :
295 : : struct one_arg
296 : : {
297 : : pid_t tid;
298 : : bool seen;
299 : : int (*callback) (Dwfl_Thread *thread, void *arg);
300 : : void *arg;
301 : : int ret;
302 : : };
303 : :
304 : : static int
305 : 0 : get_one_thread_cb (Dwfl_Thread *thread, void *arg)
306 : : {
307 : 0 : struct one_arg *oa = (struct one_arg *) arg;
308 [ # # # # ]: 0 : if (! oa->seen && INTUSE(dwfl_thread_tid) (thread) == oa->tid)
309 : : {
310 : 0 : oa->seen = true;
311 : 0 : oa->ret = oa->callback (thread, oa->arg);
312 : 0 : return DWARF_CB_ABORT;
313 : : }
314 : :
315 : : return DWARF_CB_OK;
316 : : }
317 : :
318 : : /* Note not currently exported, will be when there are more Dwfl_Thread
319 : : properties to query. Use dwfl_getthread_frames for now directly. */
320 : : static int
321 : 0 : getthread (Dwfl *dwfl, pid_t tid,
322 : : int (*callback) (Dwfl_Thread *thread, void *arg),
323 : : void *arg)
324 : : {
325 [ # # ]: 0 : if (dwfl->attacherr != DWFL_E_NOERROR)
326 : : {
327 : 0 : __libdwfl_seterrno (dwfl->attacherr);
328 : 0 : return -1;
329 : : }
330 : :
331 : 0 : Dwfl_Process *process = dwfl->process;
332 [ # # ]: 0 : if (process == NULL)
333 : : {
334 : 0 : __libdwfl_seterrno (DWFL_E_NO_ATTACH_STATE);
335 : 0 : return -1;
336 : : }
337 : :
338 [ # # ]: 0 : if (process->callbacks->get_thread != NULL)
339 : : {
340 : 0 : Dwfl_Thread thread;
341 : 0 : thread.process = process;
342 : 0 : thread.unwound = NULL;
343 : 0 : thread.callbacks_arg = NULL;
344 : 0 : thread.aarch64.pauth_insn_mask = 0;
345 : :
346 [ # # ]: 0 : if (process->callbacks->get_thread (dwfl, tid, process->callbacks_arg,
347 : : &thread.callbacks_arg))
348 : : {
349 : 0 : thread.tid = tid;
350 : 0 : return callback (&thread, arg);
351 : : }
352 : :
353 : : return -1;
354 : : }
355 : :
356 : 0 : struct one_arg oa = { .tid = tid, .callback = callback,
357 : : .arg = arg, .seen = false };
358 : 0 : int err = INTUSE(dwfl_getthreads) (dwfl, get_one_thread_cb, &oa);
359 : :
360 [ # # # # ]: 0 : if (err == DWARF_CB_ABORT && oa.seen)
361 : 0 : return oa.ret;
362 : :
363 [ # # # # ]: 0 : if (err == DWARF_CB_OK && ! oa.seen)
364 : : {
365 : 0 : errno = ESRCH;
366 : 0 : __libdwfl_seterrno (DWFL_E_ERRNO);
367 : 0 : return -1;
368 : : }
369 : :
370 : : return err;
371 : : }
372 : :
373 : : struct one_thread
374 : : {
375 : : int (*callback) (Dwfl_Frame *frame, void *arg);
376 : : void *arg;
377 : : };
378 : :
379 : : static int
380 : 0 : get_one_thread_frames_cb (Dwfl_Thread *thread, void *arg)
381 : : {
382 : 0 : struct one_thread *ot = (struct one_thread *) arg;
383 : 0 : return INTUSE(dwfl_thread_getframes) (thread, ot->callback, ot->arg);
384 : : }
385 : :
386 : : int
387 : 0 : dwfl_getthread_frames (Dwfl *dwfl, pid_t tid,
388 : : int (*callback) (Dwfl_Frame *frame, void *arg),
389 : : void *arg)
390 : : {
391 : 0 : struct one_thread ot = { .callback = callback, .arg = arg };
392 : 0 : return getthread (dwfl, tid, get_one_thread_frames_cb, &ot);
393 : : }
394 : : INTDEF(dwfl_getthread_frames)
395 : :
396 : : int
397 : 84 : dwfl_thread_getframes (Dwfl_Thread *thread,
398 : : int (*callback) (Dwfl_Frame *state, void *arg),
399 : : void *arg)
400 : : {
401 : 84 : Ebl *ebl = thread->process->ebl;
402 [ - + ]: 84 : if (ebl_frame_nregs (ebl) == 0)
403 : : {
404 : 0 : __libdwfl_seterrno (DWFL_E_NO_UNWIND);
405 : 0 : return -1;
406 : : }
407 [ - + ]: 84 : if (state_alloc (thread) == NULL)
408 : : {
409 : 0 : __libdwfl_seterrno (DWFL_E_NOMEM);
410 : 0 : return -1;
411 : : }
412 : 84 : Dwfl_Process *process = thread->process;
413 [ - + ]: 84 : if (! process->callbacks->set_initial_registers (thread,
414 : : thread->callbacks_arg))
415 : : {
416 : 0 : free_states (thread->unwound);
417 : 0 : thread->unwound = NULL;
418 : 0 : return -1;
419 : : }
420 : 84 : Dwfl_Frame *state = thread->unwound;
421 : 84 : thread->unwound = NULL;
422 [ - + ]: 84 : if (! state_fetch_pc (state))
423 : : {
424 [ # # ]: 0 : if (process->callbacks->thread_detach)
425 : 0 : process->callbacks->thread_detach (thread, thread->callbacks_arg);
426 : 34 : free_states (state);
427 : : return -1;
428 : : }
429 : 422 : do
430 : : {
431 : 422 : int err = callback (state, arg);
432 [ + + ]: 420 : if (err != DWARF_CB_OK)
433 : : {
434 [ - + ]: 14 : if (process->callbacks->thread_detach)
435 : 0 : process->callbacks->thread_detach (thread, thread->callbacks_arg);
436 : 82 : free_states (state);
437 : : return err;
438 : : }
439 : 406 : __libdwfl_frame_unwind (state);
440 : 406 : Dwfl_Frame *next = state->unwound;
441 : : /* The old frame is no longer needed. */
442 : 406 : free (state);
443 : 406 : state = next;
444 : : }
445 [ + + + + ]: 406 : while (state && state->pc_state == DWFL_FRAME_STATE_PC_SET);
446 : :
447 : 68 : Dwfl_Error err = dwfl_errno ();
448 [ + + ]: 68 : if (process->callbacks->thread_detach)
449 : 6 : process->callbacks->thread_detach (thread, thread->callbacks_arg);
450 [ + + - + ]: 68 : if (state == NULL || state->pc_state == DWFL_FRAME_STATE_ERROR)
451 : : {
452 : 34 : free_states (state);
453 : 34 : __libdwfl_seterrno (err);
454 : 34 : return -1;
455 : : }
456 [ - + ]: 34 : assert (state->pc_state == DWFL_FRAME_STATE_PC_UNDEFINED);
457 : 82 : free_states (state);
458 : : return 0;
459 : : }
460 : : INTDEF(dwfl_thread_getframes)
|
