1 /* Solaris threads debugging interface. 2 3 Copyright (C) 1996-2019 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 3 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, see <http://www.gnu.org/licenses/>. */ 19 20 /* This module implements a sort of half target that sits between the 21 machine-independent parts of GDB and the /proc interface (procfs.c) 22 to provide access to the Solaris user-mode thread implementation. 23 24 Solaris threads are true user-mode threads, which are invoked via 25 the thr_* and pthread_* (native and POSIX respectivly) interfaces. 26 These are mostly implemented in user-space, with all thread context 27 kept in various structures that live in the user's heap. These 28 should not be confused with lightweight processes (LWPs), which are 29 implemented by the kernel, and scheduled without explicit 30 intervention by the process. 31 32 Just to confuse things a little, Solaris threads (both native and 33 POSIX) are actually implemented using LWPs. In general, there are 34 going to be more threads than LWPs. There is no fixed 35 correspondence between a thread and an LWP. When a thread wants to 36 run, it gets scheduled onto the first available LWP and can 37 therefore migrate from one LWP to another as time goes on. A 38 sleeping thread may not be associated with an LWP at all! 39 40 To make it possible to mess with threads, Sun provides a library 41 called libthread_db.so.1 (not to be confused with 42 libthread_db.so.0, which doesn't have a published interface). This 43 interface has an upper part, which it provides, and a lower part 44 which we provide. The upper part consists of the td_* routines, 45 which allow us to find all the threads, query their state, etc... 46 The lower part consists of all of the ps_*, which are used by the 47 td_* routines to read/write memory, manipulate LWPs, lookup 48 symbols, etc... The ps_* routines actually do most of their work 49 by calling functions in procfs.c. */ 50 51 #include "defs.h" 52 #include <thread.h> 53 #include <proc_service.h> 54 #include <thread_db.h> 55 #include "gdbthread.h" 56 #include "target.h" 57 #include "inferior.h" 58 #include <fcntl.h> 59 #include <sys/stat.h> 60 #include <dlfcn.h> 61 #include "gdbcmd.h" 62 #include "gdbcore.h" 63 #include "regcache.h" 64 #include "solib.h" 65 #include "symfile.h" 66 #include "observable.h" 67 #include "procfs.h" 68 #include "symtab.h" 69 #include "minsyms.h" 70 #include "objfiles.h" 71 72 static const target_info thread_db_target_info = { 73 "solaris-threads", 74 N_("Solaris threads and pthread."), 75 N_("Solaris threads and pthread support.") 76 }; 77 78 class sol_thread_target final : public target_ops 79 { 80 public: 81 const target_info &info () const override 82 { return thread_db_target_info; } 83 84 strata stratum () const override { return thread_stratum; } 85 86 void detach (inferior *, int) override; 87 ptid_t wait (ptid_t, struct target_waitstatus *, int) override; 88 void resume (ptid_t, int, enum gdb_signal) override; 89 void mourn_inferior () override; 90 const char *pid_to_str (ptid_t) override; 91 ptid_t get_ada_task_ptid (long lwp, long thread) override; 92 93 void fetch_registers (struct regcache *, int) override; 94 void store_registers (struct regcache *, int) override; 95 96 enum target_xfer_status xfer_partial (enum target_object object, 97 const char *annex, 98 gdb_byte *readbuf, 99 const gdb_byte *writebuf, 100 ULONGEST offset, ULONGEST len, 101 ULONGEST *xfered_len) override; 102 103 bool thread_alive (ptid_t ptid) override; 104 void update_thread_list () override; 105 }; 106 107 static sol_thread_target sol_thread_ops; 108 109 /* Prototypes for supply_gregset etc. */ 110 #include "gregset.h" 111 112 /* This struct is defined by us, but mainly used for the proc_service 113 interface. We don't have much use for it, except as a handy place 114 to get a real PID for memory accesses. */ 115 116 struct ps_prochandle 117 { 118 ptid_t ptid; 119 }; 120 121 struct string_map 122 { 123 int num; 124 const char *str; 125 }; 126 127 static struct ps_prochandle main_ph; 128 static td_thragent_t *main_ta; 129 static int sol_thread_active = 0; 130 131 /* Default definitions: These must be defined in tm.h if they are to 132 be shared with a process module such as procfs. */ 133 134 /* Types of the libthread_db functions. */ 135 136 typedef void (td_log_ftype)(const int on_off); 137 typedef td_err_e (td_ta_new_ftype)(const struct ps_prochandle *ph_p, 138 td_thragent_t **ta_pp); 139 typedef td_err_e (td_ta_delete_ftype)(td_thragent_t *ta_p); 140 typedef td_err_e (td_init_ftype)(void); 141 typedef td_err_e (td_ta_get_ph_ftype)(const td_thragent_t *ta_p, 142 struct ps_prochandle **ph_pp); 143 typedef td_err_e (td_ta_get_nthreads_ftype)(const td_thragent_t *ta_p, 144 int *nthread_p); 145 typedef td_err_e (td_ta_tsd_iter_ftype)(const td_thragent_t *ta_p, 146 td_key_iter_f *cb, void *cbdata_p); 147 typedef td_err_e (td_ta_thr_iter_ftype)(const td_thragent_t *ta_p, 148 td_thr_iter_f *cb, void *cbdata_p, 149 td_thr_state_e state, int ti_pri, 150 sigset_t *ti_sigmask_p, 151 unsigned ti_user_flags); 152 typedef td_err_e (td_thr_validate_ftype)(const td_thrhandle_t *th_p); 153 typedef td_err_e (td_thr_tsd_ftype)(const td_thrhandle_t * th_p, 154 const thread_key_t key, void **data_pp); 155 typedef td_err_e (td_thr_get_info_ftype)(const td_thrhandle_t *th_p, 156 td_thrinfo_t *ti_p); 157 typedef td_err_e (td_thr_getfpregs_ftype)(const td_thrhandle_t *th_p, 158 prfpregset_t *fpregset); 159 typedef td_err_e (td_thr_getxregsize_ftype)(const td_thrhandle_t *th_p, 160 int *xregsize); 161 typedef td_err_e (td_thr_getxregs_ftype)(const td_thrhandle_t *th_p, 162 const caddr_t xregset); 163 typedef td_err_e (td_thr_sigsetmask_ftype)(const td_thrhandle_t *th_p, 164 const sigset_t ti_sigmask); 165 typedef td_err_e (td_thr_setprio_ftype)(const td_thrhandle_t *th_p, 166 const int ti_pri); 167 typedef td_err_e (td_thr_setsigpending_ftype)(const td_thrhandle_t *th_p, 168 const uchar_t ti_pending_flag, 169 const sigset_t ti_pending); 170 typedef td_err_e (td_thr_setfpregs_ftype)(const td_thrhandle_t *th_p, 171 const prfpregset_t *fpregset); 172 typedef td_err_e (td_thr_setxregs_ftype)(const td_thrhandle_t *th_p, 173 const caddr_t xregset); 174 typedef td_err_e (td_ta_map_id2thr_ftype)(const td_thragent_t *ta_p, 175 thread_t tid, 176 td_thrhandle_t *th_p); 177 typedef td_err_e (td_ta_map_lwp2thr_ftype)(const td_thragent_t *ta_p, 178 lwpid_t lwpid, 179 td_thrhandle_t *th_p); 180 typedef td_err_e (td_thr_getgregs_ftype)(const td_thrhandle_t *th_p, 181 prgregset_t regset); 182 typedef td_err_e (td_thr_setgregs_ftype)(const td_thrhandle_t *th_p, 183 const prgregset_t regset); 184 185 /* Pointers to routines from libthread_db resolved by dlopen(). */ 186 187 static td_log_ftype *p_td_log; 188 static td_ta_new_ftype *p_td_ta_new; 189 static td_ta_delete_ftype *p_td_ta_delete; 190 static td_init_ftype *p_td_init; 191 static td_ta_get_ph_ftype *p_td_ta_get_ph; 192 static td_ta_get_nthreads_ftype *p_td_ta_get_nthreads; 193 static td_ta_tsd_iter_ftype *p_td_ta_tsd_iter; 194 static td_ta_thr_iter_ftype *p_td_ta_thr_iter; 195 static td_thr_validate_ftype *p_td_thr_validate; 196 static td_thr_tsd_ftype *p_td_thr_tsd; 197 static td_thr_get_info_ftype *p_td_thr_get_info; 198 static td_thr_getfpregs_ftype *p_td_thr_getfpregs; 199 static td_thr_getxregsize_ftype *p_td_thr_getxregsize; 200 static td_thr_getxregs_ftype *p_td_thr_getxregs; 201 static td_thr_sigsetmask_ftype *p_td_thr_sigsetmask; 202 static td_thr_setprio_ftype *p_td_thr_setprio; 203 static td_thr_setsigpending_ftype *p_td_thr_setsigpending; 204 static td_thr_setfpregs_ftype *p_td_thr_setfpregs; 205 static td_thr_setxregs_ftype *p_td_thr_setxregs; 206 static td_ta_map_id2thr_ftype *p_td_ta_map_id2thr; 207 static td_ta_map_lwp2thr_ftype *p_td_ta_map_lwp2thr; 208 static td_thr_getgregs_ftype *p_td_thr_getgregs; 209 static td_thr_setgregs_ftype *p_td_thr_setgregs; 210 211 212 /* Return the libthread_db error string associated with ERRCODE. If 213 ERRCODE is unknown, return an appropriate message. */ 214 215 static const char * 216 td_err_string (td_err_e errcode) 217 { 218 static struct string_map td_err_table[] = 219 { 220 { TD_OK, "generic \"call succeeded\"" }, 221 { TD_ERR, "generic error." }, 222 { TD_NOTHR, "no thread can be found to satisfy query" }, 223 { TD_NOSV, "no synch. variable can be found to satisfy query" }, 224 { TD_NOLWP, "no lwp can be found to satisfy query" }, 225 { TD_BADPH, "invalid process handle" }, 226 { TD_BADTH, "invalid thread handle" }, 227 { TD_BADSH, "invalid synchronization handle" }, 228 { TD_BADTA, "invalid thread agent" }, 229 { TD_BADKEY, "invalid key" }, 230 { TD_NOMSG, "td_thr_event_getmsg() called when there was no message" }, 231 { TD_NOFPREGS, "FPU register set not available for given thread" }, 232 { TD_NOLIBTHREAD, "application not linked with libthread" }, 233 { TD_NOEVENT, "requested event is not supported" }, 234 { TD_NOCAPAB, "capability not available" }, 235 { TD_DBERR, "Debugger service failed" }, 236 { TD_NOAPLIC, "Operation not applicable to" }, 237 { TD_NOTSD, "No thread specific data for this thread" }, 238 { TD_MALLOC, "Malloc failed" }, 239 { TD_PARTIALREG, "Only part of register set was written/read" }, 240 { TD_NOXREGS, "X register set not available for given thread" } 241 }; 242 const int td_err_size = sizeof td_err_table / sizeof (struct string_map); 243 int i; 244 static char buf[50]; 245 246 for (i = 0; i < td_err_size; i++) 247 if (td_err_table[i].num == errcode) 248 return td_err_table[i].str; 249 250 xsnprintf (buf, sizeof (buf), "Unknown libthread_db error code: %d", 251 errcode); 252 253 return buf; 254 } 255 256 /* Return the libthread_db state string assicoated with STATECODE. 257 If STATECODE is unknown, return an appropriate message. */ 258 259 static const char * 260 td_state_string (td_thr_state_e statecode) 261 { 262 static struct string_map td_thr_state_table[] = 263 { 264 { TD_THR_ANY_STATE, "any state" }, 265 { TD_THR_UNKNOWN, "unknown" }, 266 { TD_THR_STOPPED, "stopped" }, 267 { TD_THR_RUN, "run" }, 268 { TD_THR_ACTIVE, "active" }, 269 { TD_THR_ZOMBIE, "zombie" }, 270 { TD_THR_SLEEP, "sleep" }, 271 { TD_THR_STOPPED_ASLEEP, "stopped asleep" } 272 }; 273 const int td_thr_state_table_size = 274 sizeof td_thr_state_table / sizeof (struct string_map); 275 int i; 276 static char buf[50]; 277 278 for (i = 0; i < td_thr_state_table_size; i++) 279 if (td_thr_state_table[i].num == statecode) 280 return td_thr_state_table[i].str; 281 282 xsnprintf (buf, sizeof (buf), "Unknown libthread_db state code: %d", 283 statecode); 284 285 return buf; 286 } 287 288 289 /* Convert a POSIX or Solaris thread ID into a LWP ID. If THREAD_ID 290 doesn't exist, that's an error. If it's an inactive thread, return 291 DEFAULT_LWP. 292 293 NOTE: This function probably shouldn't call error(). */ 294 295 static ptid_t 296 thread_to_lwp (ptid_t thread_id, int default_lwp) 297 { 298 td_thrinfo_t ti; 299 td_thrhandle_t th; 300 td_err_e val; 301 302 if (thread_id.lwp_p ()) 303 return thread_id; /* It's already an LWP ID. */ 304 305 /* It's a thread. Convert to LWP. */ 306 307 val = p_td_ta_map_id2thr (main_ta, thread_id.tid (), &th); 308 if (val == TD_NOTHR) 309 return ptid_t (-1); /* Thread must have terminated. */ 310 else if (val != TD_OK) 311 error (_("thread_to_lwp: td_ta_map_id2thr %s"), td_err_string (val)); 312 313 val = p_td_thr_get_info (&th, &ti); 314 if (val == TD_NOTHR) 315 return ptid_t (-1); /* Thread must have terminated. */ 316 else if (val != TD_OK) 317 error (_("thread_to_lwp: td_thr_get_info: %s"), td_err_string (val)); 318 319 if (ti.ti_state != TD_THR_ACTIVE) 320 { 321 if (default_lwp != -1) 322 return ptid_t (default_lwp); 323 error (_("thread_to_lwp: thread state not active: %s"), 324 td_state_string (ti.ti_state)); 325 } 326 327 return ptid_t (thread_id.pid (), ti.ti_lid, 0); 328 } 329 330 /* Convert an LWP ID into a POSIX or Solaris thread ID. If LWP_ID 331 doesn't exists, that's an error. 332 333 NOTE: This function probably shouldn't call error(). */ 334 335 static ptid_t 336 lwp_to_thread (ptid_t lwp) 337 { 338 td_thrinfo_t ti; 339 td_thrhandle_t th; 340 td_err_e val; 341 342 if (lwp.tid_p ()) 343 return lwp; /* It's already a thread ID. */ 344 345 /* It's an LWP. Convert it to a thread ID. */ 346 347 if (!target_thread_alive (lwp)) 348 return ptid_t (-1); /* Must be a defunct LPW. */ 349 350 val = p_td_ta_map_lwp2thr (main_ta, lwp.lwp (), &th); 351 if (val == TD_NOTHR) 352 return ptid_t (-1); /* Thread must have terminated. */ 353 else if (val != TD_OK) 354 error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val)); 355 356 val = p_td_thr_validate (&th); 357 if (val == TD_NOTHR) 358 return lwp; /* Unknown to libthread; just return LPW, */ 359 else if (val != TD_OK) 360 error (_("lwp_to_thread: td_thr_validate: %s."), td_err_string (val)); 361 362 val = p_td_thr_get_info (&th, &ti); 363 if (val == TD_NOTHR) 364 return ptid_t (-1); /* Thread must have terminated. */ 365 else if (val != TD_OK) 366 error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val)); 367 368 return ptid_t (lwp.pid (), 0 , ti.ti_tid); 369 } 370 371 372 /* Most target vector functions from here on actually just pass 373 through to the layer beneath, as they don't need to do anything 374 specific for threads. */ 375 376 /* Take a program previously attached to and detaches it. The program 377 resumes execution and will no longer stop on signals, etc. We'd 378 better not have left any breakpoints in the program or it'll die 379 when it hits one. For this to work, it may be necessary for the 380 process to have been previously attached. It *might* work if the 381 program was started via the normal ptrace (PTRACE_TRACEME). */ 382 383 void 384 sol_thread_target::detach (inferior *inf, int from_tty) 385 { 386 target_ops *beneath = this->beneath (); 387 388 sol_thread_active = 0; 389 inferior_ptid = ptid_t (main_ph.ptid.pid ()); 390 unpush_target (this); 391 beneath->detach (inf, from_tty); 392 } 393 394 /* Resume execution of process PTID. If STEP is nozero, then just 395 single step it. If SIGNAL is nonzero, restart it with that signal 396 activated. We may have to convert PTID from a thread ID to an LWP 397 ID for procfs. */ 398 399 void 400 sol_thread_target::resume (ptid_t ptid, int step, enum gdb_signal signo) 401 { 402 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid); 403 404 inferior_ptid = thread_to_lwp (inferior_ptid, main_ph.ptid.pid ()); 405 if (inferior_ptid.pid () == -1) 406 inferior_ptid = procfs_first_available (); 407 408 if (ptid.pid () != -1) 409 { 410 ptid_t save_ptid = ptid; 411 412 ptid = thread_to_lwp (ptid, -2); 413 if (ptid.pid () == -2) /* Inactive thread. */ 414 error (_("This version of Solaris can't start inactive threads.")); 415 if (info_verbose && ptid.pid () == -1) 416 warning (_("Specified thread %ld seems to have terminated"), 417 save_ptid.tid ()); 418 } 419 420 beneath ()->resume (ptid, step, signo); 421 } 422 423 /* Wait for any threads to stop. We may have to convert PTID from a 424 thread ID to an LWP ID, and vice versa on the way out. */ 425 426 ptid_t 427 sol_thread_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus, 428 int options) 429 { 430 ptid_t rtnval; 431 ptid_t save_ptid; 432 433 save_ptid = inferior_ptid; 434 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid); 435 436 inferior_ptid = thread_to_lwp (inferior_ptid, main_ph.ptid.pid ()); 437 if (inferior_ptid.pid () == -1) 438 inferior_ptid = procfs_first_available (); 439 440 if (ptid.pid () != -1) 441 { 442 ptid_t ptid_for_warning = ptid; 443 444 ptid = thread_to_lwp (ptid, -2); 445 if (ptid.pid () == -2) /* Inactive thread. */ 446 error (_("This version of Solaris can't start inactive threads.")); 447 if (info_verbose && ptid.pid () == -1) 448 warning (_("Specified thread %ld seems to have terminated"), 449 ptid_for_warning.tid ()); 450 } 451 452 rtnval = beneath ()->wait (ptid, ourstatus, options); 453 454 if (ourstatus->kind != TARGET_WAITKIND_EXITED) 455 { 456 /* Map the LWP of interest back to the appropriate thread ID. */ 457 rtnval = lwp_to_thread (rtnval); 458 if (rtnval.pid () == -1) 459 rtnval = save_ptid; 460 461 /* See if we have a new thread. */ 462 if (rtnval.tid_p () && rtnval != save_ptid) 463 { 464 thread_info *thr = find_thread_ptid (rtnval); 465 if (thr == NULL || thr->state == THREAD_EXITED) 466 add_thread (rtnval); 467 } 468 } 469 470 /* During process initialization, we may get here without the thread 471 package being initialized, since that can only happen after we've 472 found the shared libs. */ 473 474 return rtnval; 475 } 476 477 void 478 sol_thread_target::fetch_registers (struct regcache *regcache, int regnum) 479 { 480 thread_t thread; 481 td_thrhandle_t thandle; 482 td_err_e val; 483 prgregset_t gregset; 484 prfpregset_t fpregset; 485 gdb_gregset_t *gregset_p = &gregset; 486 gdb_fpregset_t *fpregset_p = &fpregset; 487 ptid_t ptid = regcache->ptid (); 488 489 if (!ptid.tid_p ()) 490 { 491 /* It's an LWP; pass the request on to the layer beneath. */ 492 beneath ()->fetch_registers (regcache, regnum); 493 return; 494 } 495 496 /* Solaris thread: convert PTID into a td_thrhandle_t. */ 497 thread = ptid.tid (); 498 if (thread == 0) 499 error (_("sol_thread_fetch_registers: thread == 0")); 500 501 val = p_td_ta_map_id2thr (main_ta, thread, &thandle); 502 if (val != TD_OK) 503 error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"), 504 td_err_string (val)); 505 506 /* Get the general-purpose registers. */ 507 508 val = p_td_thr_getgregs (&thandle, gregset); 509 if (val != TD_OK && val != TD_PARTIALREG) 510 error (_("sol_thread_fetch_registers: td_thr_getgregs %s"), 511 td_err_string (val)); 512 513 /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc 514 and %sp are saved (by a thread context switch). */ 515 516 /* And, now the floating-point registers. */ 517 518 val = p_td_thr_getfpregs (&thandle, &fpregset); 519 if (val != TD_OK && val != TD_NOFPREGS) 520 error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"), 521 td_err_string (val)); 522 523 /* Note that we must call supply_gregset and supply_fpregset *after* 524 calling the td routines because the td routines call ps_lget* 525 which affect the values stored in the registers array. */ 526 527 supply_gregset (regcache, (const gdb_gregset_t *) gregset_p); 528 supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset_p); 529 } 530 531 void 532 sol_thread_target::store_registers (struct regcache *regcache, int regnum) 533 { 534 thread_t thread; 535 td_thrhandle_t thandle; 536 td_err_e val; 537 prgregset_t gregset; 538 prfpregset_t fpregset; 539 ptid_t ptid = regcache->ptid (); 540 541 if (!ptid.tid_p ()) 542 { 543 /* It's an LWP; pass the request on to the layer beneath. */ 544 beneath ()->store_registers (regcache, regnum); 545 return; 546 } 547 548 /* Solaris thread: convert PTID into a td_thrhandle_t. */ 549 thread = ptid.tid (); 550 551 val = p_td_ta_map_id2thr (main_ta, thread, &thandle); 552 if (val != TD_OK) 553 error (_("sol_thread_store_registers: td_ta_map_id2thr %s"), 554 td_err_string (val)); 555 556 if (regnum != -1) 557 { 558 val = p_td_thr_getgregs (&thandle, gregset); 559 if (val != TD_OK) 560 error (_("sol_thread_store_registers: td_thr_getgregs %s"), 561 td_err_string (val)); 562 val = p_td_thr_getfpregs (&thandle, &fpregset); 563 if (val != TD_OK) 564 error (_("sol_thread_store_registers: td_thr_getfpregs %s"), 565 td_err_string (val)); 566 } 567 568 fill_gregset (regcache, (gdb_gregset_t *) &gregset, regnum); 569 fill_fpregset (regcache, (gdb_fpregset_t *) &fpregset, regnum); 570 571 val = p_td_thr_setgregs (&thandle, gregset); 572 if (val != TD_OK) 573 error (_("sol_thread_store_registers: td_thr_setgregs %s"), 574 td_err_string (val)); 575 val = p_td_thr_setfpregs (&thandle, &fpregset); 576 if (val != TD_OK) 577 error (_("sol_thread_store_registers: td_thr_setfpregs %s"), 578 td_err_string (val)); 579 } 580 581 /* Perform partial transfers on OBJECT. See target_read_partial and 582 target_write_partial for details of each variant. One, and only 583 one, of readbuf or writebuf must be non-NULL. */ 584 585 enum target_xfer_status 586 sol_thread_target::xfer_partial (enum target_object object, 587 const char *annex, gdb_byte *readbuf, 588 const gdb_byte *writebuf, 589 ULONGEST offset, ULONGEST len, 590 ULONGEST *xfered_len) 591 { 592 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid); 593 594 if (inferior_ptid.tid_p () || !target_thread_alive (inferior_ptid)) 595 { 596 /* It's either a thread or an LWP that isn't alive. Any live 597 LWP will do so use the first available. 598 599 NOTE: We don't need to call switch_to_thread; we're just 600 reading memory. */ 601 inferior_ptid = procfs_first_available (); 602 } 603 604 return beneath ()->xfer_partial (object, annex, readbuf, 605 writebuf, offset, len, xfered_len); 606 } 607 608 static void 609 check_for_thread_db (void) 610 { 611 td_err_e err; 612 ptid_t ptid; 613 614 /* Don't attempt to use thread_db for remote targets. */ 615 if (!(target_can_run () || core_bfd)) 616 return; 617 618 /* Do nothing if we couldn't load libthread_db.so.1. */ 619 if (p_td_ta_new == NULL) 620 return; 621 622 if (sol_thread_active) 623 /* Nothing to do. The thread library was already detected and the 624 target vector was already activated. */ 625 return; 626 627 /* Now, initialize libthread_db. This needs to be done after the 628 shared libraries are located because it needs information from 629 the user's thread library. */ 630 631 err = p_td_init (); 632 if (err != TD_OK) 633 { 634 warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err)); 635 return; 636 } 637 638 /* Now attempt to open a connection to the thread library. */ 639 err = p_td_ta_new (&main_ph, &main_ta); 640 switch (err) 641 { 642 case TD_NOLIBTHREAD: 643 /* No thread library was detected. */ 644 break; 645 646 case TD_OK: 647 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n")); 648 649 /* The thread library was detected. Activate the sol_thread target. */ 650 push_target (&sol_thread_ops); 651 sol_thread_active = 1; 652 653 main_ph.ptid = inferior_ptid; /* Save for xfer_memory. */ 654 ptid = lwp_to_thread (inferior_ptid); 655 if (ptid.pid () != -1) 656 inferior_ptid = ptid; 657 658 target_update_thread_list (); 659 break; 660 661 default: 662 warning (_("Cannot initialize thread debugging library: %s"), 663 td_err_string (err)); 664 break; 665 } 666 } 667 668 /* This routine is called whenever a new symbol table is read in, or 669 when all symbol tables are removed. libthread_db can only be 670 initialized when it finds the right variables in libthread.so. 671 Since it's a shared library, those variables don't show up until 672 the library gets mapped and the symbol table is read in. */ 673 674 static void 675 sol_thread_new_objfile (struct objfile *objfile) 676 { 677 if (objfile != NULL) 678 check_for_thread_db (); 679 } 680 681 /* Clean up after the inferior dies. */ 682 683 void 684 sol_thread_target::mourn_inferior () 685 { 686 target_ops *beneath = this->beneath (); 687 688 sol_thread_active = 0; 689 690 unpush_target (this); 691 692 beneath->mourn_inferior (); 693 } 694 695 /* Return true if PTID is still active in the inferior. */ 696 697 bool 698 sol_thread_target::thread_alive (ptid_t ptid) 699 { 700 if (ptid.tid_p ()) 701 { 702 /* It's a (user-level) thread. */ 703 td_err_e val; 704 td_thrhandle_t th; 705 int pid; 706 707 pid = ptid.tid (); 708 val = p_td_ta_map_id2thr (main_ta, pid, &th); 709 if (val != TD_OK) 710 return false; /* Thread not found. */ 711 val = p_td_thr_validate (&th); 712 if (val != TD_OK) 713 return false; /* Thread not valid. */ 714 return true; /* Known thread. */ 715 } 716 else 717 { 718 /* It's an LPW; pass the request on to the layer below. */ 719 return beneath ()->thread_alive (ptid); 720 } 721 } 722 723 724 /* These routines implement the lower half of the thread_db interface, 725 i.e. the ps_* routines. */ 726 727 /* The next four routines are called by libthread_db to tell us to 728 stop and stop a particular process or lwp. Since GDB ensures that 729 these are all stopped by the time we call anything in thread_db, 730 these routines need to do nothing. */ 731 732 /* Process stop. */ 733 734 ps_err_e 735 ps_pstop (struct ps_prochandle *ph) 736 { 737 return PS_OK; 738 } 739 740 /* Process continue. */ 741 742 ps_err_e 743 ps_pcontinue (struct ps_prochandle *ph) 744 { 745 return PS_OK; 746 } 747 748 /* LWP stop. */ 749 750 ps_err_e 751 ps_lstop (struct ps_prochandle *ph, lwpid_t lwpid) 752 { 753 return PS_OK; 754 } 755 756 /* LWP continue. */ 757 758 ps_err_e 759 ps_lcontinue (struct ps_prochandle *ph, lwpid_t lwpid) 760 { 761 return PS_OK; 762 } 763 764 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */ 765 766 ps_err_e 767 ps_pglobal_lookup (struct ps_prochandle *ph, const char *ld_object_name, 768 const char *ld_symbol_name, psaddr_t *ld_symbol_addr) 769 { 770 struct bound_minimal_symbol ms; 771 772 ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL); 773 if (!ms.minsym) 774 return PS_NOSYM; 775 776 *ld_symbol_addr = BMSYMBOL_VALUE_ADDRESS (ms); 777 return PS_OK; 778 } 779 780 /* Common routine for reading and writing memory. */ 781 782 static ps_err_e 783 rw_common (int dowrite, const struct ps_prochandle *ph, psaddr_t addr, 784 gdb_byte *buf, int size) 785 { 786 int ret; 787 788 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid); 789 790 if (inferior_ptid.tid_p () || !target_thread_alive (inferior_ptid)) 791 { 792 /* It's either a thread or an LWP that isn't alive. Any live 793 LWP will do so use the first available. 794 795 NOTE: We don't need to call switch_to_thread; we're just 796 reading memory. */ 797 inferior_ptid = procfs_first_available (); 798 } 799 800 #if defined (__sparcv9) 801 /* For Sparc64 cross Sparc32, make sure the address has not been 802 accidentally sign-extended (or whatever) to beyond 32 bits. */ 803 if (bfd_get_arch_size (exec_bfd) == 32) 804 addr &= 0xffffffff; 805 #endif 806 807 if (dowrite) 808 ret = target_write_memory (addr, (gdb_byte *) buf, size); 809 else 810 ret = target_read_memory (addr, (gdb_byte *) buf, size); 811 812 return (ret == 0 ? PS_OK : PS_ERR); 813 } 814 815 /* Copies SIZE bytes from target process .data segment to debugger memory. */ 816 817 ps_err_e 818 ps_pdread (struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t size) 819 { 820 return rw_common (0, ph, addr, (gdb_byte *) buf, size); 821 } 822 823 /* Copies SIZE bytes from debugger memory .data segment to target process. */ 824 825 ps_err_e 826 ps_pdwrite (struct ps_prochandle *ph, psaddr_t addr, 827 const void *buf, size_t size) 828 { 829 return rw_common (1, ph, addr, (gdb_byte *) buf, size); 830 } 831 832 /* Copies SIZE bytes from target process .text segment to debugger memory. */ 833 834 ps_err_e 835 ps_ptread (struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t size) 836 { 837 return rw_common (0, ph, addr, (gdb_byte *) buf, size); 838 } 839 840 /* Copies SIZE bytes from debugger memory .text segment to target process. */ 841 842 ps_err_e 843 ps_ptwrite (struct ps_prochandle *ph, psaddr_t addr, 844 const void *buf, size_t size) 845 { 846 return rw_common (1, ph, addr, (gdb_byte *) buf, size); 847 } 848 849 /* Get general-purpose registers for LWP. */ 850 851 ps_err_e 852 ps_lgetregs (struct ps_prochandle *ph, lwpid_t lwpid, prgregset_t gregset) 853 { 854 ptid_t ptid = ptid_t (inferior_ptid.pid (), lwpid, 0); 855 struct regcache *regcache 856 = get_thread_arch_regcache (ptid, target_gdbarch ()); 857 858 target_fetch_registers (regcache, -1); 859 fill_gregset (regcache, (gdb_gregset_t *) gregset, -1); 860 861 return PS_OK; 862 } 863 864 /* Set general-purpose registers for LWP. */ 865 866 ps_err_e 867 ps_lsetregs (struct ps_prochandle *ph, lwpid_t lwpid, 868 const prgregset_t gregset) 869 { 870 ptid_t ptid = ptid_t (inferior_ptid.pid (), lwpid, 0); 871 struct regcache *regcache 872 = get_thread_arch_regcache (ptid, target_gdbarch ()); 873 874 supply_gregset (regcache, (const gdb_gregset_t *) gregset); 875 target_store_registers (regcache, -1); 876 877 return PS_OK; 878 } 879 880 /* Log a message (sends to gdb_stderr). */ 881 882 void 883 ps_plog (const char *fmt, ...) 884 { 885 va_list args; 886 887 va_start (args, fmt); 888 889 vfprintf_filtered (gdb_stderr, fmt, args); 890 } 891 892 /* Get size of extra register set. Currently a noop. */ 893 894 ps_err_e 895 ps_lgetxregsize (struct ps_prochandle *ph, lwpid_t lwpid, int *xregsize) 896 { 897 return PS_OK; 898 } 899 900 /* Get extra register set. Currently a noop. */ 901 902 ps_err_e 903 ps_lgetxregs (struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset) 904 { 905 return PS_OK; 906 } 907 908 /* Set extra register set. Currently a noop. */ 909 910 ps_err_e 911 ps_lsetxregs (struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset) 912 { 913 return PS_OK; 914 } 915 916 /* Get floating-point registers for LWP. */ 917 918 ps_err_e 919 ps_lgetfpregs (struct ps_prochandle *ph, lwpid_t lwpid, 920 prfpregset_t *fpregset) 921 { 922 ptid_t ptid = ptid_t (inferior_ptid.pid (), lwpid, 0); 923 struct regcache *regcache 924 = get_thread_arch_regcache (ptid, target_gdbarch ()); 925 926 target_fetch_registers (regcache, -1); 927 fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1); 928 929 return PS_OK; 930 } 931 932 /* Set floating-point regs for LWP. */ 933 934 ps_err_e 935 ps_lsetfpregs (struct ps_prochandle *ph, lwpid_t lwpid, 936 const prfpregset_t * fpregset) 937 { 938 ptid_t ptid = ptid_t (inferior_ptid.pid (), lwpid, 0); 939 struct regcache *regcache 940 = get_thread_arch_regcache (ptid, target_gdbarch ()); 941 942 supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset); 943 target_store_registers (regcache, -1); 944 945 return PS_OK; 946 } 947 948 /* Identify process as 32-bit or 64-bit. At the moment we're using 949 BFD to do this. There might be a more Solaris-specific 950 (e.g. procfs) method, but this ought to work. */ 951 952 ps_err_e 953 ps_pdmodel (struct ps_prochandle *ph, int *data_model) 954 { 955 if (exec_bfd == 0) 956 *data_model = PR_MODEL_UNKNOWN; 957 else if (bfd_get_arch_size (exec_bfd) == 32) 958 *data_model = PR_MODEL_ILP32; 959 else 960 *data_model = PR_MODEL_LP64; 961 962 return PS_OK; 963 } 964 965 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun) 966 967 /* Reads the local descriptor table of a LWP. 968 969 This function is necessary on x86-solaris only. Without it, the loading 970 of libthread_db would fail because of ps_lgetLDT being undefined. */ 971 972 ps_err_e 973 ps_lgetLDT (struct ps_prochandle *ph, lwpid_t lwpid, struct ssd *pldt) /* ARI: editCase function */ 974 { 975 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */ 976 struct ssd *ret; 977 978 /* FIXME: can't I get the process ID from the prochandle or 979 something? */ 980 981 if (inferior_ptid.pid () <= 0 || lwpid <= 0) 982 return PS_BADLID; 983 984 ret = procfs_find_LDT_entry (ptid_t (inferior_ptid.pid (), 985 lwpid, 0)); 986 if (ret) 987 { 988 memcpy (pldt, ret, sizeof (struct ssd)); 989 return PS_OK; 990 } 991 else 992 /* LDT not found. */ 993 return PS_ERR; 994 } 995 #endif 996 997 998 /* Convert PTID to printable form. */ 999 1000 const char * 1001 sol_thread_target::pid_to_str (ptid_t ptid) 1002 { 1003 static char buf[100]; 1004 1005 if (ptid.tid_p ()) 1006 { 1007 ptid_t lwp; 1008 1009 lwp = thread_to_lwp (ptid, -2); 1010 1011 if (lwp.pid () == -1) 1012 xsnprintf (buf, sizeof (buf), "Thread %ld (defunct)", 1013 ptid.tid ()); 1014 else if (lwp.pid () != -2) 1015 xsnprintf (buf, sizeof (buf), "Thread %ld (LWP %ld)", 1016 ptid.tid (), lwp.lwp ()); 1017 else 1018 xsnprintf (buf, sizeof (buf), "Thread %ld ", 1019 ptid.tid ()); 1020 } 1021 else if (ptid.lwp () != 0) 1022 xsnprintf (buf, sizeof (buf), "LWP %ld ", ptid.lwp ()); 1023 else 1024 xsnprintf (buf, sizeof (buf), "process %d ", ptid.pid ()); 1025 1026 return buf; 1027 } 1028 1029 1030 /* Worker bee for update_thread_list. Callback function that gets 1031 called once per user-level thread (i.e. not for LWP's). */ 1032 1033 static int 1034 sol_update_thread_list_callback (const td_thrhandle_t *th, void *ignored) 1035 { 1036 td_err_e retval; 1037 td_thrinfo_t ti; 1038 1039 retval = p_td_thr_get_info (th, &ti); 1040 if (retval != TD_OK) 1041 return -1; 1042 1043 ptid_t ptid = ptid_t (inferior_ptid.pid (), 0, ti.ti_tid); 1044 thread_info *thr = find_thread_ptid (ptid); 1045 if (thr == NULL || thr->state == THREAD_EXITED) 1046 add_thread (ptid); 1047 1048 return 0; 1049 } 1050 1051 void 1052 sol_thread_target::update_thread_list () 1053 { 1054 /* Delete dead threads. */ 1055 prune_threads (); 1056 1057 /* Find any new LWP's. */ 1058 beneath ()->update_thread_list (); 1059 1060 /* Then find any new user-level threads. */ 1061 p_td_ta_thr_iter (main_ta, sol_update_thread_list_callback, (void *) 0, 1062 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY, 1063 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS); 1064 } 1065 1066 /* Worker bee for the "info sol-thread" command. This is a callback 1067 function that gets called once for each Solaris user-level thread 1068 (i.e. not for LWPs) in the inferior. Print anything interesting 1069 that we can think of. */ 1070 1071 static int 1072 info_cb (const td_thrhandle_t *th, void *s) 1073 { 1074 td_err_e ret; 1075 td_thrinfo_t ti; 1076 1077 ret = p_td_thr_get_info (th, &ti); 1078 if (ret == TD_OK) 1079 { 1080 printf_filtered ("%s thread #%d, lwp %d, ", 1081 ti.ti_type == TD_THR_SYSTEM ? "system" : "user ", 1082 ti.ti_tid, ti.ti_lid); 1083 switch (ti.ti_state) 1084 { 1085 default: 1086 case TD_THR_UNKNOWN: 1087 printf_filtered ("<unknown state>"); 1088 break; 1089 case TD_THR_STOPPED: 1090 printf_filtered ("(stopped)"); 1091 break; 1092 case TD_THR_RUN: 1093 printf_filtered ("(run) "); 1094 break; 1095 case TD_THR_ACTIVE: 1096 printf_filtered ("(active) "); 1097 break; 1098 case TD_THR_ZOMBIE: 1099 printf_filtered ("(zombie) "); 1100 break; 1101 case TD_THR_SLEEP: 1102 printf_filtered ("(asleep) "); 1103 break; 1104 case TD_THR_STOPPED_ASLEEP: 1105 printf_filtered ("(stopped asleep)"); 1106 break; 1107 } 1108 /* Print thr_create start function. */ 1109 if (ti.ti_startfunc != 0) 1110 { 1111 const struct bound_minimal_symbol msym 1112 = lookup_minimal_symbol_by_pc (ti.ti_startfunc); 1113 1114 printf_filtered (" startfunc=%s", 1115 msym.minsym 1116 ? MSYMBOL_PRINT_NAME (msym.minsym) 1117 : paddress (target_gdbarch (), ti.ti_startfunc)); 1118 } 1119 1120 /* If thread is asleep, print function that went to sleep. */ 1121 if (ti.ti_state == TD_THR_SLEEP) 1122 { 1123 const struct bound_minimal_symbol msym 1124 = lookup_minimal_symbol_by_pc (ti.ti_pc); 1125 1126 printf_filtered (" sleepfunc=%s", 1127 msym.minsym 1128 ? MSYMBOL_PRINT_NAME (msym.minsym) 1129 : paddress (target_gdbarch (), ti.ti_pc)); 1130 } 1131 1132 printf_filtered ("\n"); 1133 } 1134 else 1135 warning (_("info sol-thread: failed to get info for thread.")); 1136 1137 return 0; 1138 } 1139 1140 /* List some state about each Solaris user-level thread in the 1141 inferior. */ 1142 1143 static void 1144 info_solthreads (const char *args, int from_tty) 1145 { 1146 p_td_ta_thr_iter (main_ta, info_cb, (void *) args, 1147 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY, 1148 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS); 1149 } 1150 1151 /* Callback routine used to find a thread based on the TID part of 1152 its PTID. */ 1153 1154 static int 1155 thread_db_find_thread_from_tid (struct thread_info *thread, void *data) 1156 { 1157 long *tid = (long *) data; 1158 1159 if (thread->ptid.tid () == *tid) 1160 return 1; 1161 1162 return 0; 1163 } 1164 1165 ptid_t 1166 sol_thread_target::get_ada_task_ptid (long lwp, long thread) 1167 { 1168 struct thread_info *thread_info = 1169 iterate_over_threads (thread_db_find_thread_from_tid, &thread); 1170 1171 if (thread_info == NULL) 1172 { 1173 /* The list of threads is probably not up to date. Find any 1174 thread that is missing from the list, and try again. */ 1175 update_thread_list (); 1176 thread_info = iterate_over_threads (thread_db_find_thread_from_tid, 1177 &thread); 1178 } 1179 1180 gdb_assert (thread_info != NULL); 1181 1182 return (thread_info->ptid); 1183 } 1184 1185 void 1186 _initialize_sol_thread (void) 1187 { 1188 void *dlhandle; 1189 1190 dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW); 1191 if (!dlhandle) 1192 goto die; 1193 1194 #define resolve(X) \ 1195 if (!(p_##X = (X ## _ftype *) dlsym (dlhandle, #X))) \ 1196 goto die; 1197 1198 resolve (td_log); 1199 resolve (td_ta_new); 1200 resolve (td_ta_delete); 1201 resolve (td_init); 1202 resolve (td_ta_get_ph); 1203 resolve (td_ta_get_nthreads); 1204 resolve (td_ta_tsd_iter); 1205 resolve (td_ta_thr_iter); 1206 resolve (td_thr_validate); 1207 resolve (td_thr_tsd); 1208 resolve (td_thr_get_info); 1209 resolve (td_thr_getfpregs); 1210 resolve (td_thr_getxregsize); 1211 resolve (td_thr_getxregs); 1212 resolve (td_thr_sigsetmask); 1213 resolve (td_thr_setprio); 1214 resolve (td_thr_setsigpending); 1215 resolve (td_thr_setfpregs); 1216 resolve (td_thr_setxregs); 1217 resolve (td_ta_map_id2thr); 1218 resolve (td_ta_map_lwp2thr); 1219 resolve (td_thr_getgregs); 1220 resolve (td_thr_setgregs); 1221 1222 add_cmd ("sol-threads", class_maintenance, info_solthreads, 1223 _("Show info on Solaris user threads."), &maintenanceinfolist); 1224 1225 /* Hook into new_objfile notification. */ 1226 gdb::observers::new_objfile.attach (sol_thread_new_objfile); 1227 return; 1228 1229 die: 1230 fprintf_unfiltered (gdb_stderr, "\ 1231 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ()); 1232 1233 if (dlhandle) 1234 dlclose (dlhandle); 1235 1236 return; 1237 } 1238