libdwfl/dwfl_frame.c

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