gnu/usr.bin/gdb/libgdb/fbsd-threads.c

   1 /* $FreeBSD$ */
   2 /* FreeBSD libthread_db assisted debugging support.
   3    Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include <dlfcn.h>
  23 #include <sys/types.h>
  24 #include <sys/ptrace.h>
  25 #include <signal.h>
  26
  27 #include "proc_service.h"
  28 #include "thread_db.h"
  29
  30 #include "defs.h"
  31 #include "bfd.h"
  32 #include "elf-bfd.h"
  33 #include "gdb_assert.h"
  34 #include "gdbcore.h"
  35 #include "gdbthread.h"
  36 #include "inferior.h"
  37 #include "objfiles.h"
  38 #include "regcache.h"
  39 #include "symfile.h"
  40 #include "symtab.h"
  41 #include "target.h"
  42 #include "gdbcmd.h"
  43 #include "solib-svr4.h"
  44
  45 #include "gregset.h"
  46 #ifdef PT_GETXMMREGS
  47 #include "i387-tdep.h"
  48 #endif
  49
  50 #define LIBTHREAD_DB_SO "libthread_db.so"
  51
  52 struct ps_prochandle
  53 {
  54   pid_t pid;
  55 };
  56
  57 extern int child_suppress_run;
  58
  59 extern struct target_ops child_ops;
  60
  61 /* This module's target vectors.  */
  62 static struct target_ops fbsd_thread_ops;
  63 static struct target_ops fbsd_core_ops;
  64
  65 /* Saved copy of orignal core_ops. */
  66 static struct target_ops orig_core_ops;
  67 extern struct target_ops core_ops;
  68
  69 /* Pointer to the next function on the objfile event chain.  */
  70 static void (*target_new_objfile_chain) (struct objfile *objfile);
  71
  72 /* Non-zero if there is a thread module */
  73 static int fbsd_thread_present;
  74
  75 /* Non-zero if we're using this module's target vector.  */
  76 static int fbsd_thread_active;
  77
  78 /* Non-zero if core_open is called */
  79 static int fbsd_thread_core = 0;
  80
  81 /* Non-zero if we have to keep this module's target vector active
  82    across re-runs.  */
  83 static int keep_thread_db;
  84
  85 /* Structure that identifies the child process for the
  86    <proc_service.h> interface.  */
  87 static struct ps_prochandle proc_handle;
  88
  89 /* Connection to the libthread_db library.  */
  90 static td_thragent_t *thread_agent;
  91
  92 /* The last thread we are single stepping */
  93 static ptid_t last_single_step_thread;
  94
  95 /* Pointers to the libthread_db functions.  */
  96
  97 static td_err_e (*td_init_p) (void);
  98
  99 static td_err_e (*td_ta_new_p) (struct ps_prochandle *ps, td_thragent_t **ta);
 100 static td_err_e (*td_ta_delete_p) (td_thragent_t *);
 101 static td_err_e (*td_ta_map_id2thr_p) (const td_thragent_t *ta, thread_t pt,
 102                                        td_thrhandle_t *__th);
 103 static td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta, lwpid_t lwpid,
 104                                         td_thrhandle_t *th);
 105 static td_err_e (*td_ta_thr_iter_p) (const td_thragent_t *ta,
 106                                      td_thr_iter_f *callback,
 107                                      void *cbdata_p, td_thr_state_e state,
 108                                      int ti_pri, sigset_t *ti_sigmask_p,
 109                                      unsigned int ti_user_flags);
 110 static td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta,
 111                                        td_event_e event, td_notify_t *ptr);
 112 static td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta,
 113                                       td_thr_events_t *event);
 114 static td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta,
 115                                          td_event_msg_t *msg);
 116 static td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th,
 117                                       td_thrinfo_t *infop);
 118 #ifdef PT_GETXMMREGS
 119 static td_err_e (*td_thr_getxmmregs_p) (const td_thrhandle_t *th,
 120                                         char *regset);
 121 #endif
 122 static td_err_e (*td_thr_getfpregs_p) (const td_thrhandle_t *th,
 123                                        prfpregset_t *regset);
 124 static td_err_e (*td_thr_getgregs_p) (const td_thrhandle_t *th,
 125                                       prgregset_t gregs);
 126 #ifdef PT_GETXMMREGS
 127 static td_err_e (*td_thr_setxmmregs_p) (const td_thrhandle_t *th,
 128                                         const char *fpregs);
 129 #endif
 130 static td_err_e (*td_thr_setfpregs_p) (const td_thrhandle_t *th,
 131                                        const prfpregset_t *fpregs);
 132 static td_err_e (*td_thr_setgregs_p) (const td_thrhandle_t *th,
 133                                       prgregset_t gregs);
 134 static td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th, int event);
 135
 136 static td_err_e (*td_thr_sstep_p) (td_thrhandle_t *th, int step);
 137
 138 static td_err_e (*td_ta_tsd_iter_p) (const td_thragent_t *ta,
 139                                  td_key_iter_f *func, void *data);
 140 static td_err_e (*td_thr_tls_get_addr_p) (const td_thrhandle_t *th,
 141                                           void *map_address,
 142                                           size_t offset, void **address);
 143 static td_err_e (*td_thr_dbsuspend_p) (const td_thrhandle_t *);
 144 static td_err_e (*td_thr_dbresume_p) (const td_thrhandle_t *);
 145
 146 static CORE_ADDR td_create_bp_addr;
 147
 148 /* Location of the thread death event breakpoint.  */
 149 static CORE_ADDR td_death_bp_addr;
 150
 151 /* Prototypes for local functions.  */
 152 static void fbsd_thread_find_new_threads (void);
 153 static int fbsd_thread_alive (ptid_t ptid);
 154 static void attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
 155                const td_thrinfo_t *ti_p, int verbose);
 156 static void fbsd_thread_detach (char *args, int from_tty);
 157
 158 /* Building process ids.  */
 159
 160 #define GET_PID(ptid)           ptid_get_pid (ptid)
 161 #define GET_LWP(ptid)           ptid_get_lwp (ptid)
 162 #define GET_THREAD(ptid)        ptid_get_tid (ptid)
 163
 164 #define IS_LWP(ptid)            (GET_LWP (ptid) != 0)
 165 #define IS_THREAD(ptid)         (GET_THREAD (ptid) != 0)
 166
 167 #define BUILD_LWP(lwp, pid)     ptid_build (pid, lwp, 0)
 168 #define BUILD_THREAD(tid, pid)  ptid_build (pid, 0, tid)
 169
 170 static char *
 171 thread_db_err_str (td_err_e err)
 172 {
 173   static char buf[64];
 174
 175   switch (err)
 176     {
 177     case TD_OK:
 178       return "generic 'call succeeded'";
 179     case TD_ERR:
 180       return "generic error";
 181     case TD_NOTHR:
 182       return "no thread to satisfy query";
 183     case TD_NOSV:
 184       return "no sync handle to satisfy query";
 185     case TD_NOLWP:
 186       return "no LWP to satisfy query";
 187     case TD_BADPH:
 188       return "invalid process handle";
 189     case TD_BADTH:
 190       return "invalid thread handle";
 191     case TD_BADSH:
 192       return "invalid synchronization handle";
 193     case TD_BADTA:
 194       return "invalid thread agent";
 195     case TD_BADKEY:
 196       return "invalid key";
 197     case TD_NOMSG:
 198       return "no event message for getmsg";
 199     case TD_NOFPREGS:
 200       return "FPU register set not available";
 201     case TD_NOLIBTHREAD:
 202       return "application not linked with libthread";
 203     case TD_NOEVENT:
 204       return "requested event is not supported";
 205     case TD_NOCAPAB:
 206       return "capability not available";
 207     case TD_DBERR:
 208       return "debugger service failed";
 209     case TD_NOAPLIC:
 210       return "operation not applicable to";
 211     case TD_NOTSD:
 212       return "no thread-specific data for this thread";
 213     case TD_MALLOC:
 214       return "malloc failed";
 215     case TD_PARTIALREG:
 216       return "only part of register set was written/read";
 217     case TD_NOXREGS:
 218       return "X register set not available for this thread";
 219     default:
 220       snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err);
 221       return buf;
 222     }
 223 }
 224
 225 static char *
 226 thread_db_state_str (td_thr_state_e state)
 227 {
 228   static char buf[64];
 229
 230   switch (state)
 231     {
 232     case TD_THR_STOPPED:
 233       return "stopped by debugger";
 234     case TD_THR_RUN:
 235       return "runnable";
 236     case TD_THR_ACTIVE:
 237       return "active";
 238     case TD_THR_ZOMBIE:
 239       return "zombie";
 240     case TD_THR_SLEEP:
 241       return "sleeping";
 242     case TD_THR_STOPPED_ASLEEP:
 243       return "stopped by debugger AND blocked";
 244     default:
 245       snprintf (buf, sizeof (buf), "unknown thread_db state %d", state);
 246       return buf;
 247     }
 248 }
 249
 250 /* Convert LWP to user-level thread id. */
 251 static ptid_t
 252 thread_from_lwp (ptid_t ptid, td_thrhandle_t *th, td_thrinfo_t *ti)
 253 {
 254   td_err_e err;
 255
 256   gdb_assert (IS_LWP (ptid));
 257
 258   if (fbsd_thread_active)
 259     {
 260       err = td_ta_map_lwp2thr_p (thread_agent, GET_LWP (ptid), th);
 261       if (err == TD_OK)
 262         {
 263           err = td_thr_get_info_p (th, ti);
 264           if (err != TD_OK)
 265             error ("Cannot get thread info: %s", thread_db_err_str (err));
 266           return BUILD_THREAD (ti->ti_tid, GET_PID (ptid));
 267         }
 268     }
 269
 270   /* the LWP is not mapped to user thread */
 271   return BUILD_LWP (GET_LWP (ptid), GET_PID (ptid));
 272 }
 273
 274 static void
 275 fbsd_core_get_first_lwp (bfd *abfd, asection *asect, void *obj)
 276 {
 277   if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
 278     return;
 279
 280   if (*(lwpid_t *)obj != 0)
 281     return;
 282
 283   *(lwpid_t *)obj = atoi (bfd_section_name (abfd, asect) + 5);
 284 }
 285
 286 static long
 287 get_current_lwp (int pid)
 288 {
 289   struct ptrace_lwpinfo pl;
 290   lwpid_t lwpid;
 291
 292   if (!target_has_execution)
 293     {
 294       lwpid = 0;
 295       bfd_map_over_sections (core_bfd, fbsd_core_get_first_lwp, &lwpid);
 296       return lwpid;
 297     }
 298   if (ptrace (PT_LWPINFO, pid, (caddr_t)&pl, sizeof(pl)))
 299     perror_with_name("PT_LWPINFO");
 300
 301   return (long)pl.pl_lwpid;
 302 }
 303
 304 static void
 305 get_current_thread ()
 306 {
 307   td_thrhandle_t th;
 308   td_thrinfo_t ti;
 309   long lwp;
 310   ptid_t tmp, ptid;
 311
 312   lwp = get_current_lwp (proc_handle.pid);
 313   tmp = BUILD_LWP (lwp, proc_handle.pid);
 314   ptid = thread_from_lwp (tmp, &th, &ti);
 315   if (!in_thread_list (ptid))
 316     {
 317       attach_thread (ptid, &th, &ti, 1);
 318     }
 319   inferior_ptid = ptid;
 320 }
 321
 322 static td_err_e
 323 enable_thread_event (td_thragent_t *thread_agent, int event, CORE_ADDR *bp)
 324 {
 325   td_notify_t notify;
 326   td_err_e err;
 327
 328   /* Get the breakpoint address for thread EVENT.  */
 329   err = td_ta_event_addr_p (thread_agent, event, &notify);
 330   if (err != TD_OK)
 331     return err;
 332
 333   /* Set up the breakpoint.  */
 334   (*bp) = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
 335             extract_typed_address(&notify.u.bptaddr, builtin_type_void_func_ptr),
 336             &current_target);
 337   create_thread_event_breakpoint ((*bp));
 338
 339   return TD_OK;
 340 }
 341
 342 static void
 343 enable_thread_event_reporting (void)
 344 {
 345   td_thr_events_t events;
 346   td_notify_t notify;
 347   td_err_e err;
 348
 349   /* We cannot use the thread event reporting facility if these
 350      functions aren't available.  */
 351   if (td_ta_event_addr_p == NULL || td_ta_set_event_p == NULL
 352       || td_ta_event_getmsg_p == NULL || td_thr_event_enable_p == NULL)
 353     return;
 354
 355   /* Set the process wide mask saying which events we're interested in.  */
 356   td_event_emptyset (&events);
 357   td_event_addset (&events, TD_CREATE);
 358   td_event_addset (&events, TD_DEATH);
 359
 360   err = td_ta_set_event_p (thread_agent, &events);
 361   if (err != TD_OK)
 362     {
 363       warning ("Unable to set global thread event mask: %s",
 364                thread_db_err_str (err));
 365       return;
 366     }
 367
 368   /* Delete previous thread event breakpoints, if any.  */
 369   remove_thread_event_breakpoints ();
 370   td_create_bp_addr = 0;
 371   td_death_bp_addr = 0;
 372
 373   /* Set up the thread creation event.  */
 374   err = enable_thread_event (thread_agent, TD_CREATE, &td_create_bp_addr);
 375   if (err != TD_OK)
 376     {
 377       warning ("Unable to get location for thread creation breakpoint: %s",
 378                thread_db_err_str (err));
 379       return;
 380     }
 381
 382   /* Set up the thread death event.  */
 383   err = enable_thread_event (thread_agent, TD_DEATH, &td_death_bp_addr);
 384   if (err != TD_OK)
 385     {
 386       warning ("Unable to get location for thread death breakpoint: %s",
 387                thread_db_err_str (err));
 388       return;
 389     }
 390 }
 391
 392 static void
 393 disable_thread_event_reporting (void)
 394 {
 395   td_thr_events_t events;
 396
 397   /* Set the process wide mask saying we aren't interested in any
 398      events anymore.  */
 399   td_event_emptyset (&events);
 400   td_ta_set_event_p (thread_agent, &events);
 401
 402   /* Delete thread event breakpoints, if any.  */
 403   remove_thread_event_breakpoints ();
 404   td_create_bp_addr = 0;
 405   td_death_bp_addr = 0;
 406 }
 407
 408 static void
 409 fbsd_thread_activate (void)
 410 {
 411   fbsd_thread_active = 1;
 412   init_thread_list();
 413   if (fbsd_thread_core == 0)
 414     enable_thread_event_reporting ();
 415   fbsd_thread_find_new_threads ();
 416   get_current_thread ();
 417 }
 418
 419 static void
 420 fbsd_thread_deactivate (void)
 421 {
 422   if (fbsd_thread_core == 0)
 423     disable_thread_event_reporting();
 424   td_ta_delete_p (thread_agent);
 425
 426   inferior_ptid = pid_to_ptid (proc_handle.pid);
 427   proc_handle.pid = 0;
 428   fbsd_thread_active = 0;
 429   fbsd_thread_present = 0;
 430   init_thread_list ();
 431 }
 432
 433 static char *
 434 fbsd_thread_get_name (lwpid_t lwpid)
 435 {
 436   static char last_thr_name[MAXCOMLEN + 1];
 437   char section_name[32];
 438   struct ptrace_lwpinfo lwpinfo;
 439   bfd_size_type size;
 440   struct bfd_section *section;
 441
 442   if (target_has_execution)
 443     {
 444       if (ptrace (PT_LWPINFO, lwpid, (caddr_t)&lwpinfo, sizeof (lwpinfo)) == -1)
 445         goto fail;
 446       strncpy (last_thr_name, lwpinfo.pl_tdname, sizeof (last_thr_name) - 1);
 447     }
 448   else
 449     {
 450       snprintf (section_name, sizeof (section_name), ".tname/%u", lwpid);
 451       section = bfd_get_section_by_name (core_bfd, section_name);
 452       if (! section)
 453         goto fail;
 454
 455       /* Section size fix-up. */
 456       size = bfd_section_size (core_bfd, section);
 457       if (size > sizeof (last_thr_name))
 458         size = sizeof (last_thr_name);
 459
 460       if (! bfd_get_section_contents (core_bfd, section, last_thr_name,
 461                (file_ptr)0, size))
 462         goto fail;
 463       if (last_thr_name[0] == '\0')
 464         goto fail;
 465     }
 466     last_thr_name[sizeof (last_thr_name) - 1] = '\0';
 467     return last_thr_name;
 468 fail:
 469      strcpy (last_thr_name, "<unknown>");
 470      return last_thr_name;
 471 }
 472
 473 static void
 474 fbsd_thread_new_objfile (struct objfile *objfile)
 475 {
 476   td_err_e err;
 477
 478   if (objfile == NULL)
 479     {
 480       /* All symbols have been discarded.  If the thread_db target is
 481          active, deactivate it now.  */
 482       if (fbsd_thread_active)
 483         {
 484           gdb_assert (proc_handle.pid == 0);
 485           fbsd_thread_active = 0;
 486         }
 487
 488       goto quit;
 489     }
 490
 491   if (!child_suppress_run)
 492     goto quit;
 493
 494   /* Nothing to do.  The thread library was already detected and the
 495      target vector was already activated.  */
 496   if (fbsd_thread_active)
 497     goto quit;
 498
 499   /* Initialize the structure that identifies the child process.  Note
 500      that at this point there is no guarantee that we actually have a
 501      child process.  */
 502   proc_handle.pid = GET_PID (inferior_ptid);
 503
 504   /* Now attempt to open a connection to the thread library.  */
 505   err = td_ta_new_p (&proc_handle, &thread_agent);
 506   switch (err)
 507     {
 508     case TD_NOLIBTHREAD:
 509       /* No thread library was detected.  */
 510       break;
 511
 512     case TD_OK:
 513       /* The thread library was detected.  Activate the thread_db target.  */
 514       fbsd_thread_present = 1;
 515
 516       /* We can only poke around if there actually is a child process.
 517          If there is no child process alive, postpone the steps below
 518          until one has been created.  */
 519       if (fbsd_thread_core == 0 && proc_handle.pid != 0)
 520         {
 521           push_target(&fbsd_thread_ops);
 522           fbsd_thread_activate();
 523         }
 524       else
 525         {
 526           td_ta_delete_p(thread_agent);
 527           thread_agent = NULL;
 528         }
 529       break;
 530
 531     default:
 532       warning ("Cannot initialize thread debugging library: %s",
 533                thread_db_err_str (err));
 534       break;
 535     }
 536
 537  quit:
 538   if (target_new_objfile_chain)
 539     target_new_objfile_chain (objfile);
 540 }
 541
 542 static void
 543 fbsd_thread_attach (char *args, int from_tty)
 544 {
 545   fbsd_thread_core = 0;
 546
 547   child_ops.to_attach (args, from_tty);
 548
 549   /* Must get symbols from solibs before libthread_db can run! */
 550   SOLIB_ADD ((char *) 0, from_tty, (struct target_ops *) 0, auto_solib_add);
 551
 552   if (fbsd_thread_present && !fbsd_thread_active)
 553     push_target(&fbsd_thread_ops);
 554 }
 555
 556 static void
 557 fbsd_thread_post_attach (int pid)
 558 {
 559   child_ops.to_post_attach (pid);
 560
 561   if (fbsd_thread_present && !fbsd_thread_active)
 562     {
 563       proc_handle.pid = GET_PID (inferior_ptid);
 564       fbsd_thread_activate ();
 565     }
 566 }
 567
 568 static void
 569 fbsd_thread_detach (char *args, int from_tty)
 570 {
 571   fbsd_thread_deactivate ();
 572   unpush_target (&fbsd_thread_ops);
 573
 574   /* Clear gdb solib information and symbol file
 575      cache, so that after detach and re-attach, new_objfile
 576      hook will be called */
 577
 578   clear_solib();
 579   symbol_file_clear(0);
 580   proc_handle.pid = 0;
 581   child_ops.to_detach (args, from_tty);
 582 }
 583
 584 static int
 585 suspend_thread_callback (const td_thrhandle_t *th_p, void *data)
 586 {
 587   int err = td_thr_dbsuspend_p (th_p);
 588   if (err != 0)
 589         fprintf_filtered(gdb_stderr, "%s %s\n", __func__, thread_db_err_str (err));
 590   return (err);
 591 }
 592
 593 static int
 594 resume_thread_callback (const td_thrhandle_t *th_p, void *data)
 595 {
 596   int err = td_thr_dbresume_p (th_p);
 597   if (err != 0)
 598         fprintf_filtered(gdb_stderr, "%s %s\n", __func__, thread_db_err_str (err));
 599   return (err);
 600 }
 601
 602 static void
 603 fbsd_thread_resume (ptid_t ptid, int step, enum target_signal signo)
 604 {
 605   td_thrhandle_t th;
 606   td_thrinfo_t ti;
 607   ptid_t work_ptid;
 608   int resume_all, ret;
 609   long lwp, thvalid = 0;
 610
 611   if (!fbsd_thread_active)
 612     {
 613       child_ops.to_resume (ptid, step, signo);
 614       return;
 615     }
 616
 617   if (GET_PID(ptid) != -1 && step != 0)
 618     {
 619       resume_all = 0;
 620       work_ptid = ptid;
 621     }
 622   else
 623     {
 624       resume_all = 1;
 625       work_ptid = inferior_ptid;
 626     }
 627
 628   lwp = GET_LWP (work_ptid);
 629   if (lwp == 0)
 630     {
 631       /* check user thread */
 632       ret = td_ta_map_id2thr_p (thread_agent, GET_THREAD(work_ptid), &th);
 633       if (ret)
 634         error (thread_db_err_str (ret));
 635
 636       /* For M:N thread, we need to tell UTS to set/unset single step
 637          flag at context switch time, the flag will be written into
 638          thread mailbox. This becauses some architecture may not have
 639          machine single step flag in ucontext, so we put the flag in mailbox,
 640          when the thread switches back, kse_switchin restores the single step
 641          state.  */
 642       ret = td_thr_sstep_p (&th, step);
 643       if (ret)
 644         error (thread_db_err_str (ret));
 645       ret = td_thr_get_info_p (&th, &ti);
 646       if (ret)
 647         error (thread_db_err_str (ret));
 648       thvalid = 1;
 649       lwp = ti.ti_lid;
 650     }
 651
 652   if (lwp)
 653     {
 654       int req = step ? PT_SETSTEP : PT_CLEARSTEP;
 655       if (ptrace (req, (pid_t) lwp, (caddr_t) 1, target_signal_to_host(signo)))
 656         perror_with_name ("PT_SETSTEP/PT_CLEARSTEP");
 657     }
 658
 659   if (!ptid_equal (last_single_step_thread, null_ptid))
 660     {
 661        ret = td_ta_thr_iter_p (thread_agent, resume_thread_callback, NULL,
 662           TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
 663           TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
 664       if (ret != TD_OK)
 665         error ("resume error: %s", thread_db_err_str (ret));
 666     }
 667
 668   if (!resume_all)
 669     {
 670       ret = td_ta_thr_iter_p (thread_agent, suspend_thread_callback, NULL,
 671           TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
 672           TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
 673       if (ret != TD_OK)
 674         error ("suspend error: %s", thread_db_err_str (ret));
 675       last_single_step_thread = work_ptid;
 676     }
 677   else
 678     last_single_step_thread = null_ptid;
 679
 680   if (thvalid)
 681     {
 682       ret = td_thr_dbresume_p (&th);
 683       if (ret != TD_OK)
 684         error ("resume error: %s", thread_db_err_str (ret));
 685     }
 686   else
 687     {
 688       /* it is not necessary, put it here for completness */
 689       ret = ptrace(PT_RESUME, lwp, 0, 0);
 690     }
 691
 692   /* now continue the process, suspended thread wont run */
 693   if (ptrace (PT_CONTINUE, proc_handle.pid , (caddr_t)1,
 694               target_signal_to_host(signo)))
 695     perror_with_name ("PT_CONTINUE");
 696 }
 697
 698 static void
 699 attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
 700                const td_thrinfo_t *ti_p, int verbose)
 701 {
 702   td_err_e err;
 703
 704   /* Add the thread to GDB's thread list.  */
 705   if (!in_thread_list (ptid)) {
 706     add_thread (ptid);
 707     if (verbose)
 708       printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid));
 709   }
 710
 711   if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
 712     return;                     /* A zombie thread -- do not attach.  */
 713
 714   if (! IS_THREAD(ptid))
 715     return;
 716   if (fbsd_thread_core != 0)
 717     return;
 718   /* Enable thread event reporting for this thread. */
 719   err = td_thr_event_enable_p (th_p, 1);
 720   if (err != TD_OK)
 721     error ("Cannot enable thread event reporting for %s: %s",
 722            target_pid_to_str (ptid), thread_db_err_str (err));
 723 }
 724
 725 static void
 726 detach_thread (ptid_t ptid, int verbose)
 727 {
 728   if (verbose)
 729     printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid));
 730 }
 731
 732 static void
 733 check_event (ptid_t ptid)
 734 {
 735   td_event_msg_t msg;
 736   td_thrinfo_t ti;
 737   td_err_e err;
 738   CORE_ADDR stop_pc;
 739   int loop = 0;
 740
 741   /* Bail out early if we're not at a thread event breakpoint.  */
 742   stop_pc = read_pc_pid (ptid) - DECR_PC_AFTER_BREAK;
 743   if (stop_pc != td_create_bp_addr && stop_pc != td_death_bp_addr)
 744     return;
 745   loop = 1;
 746
 747   do
 748     {
 749       err = td_ta_event_getmsg_p (thread_agent, &msg);
 750       if (err != TD_OK)
 751         {
 752           if (err == TD_NOMSG)
 753             return;
 754           error ("Cannot get thread event message: %s",
 755                  thread_db_err_str (err));
 756         }
 757       err = td_thr_get_info_p ((void *)(uintptr_t)msg.th_p, &ti);
 758       if (err != TD_OK)
 759         error ("Cannot get thread info: %s", thread_db_err_str (err));
 760       ptid = BUILD_THREAD (ti.ti_tid, GET_PID (ptid));
 761       switch (msg.event)
 762         {
 763         case TD_CREATE:
 764           /* We may already know about this thread, for instance when the
 765              user has issued the `info threads' command before the SIGTRAP
 766              for hitting the thread creation breakpoint was reported.  */
 767           attach_thread (ptid, (void *)(uintptr_t)msg.th_p, &ti, 1);
 768           break;
 769        case TD_DEATH:
 770          if (!in_thread_list (ptid))
 771            error ("Spurious thread death event.");
 772          detach_thread (ptid, 1);
 773          break;
 774        default:
 775           error ("Spurious thread event.");
 776        }
 777     }
 778   while (loop);
 779 }
 780
 781 static ptid_t
 782 fbsd_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 783 {
 784   ptid_t ret;
 785   long lwp;
 786   CORE_ADDR stop_pc;
 787   td_thrhandle_t th;
 788   td_thrinfo_t ti;
 789
 790   ret = child_ops.to_wait (ptid, ourstatus);
 791   if (GET_PID(ret) >= 0 && ourstatus->kind == TARGET_WAITKIND_STOPPED)
 792     {
 793       lwp = get_current_lwp (GET_PID(ret));
 794       ret = thread_from_lwp (BUILD_LWP(lwp, GET_PID(ret)),
 795          &th, &ti);
 796       if (!in_thread_list(ret)) {
 797         /*
 798          * We have to enable event reporting for initial thread
 799          * which was not mapped before.
 800          */
 801         attach_thread(ret, &th, &ti, 1);
 802       }
 803       if (ourstatus->value.sig == TARGET_SIGNAL_TRAP)
 804         check_event(ret);
 805       /* this is a hack, if an event won't cause gdb to stop, for example,
 806          SIGARLM, gdb resumes the process immediatly without setting
 807          inferior_ptid to the new thread returned here, this is a bug
 808          because inferior_ptid may already not exist there, and passing
 809          a none existing thread to fbsd_thread_resume causes error. */
 810       if (!fbsd_thread_alive (inferior_ptid))
 811         {
 812           delete_thread (inferior_ptid);
 813           inferior_ptid = ret;
 814         }
 815     }
 816
 817   return (ret);
 818 }
 819
 820 static int
 821 fbsd_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 822                         struct mem_attrib *attrib, struct target_ops *target)
 823 {
 824   int err;
 825
 826   if (target_has_execution)
 827     err = child_ops.to_xfer_memory (memaddr, myaddr, len, write, attrib,
 828         target);
 829   else
 830     err = orig_core_ops.to_xfer_memory (memaddr, myaddr, len, write, attrib,
 831         target);
 832
 833   return (err);
 834 }
 835
 836 static void
 837 fbsd_lwp_fetch_registers (int regno)
 838 {
 839   gregset_t gregs;
 840   fpregset_t fpregs;
 841   lwpid_t lwp;
 842 #ifdef PT_GETXMMREGS
 843   char xmmregs[512];
 844 #endif
 845
 846   if (!target_has_execution)
 847     {
 848       orig_core_ops.to_fetch_registers (-1);
 849       return;
 850     }
 851
 852   /* XXX: We've replaced the pid with the lwpid for GDB's benefit. */
 853   lwp = GET_PID (inferior_ptid);
 854
 855   if (ptrace (PT_GETREGS, lwp, (caddr_t) &gregs, 0) == -1)
 856     error ("Cannot get lwp %d registers: %s\n", lwp, safe_strerror (errno));
 857   supply_gregset (&gregs);
 858
 859 #ifdef PT_GETXMMREGS
 860   if (ptrace (PT_GETXMMREGS, lwp, xmmregs, 0) == 0)
 861     {
 862       i387_supply_fxsave (current_regcache, -1, xmmregs);
 863     }
 864   else
 865     {
 866 #endif
 867       if (ptrace (PT_GETFPREGS, lwp, (caddr_t) &fpregs, 0) == -1)
 868         error ("Cannot get lwp %d registers: %s\n ", lwp, safe_strerror (errno));
 869       supply_fpregset (&fpregs);
 870 #ifdef PT_GETXMMREGS
 871     }
 872 #endif
 873 }
 874
 875 static void
 876 fbsd_thread_fetch_registers (int regno)
 877 {
 878   prgregset_t gregset;
 879   prfpregset_t fpregset;
 880   td_thrhandle_t th;
 881   td_err_e err;
 882 #ifdef PT_GETXMMREGS
 883   char xmmregs[512];
 884 #endif
 885
 886   if (!IS_THREAD (inferior_ptid))
 887     {
 888       fbsd_lwp_fetch_registers (regno);
 889       return;
 890     }
 891
 892   err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (inferior_ptid), &th);
 893   if (err != TD_OK)
 894     error ("Cannot find thread %d: Thread ID=%ld, %s",
 895            pid_to_thread_id (inferior_ptid),
 896            GET_THREAD (inferior_ptid), thread_db_err_str (err));
 897
 898   err = td_thr_getgregs_p (&th, gregset);
 899   if (err != TD_OK)
 900     error ("Cannot fetch general-purpose registers for thread %d: Thread ID=%ld, %s",
 901            pid_to_thread_id (inferior_ptid),
 902            GET_THREAD (inferior_ptid), thread_db_err_str (err));
 903 #ifdef PT_GETXMMREGS
 904   err = td_thr_getxmmregs_p (&th, xmmregs);
 905   if (err == TD_OK)
 906     {
 907       i387_supply_fxsave (current_regcache, -1, xmmregs);
 908     }
 909   else
 910     {
 911 #endif
 912       err = td_thr_getfpregs_p (&th, &fpregset);
 913       if (err != TD_OK)
 914         error ("Cannot get floating-point registers for thread %d: Thread ID=%ld, %s",
 915                pid_to_thread_id (inferior_ptid),
 916                GET_THREAD (inferior_ptid), thread_db_err_str (err));
 917       supply_fpregset (&fpregset);
 918 #ifdef PT_GETXMMREGS
 919     }
 920 #endif
 921
 922   supply_gregset (gregset);
 923 }
 924
 925 static void
 926 fbsd_lwp_store_registers (int regno)
 927 {
 928   gregset_t gregs;
 929   fpregset_t fpregs;
 930   lwpid_t lwp;
 931 #ifdef PT_GETXMMREGS
 932   char xmmregs[512];
 933 #endif
 934
 935   /* FIXME, is it possible ? */
 936   if (!IS_LWP (inferior_ptid))
 937     {
 938       child_ops.to_store_registers (regno);
 939       return ;
 940     }
 941
 942   lwp = GET_LWP (inferior_ptid);
 943   if (regno != -1)
 944     if (ptrace (PT_GETREGS, lwp, (caddr_t) &gregs, 0) == -1)
 945       error ("Cannot get lwp %d registers: %s\n", lwp, safe_strerror (errno));
 946
 947   fill_gregset (&gregs, regno);
 948   if (ptrace (PT_SETREGS, lwp, (caddr_t) &gregs, 0) == -1)
 949       error ("Cannot set lwp %d registers: %s\n", lwp, safe_strerror (errno));
 950
 951 #ifdef PT_GETXMMREGS
 952   if (regno != -1)
 953     if (ptrace (PT_GETXMMREGS, lwp, xmmregs, 0) == -1)
 954       goto noxmm;
 955
 956   i387_fill_fxsave (xmmregs, regno);
 957   if (ptrace (PT_SETXMMREGS, lwp, xmmregs, 0) == -1)
 958     goto noxmm;
 959
 960   return;
 961
 962 noxmm:
 963 #endif
 964
 965   if (regno != -1)
 966     if (ptrace (PT_GETFPREGS, lwp, (caddr_t) &fpregs, 0) == -1)
 967       error ("Cannot get lwp %d float registers: %s\n", lwp,
 968              safe_strerror (errno));
 969
 970   fill_fpregset (&fpregs, regno);
 971   if (ptrace (PT_SETFPREGS, lwp, (caddr_t) &fpregs, 0) == -1)
 972      error ("Cannot set lwp %d float registers: %s\n", lwp,
 973             safe_strerror (errno));
 974 }
 975
 976 static void
 977 fbsd_thread_store_registers (int regno)
 978 {
 979   prgregset_t gregset;
 980   prfpregset_t fpregset;
 981   td_thrhandle_t th;
 982   td_err_e err;
 983 #ifdef PT_GETXMMREGS
 984   char xmmregs[512];
 985 #endif
 986
 987   if (!IS_THREAD (inferior_ptid))
 988     {
 989       fbsd_lwp_store_registers (regno);
 990       return;
 991     }
 992
 993   err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (inferior_ptid), &th);
 994   if (err != TD_OK)
 995     error ("Cannot find thread %d: Thread ID=%ld, %s",
 996            pid_to_thread_id (inferior_ptid),
 997            GET_THREAD (inferior_ptid),
 998            thread_db_err_str (err));
 999
