1 /* Solaris threads debugging interface.
3 Copyright (C) 1996-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
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.
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.
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!
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. */
53 #include <proc_service.h>
54 #include <thread_db.h>
55 #include "gdbthread.h"
67 #include "gdb_string.h"
70 struct target_ops sol_thread_ops;
72 /* Prototypes for supply_gregset etc. */
75 /* This struct is defined by us, but mainly used for the proc_service
76 interface. We don't have much use for it, except as a handy place
77 to get a real PID for memory accesses. */
90 static struct ps_prochandle main_ph;
91 static td_thragent_t *main_ta;
92 static int sol_thread_active = 0;
94 static void init_sol_thread_ops (void);
96 /* Default definitions: These must be defined in tm.h if they are to
97 be shared with a process module such as procfs. */
99 #define GET_PID(ptid) ptid_get_pid (ptid)
100 #define GET_LWP(ptid) ptid_get_lwp (ptid)
101 #define GET_THREAD(ptid) ptid_get_tid (ptid)
103 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
104 #define is_thread(ptid) (GET_THREAD (ptid) != 0)
106 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
107 #define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid)
109 /* Pointers to routines from libthread_db resolved by dlopen(). */
111 static void (*p_td_log)(const int on_off);
112 static td_err_e (*p_td_ta_new)(const struct ps_prochandle *ph_p,
113 td_thragent_t **ta_pp);
114 static td_err_e (*p_td_ta_delete)(td_thragent_t *ta_p);
115 static td_err_e (*p_td_init)(void);
116 static td_err_e (*p_td_ta_get_ph)(const td_thragent_t *ta_p,
117 struct ps_prochandle **ph_pp);
118 static td_err_e (*p_td_ta_get_nthreads)(const td_thragent_t *ta_p,
120 static td_err_e (*p_td_ta_tsd_iter)(const td_thragent_t *ta_p,
121 td_key_iter_f *cb, void *cbdata_p);
122 static td_err_e (*p_td_ta_thr_iter)(const td_thragent_t *ta_p,
123 td_thr_iter_f *cb, void *cbdata_p,
124 td_thr_state_e state, int ti_pri,
125 sigset_t *ti_sigmask_p,
126 unsigned ti_user_flags);
127 static td_err_e (*p_td_thr_validate)(const td_thrhandle_t *th_p);
128 static td_err_e (*p_td_thr_tsd)(const td_thrhandle_t * th_p,
129 const thread_key_t key, void **data_pp);
130 static td_err_e (*p_td_thr_get_info)(const td_thrhandle_t *th_p,
132 static td_err_e (*p_td_thr_getfpregs)(const td_thrhandle_t *th_p,
133 prfpregset_t *fpregset);
134 static td_err_e (*p_td_thr_getxregsize)(const td_thrhandle_t *th_p,
136 static td_err_e (*p_td_thr_getxregs)(const td_thrhandle_t *th_p,
137 const caddr_t xregset);
138 static td_err_e (*p_td_thr_sigsetmask)(const td_thrhandle_t *th_p,
139 const sigset_t ti_sigmask);
140 static td_err_e (*p_td_thr_setprio)(const td_thrhandle_t *th_p,
142 static td_err_e (*p_td_thr_setsigpending)(const td_thrhandle_t *th_p,
143 const uchar_t ti_pending_flag,
144 const sigset_t ti_pending);
145 static td_err_e (*p_td_thr_setfpregs)(const td_thrhandle_t *th_p,
146 const prfpregset_t *fpregset);
147 static td_err_e (*p_td_thr_setxregs)(const td_thrhandle_t *th_p,
148 const caddr_t xregset);
149 static td_err_e (*p_td_ta_map_id2thr)(const td_thragent_t *ta_p,
151 td_thrhandle_t *th_p);
152 static td_err_e (*p_td_ta_map_lwp2thr)(const td_thragent_t *ta_p,
154 td_thrhandle_t *th_p);
155 static td_err_e (*p_td_thr_getgregs)(const td_thrhandle_t *th_p,
157 static td_err_e (*p_td_thr_setgregs)(const td_thrhandle_t *th_p,
158 const prgregset_t regset);
161 /* Return the libthread_db error string associated with ERRCODE. If
162 ERRCODE is unknown, return an appropriate message. */
165 td_err_string (td_err_e errcode)
167 static struct string_map td_err_table[] =
169 { TD_OK, "generic \"call succeeded\"" },
170 { TD_ERR, "generic error." },
171 { TD_NOTHR, "no thread can be found to satisfy query" },
172 { TD_NOSV, "no synch. variable can be found to satisfy query" },
173 { TD_NOLWP, "no lwp can be found to satisfy query" },
174 { TD_BADPH, "invalid process handle" },
175 { TD_BADTH, "invalid thread handle" },
176 { TD_BADSH, "invalid synchronization handle" },
177 { TD_BADTA, "invalid thread agent" },
178 { TD_BADKEY, "invalid key" },
179 { TD_NOMSG, "td_thr_event_getmsg() called when there was no message" },
180 { TD_NOFPREGS, "FPU register set not available for given thread" },
181 { TD_NOLIBTHREAD, "application not linked with libthread" },
182 { TD_NOEVENT, "requested event is not supported" },
183 { TD_NOCAPAB, "capability not available" },
184 { TD_DBERR, "Debugger service failed" },
185 { TD_NOAPLIC, "Operation not applicable to" },
186 { TD_NOTSD, "No thread specific data for this thread" },
187 { TD_MALLOC, "Malloc failed" },
188 { TD_PARTIALREG, "Only part of register set was written/read" },
189 { TD_NOXREGS, "X register set not available for given thread" }
191 const int td_err_size = sizeof td_err_table / sizeof (struct string_map);
195 for (i = 0; i < td_err_size; i++)
196 if (td_err_table[i].num == errcode)
197 return td_err_table[i].str;
199 xsnprintf (buf, sizeof (buf), "Unknown libthread_db error code: %d",
205 /* Return the libthread_db state string assicoated with STATECODE.
206 If STATECODE is unknown, return an appropriate message. */
209 td_state_string (td_thr_state_e statecode)
211 static struct string_map td_thr_state_table[] =
213 { TD_THR_ANY_STATE, "any state" },
214 { TD_THR_UNKNOWN, "unknown" },
215 { TD_THR_STOPPED, "stopped" },
216 { TD_THR_RUN, "run" },
217 { TD_THR_ACTIVE, "active" },
218 { TD_THR_ZOMBIE, "zombie" },
219 { TD_THR_SLEEP, "sleep" },
220 { TD_THR_STOPPED_ASLEEP, "stopped asleep" }
222 const int td_thr_state_table_size =
223 sizeof td_thr_state_table / sizeof (struct string_map);
227 for (i = 0; i < td_thr_state_table_size; i++)
228 if (td_thr_state_table[i].num == statecode)
229 return td_thr_state_table[i].str;
231 xsnprintf (buf, sizeof (buf), "Unknown libthread_db state code: %d",
238 /* Convert a POSIX or Solaris thread ID into a LWP ID. If THREAD_ID
239 doesn't exist, that's an error. If it's an inactive thread, return
242 NOTE: This function probably shouldn't call error(). */
245 thread_to_lwp (ptid_t thread_id, int default_lwp)
251 if (is_lwp (thread_id))
252 return thread_id; /* It's already an LWP ID. */
254 /* It's a thread. Convert to LWP. */
256 val = p_td_ta_map_id2thr (main_ta, GET_THREAD (thread_id), &th);
258 return pid_to_ptid (-1); /* Thread must have terminated. */
259 else if (val != TD_OK)
260 error (_("thread_to_lwp: td_ta_map_id2thr %s"), td_err_string (val));
262 val = p_td_thr_get_info (&th, &ti);
264 return pid_to_ptid (-1); /* Thread must have terminated. */
265 else if (val != TD_OK)
266 error (_("thread_to_lwp: td_thr_get_info: %s"), td_err_string (val));
268 if (ti.ti_state != TD_THR_ACTIVE)
270 if (default_lwp != -1)
271 return pid_to_ptid (default_lwp);
272 error (_("thread_to_lwp: thread state not active: %s"),
273 td_state_string (ti.ti_state));
276 return BUILD_LWP (ti.ti_lid, PIDGET (thread_id));
279 /* Convert an LWP ID into a POSIX or Solaris thread ID. If LWP_ID
280 doesn't exists, that's an error.
282 NOTE: This function probably shouldn't call error(). */
285 lwp_to_thread (ptid_t lwp)
292 return lwp; /* It's already a thread ID. */
294 /* It's an LWP. Convert it to a thread ID. */
296 if (!target_thread_alive (lwp))
297 return pid_to_ptid (-1); /* Must be a defunct LPW. */
299 val = p_td_ta_map_lwp2thr (main_ta, GET_LWP (lwp), &th);
301 return pid_to_ptid (-1); /* Thread must have terminated. */
302 else if (val != TD_OK)
303 error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val));
305 val = p_td_thr_validate (&th);
307 return lwp; /* Unknown to libthread; just return LPW, */
308 else if (val != TD_OK)
309 error (_("lwp_to_thread: td_thr_validate: %s."), td_err_string (val));
311 val = p_td_thr_get_info (&th, &ti);
313 return pid_to_ptid (-1); /* Thread must have terminated. */
314 else if (val != TD_OK)
315 error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val));
317 return BUILD_THREAD (ti.ti_tid, PIDGET (lwp));
321 /* Most target vector functions from here on actually just pass
322 through to the layer beneath, as they don't need to do anything
323 specific for threads. */
325 /* Take a program previously attached to and detaches it. The program
326 resumes execution and will no longer stop on signals, etc. We'd
327 better not have left any breakpoints in the program or it'll die
328 when it hits one. For this to work, it may be necessary for the
329 process to have been previously attached. It *might* work if the
330 program was started via the normal ptrace (PTRACE_TRACEME). */
333 sol_thread_detach (struct target_ops *ops, char *args, int from_tty)
335 struct target_ops *beneath = find_target_beneath (ops);
337 sol_thread_active = 0;
338 inferior_ptid = pid_to_ptid (PIDGET (main_ph.ptid));
340 beneath->to_detach (beneath, args, from_tty);
343 /* Resume execution of process PTID. If STEP is nozero, then just
344 single step it. If SIGNAL is nonzero, restart it with that signal
345 activated. We may have to convert PTID from a thread ID to an LWP
349 sol_thread_resume (struct target_ops *ops,
350 ptid_t ptid, int step, enum gdb_signal signo)
352 struct cleanup *old_chain;
353 struct target_ops *beneath = find_target_beneath (ops);
355 old_chain = save_inferior_ptid ();
357 inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid));
358 if (PIDGET (inferior_ptid) == -1)
359 inferior_ptid = procfs_first_available ();
361 if (PIDGET (ptid) != -1)
363 ptid_t save_ptid = ptid;
365 ptid = thread_to_lwp (ptid, -2);
366 if (PIDGET (ptid) == -2) /* Inactive thread. */
367 error (_("This version of Solaris can't start inactive threads."));
368 if (info_verbose && PIDGET (ptid) == -1)
369 warning (_("Specified thread %ld seems to have terminated"),
370 GET_THREAD (save_ptid));
373 beneath->to_resume (beneath, ptid, step, signo);
375 do_cleanups (old_chain);
378 /* Wait for any threads to stop. We may have to convert PTID from a
379 thread ID to an LWP ID, and vice versa on the way out. */
382 sol_thread_wait (struct target_ops *ops,
383 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
387 struct target_ops *beneath = find_target_beneath (ops);
388 struct cleanup *old_chain;
390 save_ptid = inferior_ptid;
391 old_chain = save_inferior_ptid ();
393 inferior_ptid = thread_to_lwp (inferior_ptid, PIDGET (main_ph.ptid));
394 if (PIDGET (inferior_ptid) == -1)
395 inferior_ptid = procfs_first_available ();
397 if (PIDGET (ptid) != -1)
399 ptid_t save_ptid = ptid;
401 ptid = thread_to_lwp (ptid, -2);
402 if (PIDGET (ptid) == -2) /* Inactive thread. */
403 error (_("This version of Solaris can't start inactive threads."));
404 if (info_verbose && PIDGET (ptid) == -1)
405 warning (_("Specified thread %ld seems to have terminated"),
406 GET_THREAD (save_ptid));
409 rtnval = beneath->to_wait (beneath, ptid, ourstatus, options);
411 if (ourstatus->kind != TARGET_WAITKIND_EXITED)
413 /* Map the LWP of interest back to the appropriate thread ID. */
414 rtnval = lwp_to_thread (rtnval);
415 if (PIDGET (rtnval) == -1)
418 /* See if we have a new thread. */
419 if (is_thread (rtnval)
420 && !ptid_equal (rtnval, save_ptid)
421 && (!in_thread_list (rtnval)
422 || is_exited (rtnval)))
426 /* During process initialization, we may get here without the thread
427 package being initialized, since that can only happen after we've
428 found the shared libs. */
430 do_cleanups (old_chain);
436 sol_thread_fetch_registers (struct target_ops *ops,
437 struct regcache *regcache, int regnum)
440 td_thrhandle_t thandle;
443 prfpregset_t fpregset;
444 gdb_gregset_t *gregset_p = &gregset;
445 gdb_fpregset_t *fpregset_p = &fpregset;
446 struct target_ops *beneath = find_target_beneath (ops);
448 if (!is_thread (inferior_ptid))
450 /* It's an LWP; pass the request on to the layer beneath. */
451 beneath->to_fetch_registers (beneath, regcache, regnum);
455 /* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t. */
456 thread = GET_THREAD (inferior_ptid);
458 error (_("sol_thread_fetch_registers: thread == 0"));
460 val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
462 error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
463 td_err_string (val));
465 /* Get the general-purpose registers. */
467 val = p_td_thr_getgregs (&thandle, gregset);
468 if (val != TD_OK && val != TD_PARTIALREG)
469 error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
470 td_err_string (val));
472 /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
473 and %sp are saved (by a thread context switch). */
475 /* And, now the floating-point registers. */
477 val = p_td_thr_getfpregs (&thandle, &fpregset);
478 if (val != TD_OK && val != TD_NOFPREGS)
479 error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
480 td_err_string (val));
482 /* Note that we must call supply_gregset and supply_fpregset *after*
483 calling the td routines because the td routines call ps_lget*
484 which affect the values stored in the registers array. */
486 supply_gregset (regcache, (const gdb_gregset_t *) gregset_p);
487 supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset_p);
491 sol_thread_store_registers (struct target_ops *ops,
492 struct regcache *regcache, int regnum)
495 td_thrhandle_t thandle;
498 prfpregset_t fpregset;
500 if (!is_thread (inferior_ptid))
502 struct target_ops *beneath = find_target_beneath (ops);
504 /* It's an LWP; pass the request on to the layer beneath. */
505 beneath->to_store_registers (beneath, regcache, regnum);
509 /* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t. */
510 thread = GET_THREAD (inferior_ptid);
512 val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
514 error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
515 td_err_string (val));
519 /* Not writing all the registers. */
520 char old_value[MAX_REGISTER_SIZE];
522 /* Save new register value. */
523 regcache_raw_collect (regcache, regnum, old_value);
525 val = p_td_thr_getgregs (&thandle, gregset);
527 error (_("sol_thread_store_registers: td_thr_getgregs %s"),
528 td_err_string (val));
529 val = p_td_thr_getfpregs (&thandle, &fpregset);
531 error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
532 td_err_string (val));
534 /* Restore new register value. */
535 regcache_raw_supply (regcache, regnum, old_value);
538 fill_gregset (regcache, (gdb_gregset_t *) &gregset, regnum);
539 fill_fpregset (regcache, (gdb_fpregset_t *) &fpregset, regnum);
541 val = p_td_thr_setgregs (&thandle, gregset);
543 error (_("sol_thread_store_registers: td_thr_setgregs %s"),
544 td_err_string (val));
545 val = p_td_thr_setfpregs (&thandle, &fpregset);
547 error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
548 td_err_string (val));
551 /* Perform partial transfers on OBJECT. See target_read_partial and
552 target_write_partial for details of each variant. One, and only
553 one, of readbuf or writebuf must be non-NULL. */
556 sol_thread_xfer_partial (struct target_ops *ops, enum target_object object,
557 const char *annex, gdb_byte *readbuf,
558 const gdb_byte *writebuf,
559 ULONGEST offset, LONGEST len)
562 struct cleanup *old_chain;
563 struct target_ops *beneath = find_target_beneath (ops);
565 old_chain = save_inferior_ptid ();
567 if (is_thread (inferior_ptid) || !target_thread_alive (inferior_ptid))
569 /* It's either a thread or an LWP that isn't alive. Any live
570 LWP will do so use the first available.
572 NOTE: We don't need to call switch_to_thread; we're just
574 inferior_ptid = procfs_first_available ();
577 retval = beneath->to_xfer_partial (beneath, object, annex,
578 readbuf, writebuf, offset, len);
580 do_cleanups (old_chain);
586 check_for_thread_db (void)
591 /* Do nothing if we couldn't load libthread_db.so.1. */
592 if (p_td_ta_new == NULL)
595 if (sol_thread_active)
596 /* Nothing to do. The thread library was already detected and the
597 target vector was already activated. */
600 /* Now, initialize libthread_db. This needs to be done after the
601 shared libraries are located because it needs information from
602 the user's thread library. */
607 warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err));
611 /* Now attempt to open a connection to the thread library. */
612 err = p_td_ta_new (&main_ph, &main_ta);
616 /* No thread library was detected. */
620 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
622 /* The thread library was detected. Activate the sol_thread target. */
623 push_target (&sol_thread_ops);
624 sol_thread_active = 1;
626 main_ph.ptid = inferior_ptid; /* Save for xfer_memory. */
627 ptid = lwp_to_thread (inferior_ptid);
628 if (PIDGET (ptid) != -1)
629 inferior_ptid = ptid;
631 target_find_new_threads ();
635 warning (_("Cannot initialize thread debugging library: %s"),
636 td_err_string (err));
641 /* This routine is called whenever a new symbol table is read in, or
642 when all symbol tables are removed. libthread_db can only be
643 initialized when it finds the right variables in libthread.so.
644 Since it's a shared library, those variables don't show up until
645 the library gets mapped and the symbol table is read in. */
648 sol_thread_new_objfile (struct objfile *objfile)
651 check_for_thread_db ();
654 /* Clean up after the inferior dies. */
657 sol_thread_mourn_inferior (struct target_ops *ops)
659 struct target_ops *beneath = find_target_beneath (ops);
661 sol_thread_active = 0;
665 beneath->to_mourn_inferior (beneath);
668 /* Return true if PTID is still active in the inferior. */
671 sol_thread_alive (struct target_ops *ops, ptid_t ptid)
673 if (is_thread (ptid))
675 /* It's a (user-level) thread. */
680 pid = GET_THREAD (ptid);
681 if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
682 return 0; /* Thread not found. */
683 if ((val = p_td_thr_validate (&th)) != TD_OK)
684 return 0; /* Thread not valid. */
685 return 1; /* Known thread. */
689 struct target_ops *beneath = find_target_beneath (ops);
691 /* It's an LPW; pass the request on to the layer below. */
692 return beneath->to_thread_alive (beneath, ptid);
697 /* These routines implement the lower half of the thread_db interface,
698 i.e. the ps_* routines. */
700 /* Various versions of <proc_service.h> have slightly different
701 function prototypes. In particular, we have
704 struct ps_prochandle * const struct ps_prochandle *
709 Which one you have depends on the Solaris version and what patches
710 you've applied. On the theory that there are only two major
711 variants, we have configure check the prototype of ps_pdwrite (),
712 and use that info to make appropriate typedefs here. */
714 #ifdef PROC_SERVICE_IS_OLD
715 typedef const struct ps_prochandle *gdb_ps_prochandle_t;
716 typedef char *gdb_ps_read_buf_t;
717 typedef char *gdb_ps_write_buf_t;
718 typedef int gdb_ps_size_t;
719 typedef psaddr_t gdb_ps_addr_t;
721 typedef struct ps_prochandle *gdb_ps_prochandle_t;
722 typedef void *gdb_ps_read_buf_t;
723 typedef const void *gdb_ps_write_buf_t;
724 typedef size_t gdb_ps_size_t;
725 typedef psaddr_t gdb_ps_addr_t;
728 /* The next four routines are called by libthread_db to tell us to
729 stop and stop a particular process or lwp. Since GDB ensures that
730 these are all stopped by the time we call anything in thread_db,
731 these routines need to do nothing. */
736 ps_pstop (gdb_ps_prochandle_t ph)
741 /* Process continue. */
744 ps_pcontinue (gdb_ps_prochandle_t ph)
752 ps_lstop (gdb_ps_prochandle_t ph, lwpid_t lwpid)
760 ps_lcontinue (gdb_ps_prochandle_t ph, lwpid_t lwpid)
765 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
768 ps_pglobal_lookup (gdb_ps_prochandle_t ph, const char *ld_object_name,
769 const char *ld_symbol_name, gdb_ps_addr_t *ld_symbol_addr)
771 struct minimal_symbol *ms;
773 ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
777 *ld_symbol_addr = SYMBOL_VALUE_ADDRESS (ms);
781 /* Common routine for reading and writing memory. */
784 rw_common (int dowrite, const struct ps_prochandle *ph, gdb_ps_addr_t addr,
788 struct cleanup *old_chain;
790 old_chain = save_inferior_ptid ();
792 if (is_thread (inferior_ptid) || !target_thread_alive (inferior_ptid))
794 /* It's either a thread or an LWP that isn't alive. Any live
795 LWP will do so use the first available.
797 NOTE: We don't need to call switch_to_thread; we're just
799 inferior_ptid = procfs_first_available ();
802 #if defined (__sparcv9)
803 /* For Sparc64 cross Sparc32, make sure the address has not been
804 accidentally sign-extended (or whatever) to beyond 32 bits. */
805 if (bfd_get_arch_size (exec_bfd) == 32)
810 ret = target_write_memory (addr, buf, size);
812 ret = target_read_memory (addr, buf, size);
814 do_cleanups (old_chain);
816 return (ret == 0 ? PS_OK : PS_ERR);
819 /* Copies SIZE bytes from target process .data segment to debugger memory. */
822 ps_pdread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
823 gdb_ps_read_buf_t buf, gdb_ps_size_t size)
825 return rw_common (0, ph, addr, buf, size);
828 /* Copies SIZE bytes from debugger memory .data segment to target process. */
831 ps_pdwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
832 gdb_ps_write_buf_t buf, gdb_ps_size_t size)
834 return rw_common (1, ph, addr, (char *) buf, size);
837 /* Copies SIZE bytes from target process .text segment to debugger memory. */
840 ps_ptread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
841 gdb_ps_read_buf_t buf, gdb_ps_size_t size)
843 return rw_common (0, ph, addr, buf, size);
846 /* Copies SIZE bytes from debugger memory .text segment to target process. */
849 ps_ptwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
850 gdb_ps_write_buf_t buf, gdb_ps_size_t size)
852 return rw_common (1, ph, addr, (char *) buf, size);
855 /* Get general-purpose registers for LWP. */
858 ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
860 struct cleanup *old_chain;
861 struct regcache *regcache;
863 old_chain = save_inferior_ptid ();
865 inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
866 regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
868 target_fetch_registers (regcache, -1);
869 fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
871 do_cleanups (old_chain);
876 /* Set general-purpose registers for LWP. */
879 ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
880 const prgregset_t gregset)
882 struct cleanup *old_chain;
883 struct regcache *regcache;
885 old_chain = save_inferior_ptid ();
887 inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
888 regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
890 supply_gregset (regcache, (const gdb_gregset_t *) gregset);
891 target_store_registers (regcache, -1);
893 do_cleanups (old_chain);
898 /* Log a message (sends to gdb_stderr). */
901 ps_plog (const char *fmt, ...)
905 va_start (args, fmt);
907 vfprintf_filtered (gdb_stderr, fmt, args);
910 /* Get floating-point registers for LWP. */
913 ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
914 prfpregset_t *fpregset)
916 struct cleanup *old_chain;
917 struct regcache *regcache;
919 old_chain = save_inferior_ptid ();
921 inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
922 regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
924 target_fetch_registers (regcache, -1);
925 fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
927 do_cleanups (old_chain);
932 /* Set floating-point regs for LWP. */
935 ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
936 const prfpregset_t * fpregset)
938 struct cleanup *old_chain;
939 struct regcache *regcache;
941 old_chain = save_inferior_ptid ();
943 inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
944 regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
946 supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
947 target_store_registers (regcache, -1);
949 do_cleanups (old_chain);
955 /* Identify process as 32-bit or 64-bit. At the moment we're using
956 BFD to do this. There might be a more Solaris-specific
957 (e.g. procfs) method, but this ought to work. */
960 ps_pdmodel (gdb_ps_prochandle_t ph, int *data_model)
963 *data_model = PR_MODEL_UNKNOWN;
964 else if (bfd_get_arch_size (exec_bfd) == 32)
965 *data_model = PR_MODEL_ILP32;
967 *data_model = PR_MODEL_LP64;
971 #endif /* PR_MODEL_LP64 */
973 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
975 /* Reads the local descriptor table of a LWP.
977 This function is necessary on x86-solaris only. Without it, the loading
978 of libthread_db would fail because of ps_lgetLDT being undefined. */
981 ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
984 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */
987 /* FIXME: can't I get the process ID from the prochandle or
990 if (PIDGET (inferior_ptid) <= 0 || lwpid <= 0)
993 ret = procfs_find_LDT_entry (BUILD_LWP (lwpid, PIDGET (inferior_ptid)));
996 memcpy (pldt, ret, sizeof (struct ssd));
1000 /* LDT not found. */
1006 /* Convert PTID to printable form. */
1009 solaris_pid_to_str (struct target_ops *ops, ptid_t ptid)
1011 static char buf[100];
1013 if (is_thread (ptid))
1017 lwp = thread_to_lwp (ptid, -2);
1019 if (PIDGET (lwp) == -1)
1020 xsnprintf (buf, sizeof (buf), "Thread %ld (defunct)",
1022 else if (PIDGET (lwp) != -2)
1023 xsnprintf (buf, sizeof (buf), "Thread %ld (LWP %ld)",
1024 GET_THREAD (ptid), GET_LWP (lwp));
1026 xsnprintf (buf, sizeof (buf), "Thread %ld ", GET_THREAD (ptid));
1028 else if (GET_LWP (ptid) != 0)
1029 xsnprintf (buf, sizeof (buf), "LWP %ld ", GET_LWP (ptid));
1031 xsnprintf (buf, sizeof (buf), "process %d ", PIDGET (ptid));
1037 /* Worker bee for find_new_threads. Callback function that gets
1038 called once per user-level thread (i.e. not for LWP's). */
1041 sol_find_new_threads_callback (const td_thrhandle_t *th, void *ignored)
1047 retval = p_td_thr_get_info (th, &ti);
1048 if (retval != TD_OK)
1051 ptid = BUILD_THREAD (ti.ti_tid, PIDGET (inferior_ptid));
1052 if (!in_thread_list (ptid) || is_exited (ptid))
1059 sol_find_new_threads (struct target_ops *ops)
1061 struct target_ops *beneath = find_target_beneath (ops);
1063 /* First Find any new LWP's. */
1064 if (beneath->to_find_new_threads != NULL)
1065 beneath->to_find_new_threads (beneath);
1067 /* Then find any new user-level threads. */
1068 p_td_ta_thr_iter (main_ta, sol_find_new_threads_callback, (void *) 0,
1069 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1070 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1073 /* Worker bee for the "info sol-thread" command. This is a callback
1074 function that gets called once for each Solaris user-level thread
1075 (i.e. not for LWPs) in the inferior. Print anything interesting
1076 that we can think of. */
1079 info_cb (const td_thrhandle_t *th, void *s)
1084 ret = p_td_thr_get_info (th, &ti);
1087 printf_filtered ("%s thread #%d, lwp %d, ",
1088 ti.ti_type == TD_THR_SYSTEM ? "system" : "user ",
1089 ti.ti_tid, ti.ti_lid);
1090 switch (ti.ti_state)
1093 case TD_THR_UNKNOWN:
1094 printf_filtered ("<unknown state>");
1096 case TD_THR_STOPPED:
1097 printf_filtered ("(stopped)");
1100 printf_filtered ("(run) ");
1103 printf_filtered ("(active) ");
1106 printf_filtered ("(zombie) ");
1109 printf_filtered ("(asleep) ");
1111 case TD_THR_STOPPED_ASLEEP:
1112 printf_filtered ("(stopped asleep)");
1115 /* Print thr_create start function. */
1116 if (ti.ti_startfunc != 0)
1118 struct minimal_symbol *msym;
1119 msym = lookup_minimal_symbol_by_pc (ti.ti_startfunc);
1121 printf_filtered (" startfunc: %s\n",
1122 SYMBOL_PRINT_NAME (msym));
1124 printf_filtered (" startfunc: %s\n",
1125 paddress (target_gdbarch (), ti.ti_startfunc));
1128 /* If thread is asleep, print function that went to sleep. */
1129 if (ti.ti_state == TD_THR_SLEEP)
1131 struct minimal_symbol *msym;
1132 msym = lookup_minimal_symbol_by_pc (ti.ti_pc);
1134 printf_filtered (" - Sleep func: %s\n",
1135 SYMBOL_PRINT_NAME (msym));
1137 printf_filtered (" - Sleep func: %s\n",
1138 paddress (target_gdbarch (), ti.ti_startfunc));
1141 /* Wrap up line, if necessary. */
1142 if (ti.ti_state != TD_THR_SLEEP && ti.ti_startfunc == 0)
1143 printf_filtered ("\n"); /* don't you hate counting newlines? */
1146 warning (_("info sol-thread: failed to get info for thread."));
1151 /* List some state about each Solaris user-level thread in the
1155 info_solthreads (char *args, int from_tty)
1157 p_td_ta_thr_iter (main_ta, info_cb, args,
1158 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1159 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1162 /* Callback routine used to find a thread based on the TID part of
1166 thread_db_find_thread_from_tid (struct thread_info *thread, void *data)
1168 long *tid = (long *) data;
1170 if (ptid_get_tid (thread->ptid) == *tid)
1177 sol_get_ada_task_ptid (long lwp, long thread)
1179 struct thread_info *thread_info =
1180 iterate_over_threads (thread_db_find_thread_from_tid, &thread);
1182 if (thread_info == NULL)
1184 /* The list of threads is probably not up to date. Find any
1185 thread that is missing from the list, and try again. */
1186 sol_find_new_threads (¤t_target);
1187 thread_info = iterate_over_threads (thread_db_find_thread_from_tid,
1191 gdb_assert (thread_info != NULL);
1193 return (thread_info->ptid);
1197 init_sol_thread_ops (void)
1199 sol_thread_ops.to_shortname = "solaris-threads";
1200 sol_thread_ops.to_longname = "Solaris threads and pthread.";
1201 sol_thread_ops.to_doc = "Solaris threads and pthread support.";
1202 sol_thread_ops.to_detach = sol_thread_detach;
1203 sol_thread_ops.to_resume = sol_thread_resume;
1204 sol_thread_ops.to_wait = sol_thread_wait;
1205 sol_thread_ops.to_fetch_registers = sol_thread_fetch_registers;
1206 sol_thread_ops.to_store_registers = sol_thread_store_registers;
1207 sol_thread_ops.to_xfer_partial = sol_thread_xfer_partial;
1208 sol_thread_ops.to_mourn_inferior = sol_thread_mourn_inferior;
1209 sol_thread_ops.to_thread_alive = sol_thread_alive;
1210 sol_thread_ops.to_pid_to_str = solaris_pid_to_str;
1211 sol_thread_ops.to_find_new_threads = sol_find_new_threads;
1212 sol_thread_ops.to_stratum = thread_stratum;
1213 sol_thread_ops.to_get_ada_task_ptid = sol_get_ada_task_ptid;
1214 sol_thread_ops.to_magic = OPS_MAGIC;
1217 /* Silence -Wmissing-prototypes. */
1218 extern void _initialize_sol_thread (void);
1221 _initialize_sol_thread (void)
1225 init_sol_thread_ops ();
1227 dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
1231 #define resolve(X) \
1232 if (!(p_##X = dlsym (dlhandle, #X))) \
1236 resolve (td_ta_new);
1237 resolve (td_ta_delete);
1239 resolve (td_ta_get_ph);
1240 resolve (td_ta_get_nthreads);
1241 resolve (td_ta_tsd_iter);
1242 resolve (td_ta_thr_iter);
1243 resolve (td_thr_validate);
1244 resolve (td_thr_tsd);
1245 resolve (td_thr_get_info);
1246 resolve (td_thr_getfpregs);
1247 resolve (td_thr_getxregsize);
1248 resolve (td_thr_getxregs);
1249 resolve (td_thr_sigsetmask);
1250 resolve (td_thr_setprio);
1251 resolve (td_thr_setsigpending);
1252 resolve (td_thr_setfpregs);
1253 resolve (td_thr_setxregs);
1254 resolve (td_ta_map_id2thr);
1255 resolve (td_ta_map_lwp2thr);
1256 resolve (td_thr_getgregs);
1257 resolve (td_thr_setgregs);
1259 add_target (&sol_thread_ops);
1261 add_cmd ("sol-threads", class_maintenance, info_solthreads,
1262 _("Show info on Solaris user threads."), &maintenanceinfolist);
1264 /* Hook into new_objfile notification. */
1265 observer_attach_new_objfile (sol_thread_new_objfile);
1269 fprintf_unfiltered (gdb_stderr, "\
1270 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());