1000   if (regno != -1)
1001     {
1002       char old_value[MAX_REGISTER_SIZE];
1003
1004       regcache_collect (regno, old_value);
1005       err = td_thr_getgregs_p (&th, gregset);
1006       if (err != TD_OK)
1007         error ("%s: td_thr_getgregs %s", __func__, thread_db_err_str (err));
1008 #ifdef PT_GETXMMREGS
1009       err = td_thr_getxmmregs_p (&th, xmmregs);
1010       if (err != TD_OK)
1011         {
1012 #endif
1013           err = td_thr_getfpregs_p (&th, &fpregset);
1014           if (err != TD_OK)
1015             error ("%s: td_thr_getfpgregs %s", __func__, thread_db_err_str (err));
1016 #ifdef PT_GETXMMREGS
1017         }
1018 #endif
1019       supply_register (regno, old_value);
1020     }
1021
1022   fill_gregset (gregset, regno);
1023   err = td_thr_setgregs_p (&th, gregset);
1024   if (err != TD_OK)
1025     error ("Cannot store general-purpose registers for thread %d: Thread ID=%d, %s",
1026            pid_to_thread_id (inferior_ptid), GET_THREAD (inferior_ptid),
1027            thread_db_err_str (err));
1028
1029 #ifdef PT_GETXMMREGS
1030   i387_fill_fxsave (xmmregs, regno);
1031   err = td_thr_setxmmregs_p (&th, xmmregs);
1032   if (err == TD_OK)
1033     return;
1034 #endif
1035
1036   fill_fpregset (&fpregset, regno);
1037   err = td_thr_setfpregs_p (&th, &fpregset);
1038   if (err != TD_OK)
1039     error ("Cannot store floating-point registers for thread %d: Thread ID=%d, %s",
1040            pid_to_thread_id (inferior_ptid), GET_THREAD (inferior_ptid),
1041            thread_db_err_str (err));
1042 }
1043
1044 static void
1045 fbsd_thread_kill (void)
1046 {
1047   child_ops.to_kill();
1048 }
1049
1050 static int
1051 fbsd_thread_can_run (void)
1052 {
1053   return child_suppress_run;
1054 }
1055
1056 static void
1057 fbsd_thread_create_inferior (char *exec_file, char *allargs, char **env)
1058 {
1059   if (fbsd_thread_present && !fbsd_thread_active)
1060     push_target(&fbsd_thread_ops);
1061
1062   child_ops.to_create_inferior (exec_file, allargs, env);
1063 }
1064
1065 static void
1066 fbsd_thread_post_startup_inferior (ptid_t ptid)
1067 {
1068   if (fbsd_thread_present && !fbsd_thread_active)
1069     {
1070       /* The child process is now the actual multi-threaded
1071          program.  Snatch its process ID... */
1072       proc_handle.pid = GET_PID (ptid);
1073       td_ta_new_p (&proc_handle, &thread_agent);
1074       fbsd_thread_activate();
1075     }
1076 }
1077
1078 static void
1079 fbsd_thread_mourn_inferior (void)
1080 {
1081   if (fbsd_thread_active)
1082     fbsd_thread_deactivate ();
1083
1084   unpush_target (&fbsd_thread_ops);
1085
1086   child_ops.to_mourn_inferior ();
1087 }
1088
1089 static void
1090 fbsd_core_check_lwp (bfd *abfd, asection *asect, void *obj)
1091 {
1092   lwpid_t lwp;
1093
1094   if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
1095     return;
1096
1097   /* already found */
1098   if (*(lwpid_t *)obj == 0)
1099     return;
1100
1101   lwp = atoi (bfd_section_name (abfd, asect) + 5);
1102   if (*(lwpid_t *)obj == lwp)
1103     *(lwpid_t *)obj = 0;
1104 }
1105
1106 static int
1107 fbsd_thread_alive (ptid_t ptid)
1108 {
1109   td_thrhandle_t th;
1110   td_thrinfo_t ti;
1111   td_err_e err;
1112   gregset_t gregs;
1113   lwpid_t lwp;
1114
1115   if (IS_THREAD (ptid))
1116     {
1117       err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (ptid), &th);
1118       if (err != TD_OK)
1119         return 0;
1120
1121       err = td_thr_get_info_p (&th, &ti);
1122       if (err != TD_OK)
1123         return 0;
1124
1125       /* A zombie thread. */
1126       if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
1127         return 0;
1128
1129       return 1;
1130     }
1131   else if (GET_LWP (ptid) == 0)
1132     {
1133       /* we sometimes are called with lwp == 0 */
1134       return 1;
1135     }
1136
1137   if (fbsd_thread_active)
1138     {
1139       err = td_ta_map_lwp2thr_p (thread_agent, GET_LWP (ptid), &th);
1140
1141       /*
1142        * if the lwp was already mapped to user thread, don't use it
1143        * directly, please use user thread id instead.
1144        */
1145       if (err == TD_OK)
1146         return 0;
1147     }
1148
1149   if (!target_has_execution)
1150     {
1151       lwp = GET_LWP (ptid);
1152       bfd_map_over_sections (core_bfd, fbsd_core_check_lwp, &lwp);
1153       return (lwp == 0);
1154     }
1155
1156   /* check lwp in kernel */
1157   return ptrace (PT_GETREGS, GET_LWP (ptid), (caddr_t)&gregs, 0) == 0;
1158 }
1159
1160 static void
1161 fbsd_thread_files_info (struct target_ops *ignore)
1162 {
1163   child_ops.to_files_info (ignore);
1164 }
1165
1166 static int
1167 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
1168 {
1169   td_thrinfo_t ti;
1170   td_err_e err;
1171   ptid_t ptid;
1172
1173   err = td_thr_get_info_p (th_p, &ti);
1174   if (err != TD_OK)
1175     error ("Cannot get thread info: %s", thread_db_err_str (err));
1176
1177   /* Ignore zombie */
1178   if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
1179     return 0;
1180
1181   ptid = BUILD_THREAD (ti.ti_tid, proc_handle.pid);
1182   attach_thread (ptid, th_p, &ti, 1);
1183   return 0;
1184 }
1185
1186 static void
1187 fbsd_thread_find_new_threads (void)
1188 {
1189   td_err_e err;
1190
1191   if (!fbsd_thread_active)
1192     return;
1193
1194   /* Iterate over all user-space threads to discover new threads. */
1195   err = td_ta_thr_iter_p (thread_agent, find_new_threads_callback, NULL,
1196           TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1197           TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1198   if (err != TD_OK)
1199     error ("Cannot find new threads: %s", thread_db_err_str (err));
1200 }
1201
1202 static char *
1203 fbsd_thread_pid_to_str (ptid_t ptid)
1204 {
1205   static char buf[64 + MAXCOMLEN];
1206
1207   if (IS_THREAD (ptid))
1208     {
1209       td_thrhandle_t th;
1210       td_thrinfo_t ti;
1211       td_err_e err;
1212
1213       err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (ptid), &th);
1214       if (err != TD_OK)
1215         error ("Cannot find thread, Thread ID=%ld, %s",
1216                 GET_THREAD (ptid), thread_db_err_str (err));
1217
1218       err = td_thr_get_info_p (&th, &ti);
1219       if (err != TD_OK)
1220         error ("Cannot get thread info, Thread ID=%ld, %s",
1221                GET_THREAD (ptid), thread_db_err_str (err));
1222
1223       if (ti.ti_lid != 0)
1224         {
1225           snprintf (buf, sizeof (buf), "Thread %llx (LWP %d/%s)",
1226                     (unsigned long long)th.th_thread, ti.ti_lid,
1227                     fbsd_thread_get_name (ti.ti_lid));
1228         }
1229       else
1230         {
1231           snprintf (buf, sizeof (buf), "Thread %llx (%s)",
1232                     (unsigned long long)th.th_thread,
1233                     thread_db_state_str (ti.ti_state));
1234         }
1235
1236       return buf;
1237     }
1238   else if (IS_LWP (ptid))
1239     {
1240       snprintf (buf, sizeof (buf), "LWP %d", (int) GET_LWP (ptid));
1241       return buf;
1242     }
1243   return normal_pid_to_str (ptid);
1244 }
1245
1246 CORE_ADDR
1247 fbsd_thread_get_local_address(ptid_t ptid, struct objfile *objfile,
1248                               CORE_ADDR offset)
1249 {
1250   td_thrhandle_t th;
1251   void *address;
1252   CORE_ADDR lm;
1253   void *lm2;
1254   int ret, is_library = (objfile->flags & OBJF_SHARED);
1255
1256   if (IS_THREAD (ptid))
1257     {
1258       if (!td_thr_tls_get_addr_p)
1259         error ("Cannot find thread-local interface in thread_db library.");
1260
1261       /* Get the address of the link map for this objfile. */
1262       lm = svr4_fetch_objfile_link_map (objfile);
1263
1264       /* Couldn't find link map. Bail out. */
1265       if (!lm)
1266         {
1267           if (is_library)
1268             error ("Cannot find shared library `%s' link_map in dynamic"
1269                    " linker's module list", objfile->name);
1270           else
1271             error ("Cannot find executable file `%s' link_map in dynamic"
1272                    " linker's module list", objfile->name);
1273         }
1274
1275       ret = td_ta_map_id2thr_p (thread_agent, GET_THREAD(ptid), &th);
1276
1277       /* get the address of the variable. */
1278       store_typed_address(&lm2, builtin_type_void_data_ptr, lm);
1279       ret = td_thr_tls_get_addr_p (&th, lm2, offset, &address);
1280
1281       if (ret != TD_OK)
1282         {
1283           if (is_library)
1284             error ("Cannot find thread-local storage for thread %ld, "
1285                    "shared library %s:\n%s",
1286                    (long) GET_THREAD (ptid),
1287                    objfile->name, thread_db_err_str (ret));
1288           else
1289             error ("Cannot find thread-local storage for thread %ld, "
1290                    "executable file %s:\n%s",
1291                    (long) GET_THREAD (ptid),
1292                    objfile->name, thread_db_err_str (ret));
1293         }
1294
1295       /* Cast assuming host == target. */
1296       return extract_typed_address(&address, builtin_type_void_data_ptr);
1297     }
1298   return (0);
1299 }
1300
1301 static int
1302 tsd_cb (thread_key_t key, void (*destructor)(void *), void *ignore)
1303 {
1304   struct minimal_symbol *ms;
1305   char *name;
1306
1307   ms = lookup_minimal_symbol_by_pc (
1308         extract_typed_address(&destructor, builtin_type_void_func_ptr));
1309   if (!ms)
1310     name = "???";
1311   else
1312     name = DEPRECATED_SYMBOL_NAME (ms);
1313
1314   printf_filtered ("Key %d, destructor %p <%s>\n", key, destructor, name);
1315   return 0;
1316 }
1317
1318 static void
1319 fbsd_thread_tsd_cmd (char *exp, int from_tty)
1320 {
1321   if (fbsd_thread_active)
1322     td_ta_tsd_iter_p (thread_agent, tsd_cb, NULL);
1323 }
1324
1325 static void
1326 fbsd_print_sigset (sigset_t *set)
1327 {
1328   int i;
1329
1330   for (i = 1; i <= _SIG_MAXSIG; ++i) {
1331      if (sigismember(set, i)) {
1332        if (i < sizeof(sys_signame)/sizeof(sys_signame[0]))
1333          printf_filtered("%s ", sys_signame[i]);
1334        else
1335          printf_filtered("sig%d ", i);
1336      }
1337   }
1338   printf_filtered("\n");
1339 }
1340
1341 static void
1342 fbsd_thread_signal_cmd (char *exp, int from_tty)
1343 {
1344   td_thrhandle_t th;
1345   td_thrinfo_t ti;
1346   td_err_e err;
1347   const char *code;
1348
1349   if (!fbsd_thread_active || !IS_THREAD(inferior_ptid))
1350     return;
1351
1352   err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (inferior_ptid), &th);
1353   if (err != TD_OK)
1354     return;
1355
1356   err = td_thr_get_info_p (&th, &ti);
1357   if (err != TD_OK)
1358     return;
1359
1360   printf_filtered("signal mask:\n");
1361   fbsd_print_sigset(&ti.ti_sigmask);
1362   printf_filtered("signal pending:\n");
1363   fbsd_print_sigset(&ti.ti_pending);
1364   if (ti.ti_siginfo.si_signo != 0) {
1365    printf_filtered("si_signo %d si_errno %d", ti.ti_siginfo.si_signo,
1366      ti.ti_siginfo.si_errno);
1367    if (ti.ti_siginfo.si_errno != 0)
1368     printf_filtered(" (%s)", strerror(ti.ti_siginfo.si_errno));
1369    printf_filtered("\n");
1370    switch (ti.ti_siginfo.si_code) {
1371    case SI_NOINFO:
1372         code = "NOINFO";
1373         break;
1374     case SI_USER:
1375         code = "USER";
1376         break;
1377     case SI_QUEUE:
1378         code = "QUEUE";
1379         break;
1380     case SI_TIMER:
1381         code = "TIMER";
1382         break;
1383     case SI_ASYNCIO:
1384         code = "ASYNCIO";
1385         break;
1386     case SI_MESGQ:
1387         code = "MESGQ";
1388         break;
1389     case SI_KERNEL:
1390         code = "KERNEL";
1391         break;
1392     default:
1393         code = "UNKNOWN";
1394         break;
1395     }
1396     printf_filtered("si_code %s (%d) si_pid %d si_uid %d si_status %x "
1397       "si_addr %p\n",
1398       code, ti.ti_siginfo.si_code, ti.ti_siginfo.si_pid, ti.ti_siginfo.si_uid,
1399       ti.ti_siginfo.si_status, ti.ti_siginfo.si_addr);
1400   }
1401 }
1402
1403 static int
1404 ignore (CORE_ADDR addr, char *contents)
1405 {
1406   return 0;
1407 }
1408
1409 static void
1410 fbsd_core_open (char *filename, int from_tty)
1411 {
1412   int err;
1413
1414   fbsd_thread_core = 1;
1415
1416   orig_core_ops.to_open (filename, from_tty);
1417
1418   if (fbsd_thread_present)
1419     {
1420       err = td_ta_new_p (&proc_handle, &thread_agent);
1421       if (err == TD_OK)
1422         {
1423           proc_handle.pid = elf_tdata (core_bfd)->core_pid;
1424           fbsd_thread_activate ();
1425         }
1426       else
1427         error ("fbsd_core_open: td_ta_new: %s", thread_db_err_str (err));
1428     }
1429 }
1430
1431 static void
1432 fbsd_core_close (int quitting)
1433 {
1434   orig_core_ops.to_close (quitting);
1435 }
1436
1437 static void
1438 fbsd_core_detach (char *args, int from_tty)
1439 {
1440   if (fbsd_thread_active)
1441     fbsd_thread_deactivate ();
1442   unpush_target (&fbsd_thread_ops);
1443   orig_core_ops.to_detach (args, from_tty);
1444
1445   /* Clear gdb solib information and symbol file
1446      cache, so that after detach and re-attach, new_objfile
1447      hook will be called */
1448   clear_solib();
1449   symbol_file_clear(0);
1450 }
1451
1452 static void
1453 fbsd_core_files_info (struct target_ops *ignore)
1454 {
1455   orig_core_ops.to_files_info (ignore);
1456 }
1457
1458 static void
1459 init_fbsd_core_ops (void)
1460 {
1461   fbsd_core_ops.to_shortname = "FreeBSD-core";
1462   fbsd_core_ops.to_longname = "FreeBSD multithreaded core dump file";
1463   fbsd_core_ops.to_doc =
1464     "Use a core file as a target.  Specify the filename of the core file.";
1465   fbsd_core_ops.to_open = fbsd_core_open;
1466   fbsd_core_ops.to_close = fbsd_core_close;
1467   fbsd_core_ops.to_attach = 0;
1468   fbsd_core_ops.to_post_attach = 0;
1469   fbsd_core_ops.to_detach = fbsd_core_detach;
1470   /* fbsd_core_ops.to_resume  = 0; */
1471   /* fbsd_core_ops.to_wait  = 0;  */
1472   fbsd_core_ops.to_fetch_registers = fbsd_thread_fetch_registers;
1473   /* fbsd_core_ops.to_store_registers  = 0; */
1474   /* fbsd_core_ops.to_prepare_to_store  = 0; */
1475   fbsd_core_ops.to_xfer_memory = fbsd_thread_xfer_memory;
1476   fbsd_core_ops.to_files_info = fbsd_core_files_info;
1477   fbsd_core_ops.to_insert_breakpoint = ignore;
1478   fbsd_core_ops.to_remove_breakpoint = ignore;
1479   /* fbsd_core_ops.to_lookup_symbol  = 0; */
1480   fbsd_core_ops.to_create_inferior = fbsd_thread_create_inferior;
1481   fbsd_core_ops.to_stratum = core_stratum;
1482   fbsd_core_ops.to_has_all_memory = 0;
1483   fbsd_core_ops.to_has_memory = 1;
1484   fbsd_core_ops.to_has_stack = 1;
1485   fbsd_core_ops.to_has_registers = 1;
1486   fbsd_core_ops.to_has_execution = 0;
1487   fbsd_core_ops.to_has_thread_control = tc_none;
1488   fbsd_core_ops.to_thread_alive = fbsd_thread_alive;
1489   fbsd_core_ops.to_pid_to_str = fbsd_thread_pid_to_str;
1490   fbsd_core_ops.to_find_new_threads = fbsd_thread_find_new_threads;
1491   fbsd_core_ops.to_sections = 0;
1492   fbsd_core_ops.to_sections_end = 0;
1493   fbsd_core_ops.to_magic = OPS_MAGIC;
1494 }
1495
1496 static void
1497 init_fbsd_thread_ops (void)
1498 {
1499   fbsd_thread_ops.to_shortname = "freebsd-threads";
1500   fbsd_thread_ops.to_longname = "FreeBSD multithreaded child process.";
1501   fbsd_thread_ops.to_doc = "FreeBSD threads support.";
1502   fbsd_thread_ops.to_attach = fbsd_thread_attach;
1503   fbsd_thread_ops.to_detach = fbsd_thread_detach;
1504   fbsd_thread_ops.to_post_attach = fbsd_thread_post_attach;
1505   fbsd_thread_ops.to_resume = fbsd_thread_resume;
1506   fbsd_thread_ops.to_wait = fbsd_thread_wait;
1507   fbsd_thread_ops.to_fetch_registers = fbsd_thread_fetch_registers;
1508   fbsd_thread_ops.to_store_registers = fbsd_thread_store_registers;
1509   fbsd_thread_ops.to_xfer_memory = fbsd_thread_xfer_memory;
1510   fbsd_thread_ops.to_files_info = fbsd_thread_files_info;
1511   fbsd_thread_ops.to_kill = fbsd_thread_kill;
1512   fbsd_thread_ops.to_create_inferior = fbsd_thread_create_inferior;
1513   fbsd_thread_ops.to_post_startup_inferior = fbsd_thread_post_startup_inferior;
1514   fbsd_thread_ops.to_mourn_inferior = fbsd_thread_mourn_inferior;
1515   fbsd_thread_ops.to_can_run = fbsd_thread_can_run;
1516   fbsd_thread_ops.to_thread_alive = fbsd_thread_alive;
1517   fbsd_thread_ops.to_find_new_threads = fbsd_thread_find_new_threads;
1518   fbsd_thread_ops.to_pid_to_str = fbsd_thread_pid_to_str;
1519   fbsd_thread_ops.to_stratum = thread_stratum;
1520   fbsd_thread_ops.to_has_thread_control = tc_none;
1521   fbsd_thread_ops.to_has_all_memory = 1;
1522   fbsd_thread_ops.to_has_memory = 1;
1523   fbsd_thread_ops.to_has_stack = 1;
1524   fbsd_thread_ops.to_has_registers = 1;
1525   fbsd_thread_ops.to_has_execution = 1;
1526   fbsd_thread_ops.to_insert_breakpoint = memory_insert_breakpoint;
1527   fbsd_thread_ops.to_remove_breakpoint = memory_remove_breakpoint;
1528   fbsd_thread_ops.to_get_thread_local_address = fbsd_thread_get_local_address;
1529   fbsd_thread_ops.to_magic = OPS_MAGIC;
1530 }
1531
1532 static int
1533 thread_db_load (void)
1534 {
1535   void *handle;
1536   td_err_e err;
1537
1538   handle = dlopen (LIBTHREAD_DB_SO, RTLD_NOW);
1539   if (handle == NULL)
1540       return 0;
1541
1542 #define resolve(X)                      \
1543  if (!(X##_p = dlsym (handle, #X)))     \
1544    return 0;
1545
1546   resolve(td_init);
1547   resolve(td_ta_new);
1548   resolve(td_ta_delete);
1549   resolve(td_ta_map_id2thr);
1550   resolve(td_ta_map_lwp2thr);
1551   resolve(td_ta_thr_iter);
1552   resolve(td_thr_get_info);
1553 #ifdef PT_GETXMMREGS
1554   resolve(td_thr_getxmmregs);
1555 #endif
1556   resolve(td_thr_getfpregs);
1557   resolve(td_thr_getgregs);
1558 #ifdef PT_GETXMMREGS
1559   resolve(td_thr_setxmmregs);
1560 #endif
1561   resolve(td_thr_setfpregs);
1562   resolve(td_thr_setgregs);
1563   resolve(td_thr_sstep);
1564   resolve(td_ta_tsd_iter);
1565   resolve(td_thr_dbsuspend);
1566   resolve(td_thr_dbresume);
1567   resolve(td_thr_tls_get_addr);
1568
1569   /* Initialize the library.  */
1570   err = td_init_p ();
1571   if (err != TD_OK)
1572     {
1573       warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err));
1574       return 0;
1575     }
1576
1577   /* These are not essential.  */
1578   td_ta_event_addr_p = dlsym (handle, "td_ta_event_addr");
1579   td_ta_set_event_p = dlsym (handle, "td_ta_set_event");
1580   td_ta_event_getmsg_p = dlsym (handle, "td_ta_event_getmsg");
1581   td_thr_event_enable_p = dlsym (handle, "td_thr_event_enable");
1582   td_thr_tls_get_addr_p = dlsym (handle, "td_thr_tls_get_addr");
1583
1584   return 1;
1585 }
1586
1587 /* we suppress the call to add_target of core_ops in corelow because
1588    if there are two targets in the stratum core_stratum, find_core_target
1589    won't know which one to return.  see corelow.c for an additonal
1590    comment on coreops_suppress_target. */
1591
1592 int coreops_suppress_target = 1;
1593
1594 /* similarly we allow this target to be completely skipped.  This is used
1595    by kgdb which uses its own core target. */
1596
1597 int fbsdcoreops_suppress_target;
1598
1599 void
1600 _initialize_thread_db (void)
1601 {
1602
1603   if (fbsdcoreops_suppress_target)
1604     return;
1605   init_fbsd_thread_ops ();
1606   init_fbsd_core_ops ();
1607
1608   if (thread_db_load ())
1609     {
1610       add_target (&fbsd_thread_ops);
1611
1612       /* "thread tsd" command */
1613       add_cmd ("tsd", class_run, fbsd_thread_tsd_cmd,
1614             "Show the thread-specific data keys and destructors "
1615             "for the process.\n",
1616            &thread_cmd_list);
1617
1618       add_cmd ("signal", class_run, fbsd_thread_signal_cmd,
1619             "Show the thread signal info.\n",
1620            &thread_cmd_list);
1621
1622       memcpy (&orig_core_ops, &core_ops, sizeof (struct target_ops));
1623       memcpy (&core_ops, &fbsd_core_ops, sizeof (struct target_ops));
1624       add_target (&core_ops);
1625
1626       /* Add ourselves to objfile event chain. */
1627       target_new_objfile_chain = target_new_objfile_hook;
1628       target_new_objfile_hook = fbsd_thread_new_objfile;
1629
1630       child_suppress_run = 1;
1631     }
1632   else
1633     {
1634       fprintf_unfiltered (gdb_stderr,
1635         "[GDB will not be able to debug user-mode threads: %s]\n", dlerror());
1636
1637       /* allow the user to debug non-threaded core files */
1638       add_target (&core_ops);
1639     }
1640 }
1641
1642 /* proc service functions */
1643 void
1644 ps_plog (const char *fmt, ...)
1645 {
1646   va_list args;
1647
1648   va_start (args, fmt);
1649   vfprintf_filtered (gdb_stderr, fmt, args);
1650   va_end (args);
1651 }
1652
1653 ps_err_e
1654 ps_pglobal_lookup (struct ps_prochandle *ph, const char *obj,
1655    const char *name, psaddr_t *sym_addr)
1656 {
1657   struct minimal_symbol *ms;
1658   CORE_ADDR addr;
1659
1660   ms = lookup_minimal_symbol (name, NULL, NULL);
1661   if (ms == NULL)
1662     return PS_NOSYM;
1663
1664   addr = SYMBOL_VALUE_ADDRESS (ms);
1665   store_typed_address(sym_addr, builtin_type_void_data_ptr, addr);
1666   return PS_OK;
1667 }
1668
1669 ps_err_e
1670 ps_pread (struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t len)
1671 {
1672   int err = target_read_memory (
1673     extract_typed_address(&addr, builtin_type_void_data_ptr), buf, len);
1674   return (err == 0 ? PS_OK : PS_ERR);
1675 }
1676
1677 ps_err_e
1678 ps_pwrite (struct ps_prochandle *ph, psaddr_t addr, const void *buf,
1679             size_t len)
1680 {
1681   int err = target_write_memory (
1682     extract_typed_address(&addr, builtin_type_void_data_ptr), (void *)buf, len);
1683   return (err == 0 ? PS_OK : PS_ERR);
1684 }
1685
1686 ps_err_e
1687 ps_lgetregs (struct ps_prochandle *ph, lwpid_t lwpid, prgregset_t gregset)
1688 {
1689   struct cleanup *old_chain;
1690
1691   old_chain = save_inferior_ptid ();
1692
1693   /* XXX: Target operation isn't lwp aware: replace pid with lwp */
1694   inferior_ptid = BUILD_LWP (0, lwpid);
1695
1696   target_fetch_registers (-1);
1697   fill_gregset (gregset, -1);
1698   do_cleanups (old_chain);
1699   return PS_OK;
1700 }
1701
1702 ps_err_e
1703 ps_lsetregs (struct ps_prochandle *ph, lwpid_t lwpid, const prgregset_t gregset)
1704 {
1705   struct cleanup *old_chain;
1706
1707   old_chain = save_inferior_ptid ();
1708   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1709   supply_gregset ((gdb_gregset_t *) gregset);
1710   target_store_registers (-1);
1711   do_cleanups (old_chain);
1712   return PS_OK;
1713 }
1714
1715 ps_err_e
1716 ps_lgetfpregs (struct ps_prochandle *ph, lwpid_t lwpid, prfpregset_t *fpregset)
1717 {
1718   struct cleanup *old_chain;
1719
1720   old_chain = save_inferior_ptid ();
1721   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1722   target_fetch_registers (-1);
1723   fill_fpregset (fpregset, -1);
1724   do_cleanups (old_chain);
1725   return PS_OK;
1726 }
1727
1728 ps_err_e
1729 ps_lsetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
1730                const prfpregset_t *fpregset)
1731 {
1732   struct cleanup *old_chain;
1733
1734   old_chain = save_inferior_ptid ();
1735   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1736   supply_fpregset ((gdb_fpregset_t *) fpregset);
1737   target_store_registers (-1);
1738   do_cleanups (old_chain);
1739   return PS_OK;
1740 }
1741
1742 #ifdef PT_GETXMMREGS
1743 ps_err_e
1744 ps_lgetxmmregs (struct ps_prochandle *ph, lwpid_t lwpid, char *xmmregs)
1745 {
1746   struct cleanup *old_chain;
1747
1748   old_chain = save_inferior_ptid ();
1749   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1750   target_fetch_registers (-1);
1751   i387_fill_fxsave (xmmregs, -1);
1752   do_cleanups (old_chain);
1753   return PS_OK;
1754 }
1755
1756 ps_err_e
1757 ps_lsetxmmregs (struct ps_prochandle *ph, lwpid_t lwpid,
1758                 const char *xmmregs)
1759 {
1760   struct cleanup *old_chain;
1761
1762   old_chain = save_inferior_ptid ();
1763   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
1764   i387_supply_fxsave (current_regcache, -1, xmmregs);
1765   target_store_registers (-1);
1766   do_cleanups (old_chain);
1767   return PS_OK;
1768 }
1769 #endif
1770
1771 ps_err_e
1772 ps_lstop(struct ps_prochandle *ph, lwpid_t lwpid)
1773 {
1774   if (ptrace (PT_SUSPEND, lwpid, 0, 0) == -1)
1775     return PS_ERR;
1776   return PS_OK;
1777 }
1778
1779 ps_err_e
1780 ps_lcontinue(struct ps_prochandle *ph, lwpid_t lwpid)
1781 {
1782   if (ptrace (PT_RESUME, lwpid, 0, 0) == -1)
1783     return PS_ERR;
1784   return PS_OK;
1785 }
1786
1787 ps_err_e
1788 ps_linfo(struct ps_prochandle *ph, lwpid_t lwpid, void *info)
1789 {
1790   if (fbsd_thread_core) {
1791     /* XXX should verify lwpid and make a pseudo lwp info */
1792     memset(info, 0, sizeof(struct ptrace_lwpinfo));
1793     return PS_OK;
1794   }
1795
1796   if (ptrace (PT_LWPINFO, lwpid, info, sizeof(struct ptrace_lwpinfo)) == -1)
1797     return PS_ERR;
1798   return PS_OK;
1799 }