3 Copyright 2001, 2002 Red Hat, Inc.
5 This file is part of RDA, the Red Hat Debug Agent (and library).
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.
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, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
22 Alternative licenses for RDA may be arranged by contacting Red Hat,
30 #include <thread_db.h>
36 #include "gdbserv-target.h"
38 #include "gdb_proc_service.h"
39 #include "gdbserv-thread-db.h"
41 /* Make lots of noise (debugging output). */
42 int thread_db_noisy = 0;
43 int proc_service_noisy = 0;
46 * A tiny local symbol table.
48 * This is used by ps_pglobal_lookup, and is really just a
49 * local cache of symbols whose values we have obtained from gdb.
51 * Since the cache is expected to be small, and infrequently used,
52 * there is no effort to sort or hash it. Symbols may be added
53 * in an "undefined" state, and then defined later.
56 /* The "defined_p" field may have one of the following three values. */
57 enum symbol_cache_defined { UNDEFINED, REQUESTED, DEFINED };
62 enum symbol_cache_defined defined_p;
63 struct symbol_cache *next;
66 /* Function: add_symbol_to_list
67 Add a symbol to the symbol cache. First checks to see if
68 an entry is already in there, and re-uses it if so. This way
69 the cache may be used for symbols awaiting lookup as well as
70 for those that have already been defined by the debugger. */
73 add_symbol_to_list (const char *name, paddr_t value, int defined_p)
75 struct symbol_cache *tmp;
77 for (tmp = symbol_list; tmp; tmp = tmp->next)
79 if (strcmp (name, tmp->name) == 0)
81 /* Symbol is already in cache -- set its value and definedness. */
83 if (defined_p == DEFINED)
84 tmp->defined_p = defined_p;
89 /* Symbol is not in cache -- add it. */
90 tmp = malloc (sizeof (struct symbol_cache));
93 tmp->defined_p = defined_p;
94 tmp->name = malloc (strlen (name) + 1);
95 strcpy (tmp->name, name);
97 tmp->next = symbol_list;
101 /* Function: free_symbol_list
102 Empty the symbol cache. */
105 free_symbol_list (void)
107 struct symbol_cache *tmp;
109 for (tmp = symbol_list; tmp; tmp = symbol_list)
111 symbol_list = tmp->next;
117 /* Function: sync_symbol_list
118 Return all "requested" symbols to the "undefined" state
119 (so they can be "requested" again). Called when a new
120 source of symbols becomes available (eg. a new shared object). */
123 sync_symbol_list (void)
125 struct symbol_cache *tmp;
127 for (tmp = symbol_list; tmp; tmp = tmp->next)
128 if (tmp->defined_p == REQUESTED)
129 tmp->defined_p = UNDEFINED;
132 /* Function: lookup_cached_symbol
133 If symbol is defined and cached, return its value in VALUE.
134 Return: 0 if not found, 1 if found. */
137 lookup_cached_symbol (char *name, paddr_t *value)
139 struct symbol_cache *tmp;
141 for (tmp = symbol_list; tmp; tmp = tmp->next)
142 if (strcmp (name, tmp->name) == 0 && tmp->defined_p == DEFINED)
144 *value = tmp->value; /* known and defined */
148 return 0; /* not found */
151 /* Function: next_undefined_symbol
152 Find a symbol in the cache that needs lookup by GDB.
153 On returning a symbol, mark it REQUESTED, so that it won't
154 be requested again until a new source of symbols opens up
155 (eg. a new shared object). */
158 next_undefined_symbol (void)
160 struct symbol_cache *tmp;
161 /* Make a pass thru the list, and return the first symbol that
162 hasn't been either requested or defined. */
163 for (tmp = symbol_list; tmp; tmp = tmp->next)
164 if (tmp->defined_p == UNDEFINED)
166 tmp->defined_p = REQUESTED;
173 * A tiny local thread list.
175 * This local list of threads is used for gdbserv operations that
176 * require a struct gdbserv_thread. Its first use will be to
177 * implement "info threads" for gdb.
180 /* Define the struct gdbserv_thread object. */
182 struct gdbserv_thread {
188 struct gdbserv_thread *next;
191 /* Function: add_thread_to_list
192 Add a thread (provided by libthread_db) to the local list. */
194 static struct gdbserv_thread *
195 add_thread_to_list (td_thrinfo_t *ti)
197 struct gdbserv_thread *new = malloc (sizeof (struct gdbserv_thread));
199 /* First cut -- add to start of list. */
200 memcpy (&new->ti, ti, sizeof (td_thrinfo_t));
201 new->next = thread_list;
206 static struct gdbserv_thread *
207 first_thread_in_list (void)
212 static struct gdbserv_thread *
213 next_thread_in_list (struct gdbserv_thread *thread)
222 delete_thread_from_list (struct gdbserv_thread *thread)
224 struct gdbserv_thread *tmp;
226 for (tmp = thread_list; tmp; tmp = tmp->next)
228 if (tmp->next == thread)
230 tmp->next = tmp->next->next; /* unlink */
231 free (thread); /* discard */
232 return; /* finished */
235 /* Special case -- delete first element of list. */
236 if (thread == thread_list)
238 thread_list = thread->next; /* unlink */
239 free (thread); /* discard */
240 return; /* finished */
242 /* If we reach this point, the thread wasn't in the list. */
246 free_thread_list (void)
248 struct gdbserv_thread *tmp;
250 for (tmp = thread_list; tmp; tmp = thread_list)
252 thread_list = tmp->next;
257 static struct gdbserv_thread *
258 thread_list_lookup_by_tid (thread_t tid)
260 struct gdbserv_thread *tmp;
262 for (tmp = thread_list; tmp; tmp = tmp->next)
263 if (tmp->ti.ti_tid == tid)
269 static struct gdbserv_thread *
270 thread_list_lookup_by_lid (lwpid_t pid)
272 struct gdbserv_thread *tmp;
274 for (tmp = thread_list; tmp; tmp = tmp->next)
275 if (tmp->ti.ti_lid == pid)
281 /* A copy of the next lower layer's target vector, before we modify it. */
282 static struct gdbserv_target parentvec;
284 /* A pointer to the current target vector. */
285 static struct gdbserv_target *currentvec;
288 * proc_service callback functions, called by thread_db.
292 ps_plog (const char *fmt, ...)
294 fprintf (stderr, "<ps_plog: %s>\n", fmt);
298 /* Look up a symbol in GDB's global symbol table.
299 Return the symbol's address.
300 FIXME: it would be more correct to look up the symbol in the context
301 of the LD_OBJECT_NAME provided. However we're probably fairly safe
302 as long as there aren't name conflicts with other libraries. */
305 ps_pglobal_lookup (gdb_ps_prochandle_t ph,
306 const char *ld_object_name, /* the library name */
307 const char *ld_symbol_name, /* the symbol name */
308 paddr_t *ld_symbol_addr) /* return the symbol addr */
312 if (lookup_cached_symbol ((char *) ld_symbol_name, &value) == 0)
314 /* Symbol not in cache -- ask GDB to look it up.
315 Add the symbol to the cache as undefined. */
316 add_symbol_to_list ((char *) ld_symbol_name, 0, UNDEFINED);
321 /* Symbol is in the cache and defined -- return its value. */
322 *ld_symbol_addr = value;
328 /* Connection to the libthread_db library. */
329 static struct ps_prochandle proc_handle;
330 static td_thragent_t *thread_agent = NULL;
332 /* Pointers to the libthread_db functions. */
333 static td_err_e (*td_init_p) (void);
335 static td_err_e (*td_ta_new_p) (struct ps_prochandle *ps,
337 static td_err_e (*td_ta_delete_p) (td_thragent_t *ta);
338 static td_err_e (*td_ta_map_id2thr_p) (const td_thragent_t *ta,
340 td_thrhandle_t *__th);
341 static td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta,
344 static td_err_e (*td_ta_thr_iter_p) (const td_thragent_t *ta,
345 td_thr_iter_f *callback,
347 td_thr_state_e state,
349 sigset_t *ti_sigmask,
350 unsigned int ti_user_flags);
351 static td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta,
354 static td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta,
355 td_thr_events_t *event);
356 static td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta,
357 td_event_msg_t *msg);
358 static td_err_e (*td_thr_validate_p) (const td_thrhandle_t *th);
359 static td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th,
360 td_thrinfo_t *infop);
361 static td_err_e (*td_thr_getfpregs_p) (const td_thrhandle_t *th,
363 static td_err_e (*td_thr_getgregs_p) (const td_thrhandle_t *th,
365 static td_err_e (*td_thr_setfpregs_p) (const td_thrhandle_t *th,
366 const FPREGSET_T *fpregs);
367 static td_err_e (*td_thr_setgregs_p) (const td_thrhandle_t *th,
369 static td_err_e (*td_thr_getxregsize_p) (const td_thrhandle_t *th,
371 static td_err_e (*td_thr_getxregs_p) (const td_thrhandle_t *th,
373 static td_err_e (*td_thr_setxregs_p) (const td_thrhandle_t *th,
375 static td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th,
377 static const char **(*td_symbol_list_p) (void);
378 static td_err_e (*td_thr_tls_get_addr_p) (const td_thrhandle_t *th,
380 size_t offset, void **address);
383 /* Function: thread_db_state_str
384 Convert a thread_db state code to a string.
385 If state code is unknown, return an <unknown> message. */
388 thread_db_state_str (td_thr_state_e statecode)
393 case TD_THR_ANY_STATE: return "<any state>";
394 case TD_THR_UNKNOWN: return "<officially unknown>";
395 case TD_THR_STOPPED: return "<stopped>";
396 case TD_THR_RUN: return "<running>";
397 case TD_THR_ACTIVE: return "<active> ";
398 case TD_THR_ZOMBIE: return "<zombie> ";
399 case TD_THR_SLEEP: return "<sleep> ";
400 case TD_THR_STOPPED_ASLEEP: return "<stopped asleep>";
402 sprintf (buf, "<unknown state code %d>", statecode);
408 thread_db_type_str (td_thr_type_e type)
411 case TD_THR_USER: return "<user> ";
412 case TD_THR_SYSTEM: return "<system>";
413 default: return "<unknown>";
417 /* Function: thread_db_err_string
418 Convert a thread_db error code to a string.
419 If errcode is unknown, then return an <unknown> message. */
422 thread_db_err_str (td_err_e errcode)
427 case TD_OK: return "generic 'call succeeded'";
428 case TD_ERR: return "generic error";
429 case TD_NOTHR: return "no thread to satisfy query";
430 case TD_NOSV: return "no sync handle to satisfy query";
431 case TD_NOLWP: return "no lwp to satisfy query";
432 case TD_BADPH: return "invalid process handle";
433 case TD_BADTH: return "invalid thread handle";
434 case TD_BADSH: return "invalid synchronization handle";
435 case TD_BADTA: return "invalid thread agent";
436 case TD_BADKEY: return "invalid key";
437 case TD_NOMSG: return "no event message for getmsg";
438 case TD_NOFPREGS: return "FPU register set not available";
439 case TD_NOLIBTHREAD: return "application not linked with libthread";
440 case TD_NOEVENT: return "requested event is not supported";
441 case TD_NOCAPAB: return "capability not available";
442 case TD_DBERR: return "debugger service failed";
443 case TD_NOAPLIC: return "operation not applicable to";
444 case TD_NOTSD: return "no thread-specific data for this thread";
445 case TD_MALLOC: return "malloc failed";
446 case TD_PARTIALREG: return "only part of register set was written/read";
447 case TD_NOXREGS: return "X register set not available for this thread";
449 sprintf (buf, "unknown thread_db error '%d'", errcode);
454 /* flag which indicates if the map_id2thr cache is valid. See below. */
455 static int thread_db_map_id2thr_cache_valid;
457 /* Function: thread_db_map_id2thr
458 Calling td_ta_map_id2thr() is expensive. This function invokes
459 td_ta_map_id2thr() and caches the value for future reference. The
460 cache may be invalidated by calling thread_db_invalidate_cache().
461 Returns: TD_OK on success, an appropriate error code otherwise. */
464 thread_db_map_id2thr (const td_thragent_t *ta, thread_t pt,
467 static td_thrhandle_t cached_handle;
468 static thread_t input_pt;
470 if (pt == input_pt && thread_db_map_id2thr_cache_valid)
479 status = td_ta_map_id2thr_p (ta, pt, th);
482 thread_db_map_id2thr_cache_valid = 1;
487 thread_db_map_id2thr_cache_valid = 0;
492 /* Invalidate the map_id2thr cache. */
494 thread_db_invalidate_map_id2thr_cache (void)
496 thread_db_map_id2thr_cache_valid = 0;
499 /* The regset cache object. This object keeps track of the most
500 recently fetched or set gregset (of a particular type) and whether
501 or not it needs to still needs to be synchronized with the target. */
504 /* Are the cache contents valid? */
507 /* Does cache need to be flushed? */
510 /* Handle corresponding to cached regset. */
511 td_thrhandle_t handle;
513 /* Size of memory area used to hold regset. */
516 /* Memory area used to hold regset. */
519 /* Functions used to get/set regset. */
520 td_err_e (*getregset) (const td_thrhandle_t *th, void *regset);
521 td_err_e (*setregset) (const td_thrhandle_t *th, const void *regset);
524 /* Declare fpregset and gregset cache objects. */
525 static struct regset_cache fpregset_cache;
526 static struct regset_cache gregset_cache;
528 /* Wrappers for td_thr_getfpregs_p, td_thr_setfpregs_p, td_thr_getgregs_p,
529 and td_thr_setgregs_p. These simply allow us to pass a void * for the
533 td_thr_getfpregs_wrapper (const td_thrhandle_t *th, void *fpregs)
535 return td_thr_getfpregs_p (th, fpregs);
538 static td_err_e td_thr_getgregs_wrapper (const td_thrhandle_t *th, void *gregs)
540 return td_thr_getgregs_p (th, gregs);
543 static td_err_e td_thr_setfpregs_wrapper (const td_thrhandle_t *th,
546 return td_thr_setfpregs_p (th, fpregs);
549 static td_err_e td_thr_setgregs_wrapper (const td_thrhandle_t *th,
552 void * gregs_nonconst = (void *) gregs;
554 return td_thr_setgregs_p (th, gregs_nonconst);
557 /* Initialize a regset cache object. */
559 initialize_regset_cache (struct regset_cache *regset_cache,
560 const int regset_size,
561 void * const regset_buffer,
562 td_err_e (* const getregset) (const td_thrhandle_t *th,
564 td_err_e (* const setregset) (const td_thrhandle_t *th,
567 regset_cache->valid = 0;
568 regset_cache->needs_flush = 0;
569 regset_cache->regset_size = regset_size;
570 regset_cache->regset_buffer = regset_buffer;
571 regset_cache->getregset = getregset;
572 regset_cache->setregset = setregset;
575 /* Initialize the fpregset and gregset cache objects. Space for
576 the regset buffer is statically allocated to avoid calls to malloc(). */
578 initialize_regset_caches (void)
580 static FPREGSET_T fpregset;
581 static GREGSET_T gregset;
583 initialize_regset_cache (&fpregset_cache, sizeof fpregset, &fpregset,
584 td_thr_getfpregs_wrapper, td_thr_setfpregs_wrapper);
585 initialize_regset_cache (&gregset_cache, sizeof gregset, gregset,
586 td_thr_getgregs_wrapper, td_thr_setgregs_wrapper);
589 /* Synchronize a cached regset with the target. */
591 thread_db_flush_regset_cache (struct regset_cache *regset_cache)
593 td_err_e status = TD_OK;
594 if (regset_cache->valid && regset_cache->needs_flush)
596 status = regset_cache->setregset (®set_cache->handle,
597 regset_cache->regset_buffer);
599 regset_cache->valid = 0;
600 regset_cache->needs_flush = 0;
605 /* Synchronize the gregset and fpregset caches with the target. */
607 thread_db_flush_regset_caches (void)
610 td_err_e ret_status = TD_OK;
612 status = thread_db_flush_regset_cache (&fpregset_cache);
616 status = thread_db_flush_regset_cache (&gregset_cache);
623 /* Fetch a regset, using a previously cached copy if possible. */
625 thread_db_get_regset (struct regset_cache *regset_cache,
626 const td_thrhandle_t *th,
629 if (regset_cache->valid
630 && memcmp (®set_cache->handle, th, sizeof *th) == 0)
632 /* Cache is valid and handles match. Copy the cached regset. */
633 memcpy (regset, regset_cache->regset_buffer, regset_cache->regset_size);
640 /* Handles don't match. Write out old cache contents before
641 fetching contents w/ new handle if necessary. */
642 if (regset_cache->valid && regset_cache->needs_flush)
644 status = regset_cache->setregset (®set_cache->handle,
645 regset_cache->regset_buffer);
648 regset_cache->needs_flush = 0;
649 regset_cache->valid = 0;
655 /* Fetch the regset. */
656 status = regset_cache->getregset (th, regset);
659 /* Preserve it in the cache. */
660 regset_cache->needs_flush = 0;
661 regset_cache->valid = 1;
662 memcpy (®set_cache->handle, th, sizeof (*th));
663 memcpy (regset_cache->regset_buffer, regset,
664 regset_cache->regset_size);
667 regset_cache->valid = 0;
672 /* Set a regset deferring synchronization with the target until
675 thread_db_set_regset (struct regset_cache *regset_cache,
676 const td_thrhandle_t *th,
679 td_err_e ret_status = TD_OK;
681 if (regset_cache->valid && regset_cache->needs_flush
682 && memcmp (®set_cache->handle, th, sizeof *th) != 0)
684 /* Cached regset needs to be flushed because handles don't
686 ret_status = thread_db_flush_regset_cache (regset_cache);
689 memcpy (®set_cache->handle, th, sizeof *th);
690 memcpy (regset_cache->regset_buffer, regset, regset_cache->regset_size);
691 regset_cache->valid = 1;
692 regset_cache->needs_flush = 1;
697 /* Mark a regset cache as invalid. */
699 thread_db_invalidate_regset_cache (struct regset_cache *regset_cache)
701 regset_cache->valid = 0;
704 /* Mark the gregset and fpregset caches as invalid. */
706 thread_db_invalidate_regset_caches (void)
708 thread_db_invalidate_regset_cache (&fpregset_cache);
709 thread_db_invalidate_regset_cache (&gregset_cache);
712 /* Invalidate all caches. */
714 thread_db_invalidate_caches (void)
716 thread_db_invalidate_regset_caches ();
717 thread_db_invalidate_map_id2thr_cache ();
720 /* Fetch the floating point registers via the fpregset cache. */
722 thread_db_getfpregs (const td_thrhandle_t *th, FPREGSET_T *fpregset)
724 return thread_db_get_regset (&fpregset_cache, th, fpregset);
727 /* Set the floating point registers via the fpregset cache. */
729 thread_db_setfpregs (const td_thrhandle_t *th, const FPREGSET_T *fpregset)
731 return thread_db_set_regset (&fpregset_cache, th, fpregset);
734 /* Fetch the general purpose registers via the gregset cache. */
736 thread_db_getgregs (const td_thrhandle_t *th, GREGSET_T gregset)
738 return thread_db_get_regset (&gregset_cache, th, gregset);
741 /* Set the general purpose registers via the gregset cache. */
743 thread_db_setgregs (const td_thrhandle_t *th, const GREGSET_T gregset)
745 return thread_db_set_regset (&gregset_cache, th, gregset);
748 /* Call dlsym() to find the address of a symbol. If symbol lookup fails,
749 print the reason to stderr. */
752 lookup_sym (void *dlhandle, char *symbol)
756 addr = dlsym (dlhandle, symbol);
759 fprintf (stderr, "Symbol lookup of %s failed: %s\n",
765 /* Function: thread_db_dlopen
766 Attach to the libthread_db library.
767 This function does all the dynamic library stuff (dlopen, dlsym).
768 Return: -1 for failure, zero for success. */
771 thread_db_dlopen (void)
775 #ifndef LIBTHREAD_DB_SO
776 #define LIBTHREAD_DB_SO "libthread_db.so.1"
779 if ((dlhandle = dlopen (LIBTHREAD_DB_SO, RTLD_NOW)) == NULL)
781 fprintf (stderr, "Unable to open %s: %s\n",
782 LIBTHREAD_DB_SO, dlerror ());
783 return -1; /* fail */
786 /* Initialize pointers to the dynamic library functions we will use.
789 if ((td_init_p = lookup_sym (dlhandle, "td_init")) == NULL)
790 return -1; /* fail */
792 if ((td_ta_new_p = lookup_sym (dlhandle, "td_ta_new")) == NULL)
793 return -1; /* fail */
795 if ((td_ta_delete_p = lookup_sym (dlhandle, "td_ta_delete")) == NULL)
796 return -1; /* fail */
798 if ((td_ta_map_id2thr_p = lookup_sym (dlhandle, "td_ta_map_id2thr")) == NULL)
799 return -1; /* fail */
801 if ((td_ta_map_lwp2thr_p = lookup_sym (dlhandle, "td_ta_map_lwp2thr")) == NULL)
802 return -1; /* fail */
804 if ((td_ta_thr_iter_p = lookup_sym (dlhandle, "td_ta_thr_iter")) == NULL)
805 return -1; /* fail */
807 if ((td_thr_validate_p = lookup_sym (dlhandle, "td_thr_validate")) == NULL)
808 return -1; /* fail */
810 if ((td_thr_get_info_p = lookup_sym (dlhandle, "td_thr_get_info")) == NULL)
811 return -1; /* fail */
813 if ((td_thr_getfpregs_p = lookup_sym (dlhandle, "td_thr_getfpregs")) == NULL)
814 return -1; /* fail */
816 if ((td_thr_getgregs_p = lookup_sym (dlhandle, "td_thr_getgregs")) == NULL)
817 return -1; /* fail */
819 if ((td_thr_setfpregs_p = lookup_sym (dlhandle, "td_thr_setfpregs")) == NULL)
820 return -1; /* fail */
822 if ((td_thr_setgregs_p = lookup_sym (dlhandle, "td_thr_setgregs")) == NULL)
823 return -1; /* fail */
825 /* These are not essential. */
826 td_ta_event_addr_p = dlsym (dlhandle, "td_ta_event_addr");
827 td_ta_set_event_p = dlsym (dlhandle, "td_ta_set_event");
828 td_ta_event_getmsg_p = dlsym (dlhandle, "td_ta_event_getmsg");
829 td_thr_event_enable_p = dlsym (dlhandle, "td_thr_event_enable");
830 td_thr_getxregsize_p = dlsym (dlhandle, "td_thr_getxregsize");
831 td_thr_getxregs_p = dlsym (dlhandle, "td_thr_getxregs");
832 td_thr_setxregs_p = dlsym (dlhandle, "td_thr_setxregs");
833 td_symbol_list_p = dlsym (dlhandle, "td_symbol_list");
834 td_thr_tls_get_addr_p = dlsym (dlhandle, "td_thr_tls_get_addr");
836 return 0; /* success */
839 /* Function: thread_db_open
840 Open a channel to the child's thread library.
841 Returns: -1 for success, 0 for failure
843 FIXME: where should we be called from? We will not succeed
844 until the thread shlib is loaded. The call from attach will not
845 succeed even if the target is statically linked, 'cause there's
846 no symbol lookup handshake on attach. Therefore I can't handle
847 a statically linked threaded process. */
850 thread_db_open (struct gdbserv *serv, int pid)
851 { /* FIXME: once we have the serv, we can derive the pid.
852 No, not true -- not when we're called from attach.
853 But then, there isn't much use in the call from attach unles
854 I make GDB respond to symbol callbacks from there somehow. */
857 if (thread_agent == NULL)
859 proc_handle.pid = pid;
860 proc_handle.serv = serv;
862 ret = td_ta_new_p (&proc_handle, &thread_agent);
865 return -1; /* success */
867 else if (thread_db_noisy)
869 fprintf (stderr, "< -- failed, thread_agent = 0x%08x>\n",
870 (long) thread_agent);
872 return 0; /* failure */
874 return -1; /* success */
877 /* Function: thread_db_detach
878 FIXME: gdbserv kills the inferior and exits when gdb detaches.
879 This is the best place I have from which to shut down the
880 thread_db interface, but it's not really where this should
884 thread_db_detach (struct gdbserv *serv, struct gdbserv_target *target)
886 struct child_process *process = gdbserv_target_data (serv);
888 /* FIXME: this isn't really enough, and detach isn't really the
889 right place for this anyway. Do this in exit_program. */
890 td_ta_delete_p (thread_agent);
894 if (process->debug_informational)
895 fprintf (stderr, "<thread_db_detach>\n");
896 if (parentvec.detach)
897 parentvec.detach (serv, target);
901 attach_thread (struct gdbserv_thread *thread)
903 if (thread->ti.ti_lid != 0 &&
904 thread->ti.ti_state != TD_THR_ZOMBIE) /* Don't attach a zombie. */
906 if (attach_lwp (thread->ti.ti_lid) == 0)
907 thread->attached = 1;
909 thread->attached = 0;
913 /* Function: find_new_threads_callback
914 Enter threads into a local thread database. */
917 find_new_threads_callback (const td_thrhandle_t *thandle, void *data)
919 struct gdbserv_thread *thread;
923 if ((ret = td_thr_get_info_p (thandle, &ti)) != TD_OK)
925 fprintf (stderr, "<find_new_threads_callback: get_info failed! %s>\n",
926 thread_db_err_str (ret));
930 /* Enter the thread into a local list
931 (unless it is TD_THR_UNKNOWN, which means its defunct). */
932 if ((thread = thread_list_lookup_by_tid (ti.ti_tid)) == NULL)
934 if (ti.ti_state != TD_THR_UNKNOWN)
936 thread = add_thread_to_list (&ti);
937 /* Now make sure we've attached to it.
938 Skip the main pid (already attached). */
939 if (thread->ti.ti_lid != proc_handle.pid)
941 attach_thread (thread);
947 /* Already in list -- cache new thread info */
948 memcpy (&thread->ti, &ti, sizeof (ti));
954 /* Function: update_thread_list
956 First run td_ta_thr_iter to find all threads.
957 Then walk the list and validate that each thread is still running.
958 If not, prune it from the list. */
961 update_thread_list (void)
963 struct gdbserv_thread *thread, *next;
964 td_thrhandle_t handle;
966 /* First make sure all libthread threads are in the list. */
967 td_ta_thr_iter_p (thread_agent, find_new_threads_callback,
970 TD_THR_LOWEST_PRIORITY,
972 TD_THR_ANY_USER_FLAGS);
974 /* Next, remove any defunct threads from the list. */
975 for (thread = first_thread_in_list ();
979 /* Thread may be deleted, so find its successor first! */
980 next = next_thread_in_list (thread);
982 /* Now ask if thread is still valid, and if not, delete it. */
983 if (thread_db_map_id2thr (thread_agent,
986 || td_thr_validate_p (&handle) != TD_OK)
988 if (thread->ti.ti_state == TD_THR_UNKNOWN)
990 /* Thread is no longer "valid".
991 By the time this happens, it's too late for us to
992 detach from it. Just delete it from the list. */
994 delete_thread_from_list (thread);
1000 /* Function: thread_db_thread_next
1001 Exported to gdbserv to implement "info threads" request from GDB. */
1003 static struct gdbserv_thread *
1004 thread_db_thread_next (struct gdbserv *serv, struct gdbserv_thread *thread)
1008 /* First request -- build up thread list using td_ta_thr_iter. */
1009 /* NOTE: this should be unnecessary, once we begin to keep the
1010 list up to date all the time. */
1011 update_thread_list ();
1013 return next_thread_in_list (thread);
1017 /* Function: thread_db_get_gen
1018 Handle 'q' requests:
1019 qSymbol and qGetTLSAddr
1023 thread_db_get_gen (struct gdbserv *serv)
1025 struct child_process *process = gdbserv_target_data (serv);
1026 char tempname[1024], *symbol_query;
1027 unsigned long tempval;
1030 if (gdbserv_input_string_match (serv, "Symbol:") >= 0)
1032 /* Message: qSymbol:<optional value>:<optional name hexified>
1034 Reply: qSymbol:<name hexified>
1036 This message from GDB has three possible forms:
1038 1) "qSymbol::" (no value, no name).
1039 This means the start of a symbol query session.
1040 GDB is offering to serve up symbols.
1041 The target should reply with the FIRST symbol whose value
1042 it wants (or "OK" if it doesn't want any).
1044 2) "qSymbol:<value>:<name hexified>
1045 This means "here is the value of the symbol you requested".
1046 The target should reply with the NEXT symbol whose value
1047 it wants (or "OK" if it doesn't want any more).
1049 3) "qSymbol::<name hexified>" (no value)
1050 This means "I have no value for the symbol you requested".
1051 The target should reply with the NEXT symbol whose value
1052 it wants (or "OK" if it doesn't want any more).
1055 if (gdbserv_input_string_match (serv, ":") >= 0)
1057 /* So far we've matched "qSymbol::". We're looking at either
1058 form #1 ("qSymbol::", open a symbol lookup session), or
1059 form #3 ("qSymbol::<name>", a reply that "this symbol is
1062 len = gdbserv_input_bytes (serv, tempname, sizeof (tempname));
1066 /* Form #1, open a new symbol lookup session.
1067 Prepare to request the first symbol in the list. */
1068 sync_symbol_list ();
1072 /* Form #3, this symbol not currently defined. Nothing
1073 to do, since we marked it REQUESTED when we sent it,
1074 and lookup_cached_symbol treats REQUESTED like
1078 else if (gdbserv_input_hex_ulong (serv, &tempval) >= 0 &&
1079 gdbserv_input_string_match (serv, ":") >= 0 &&
1080 (len = gdbserv_input_bytes (serv, tempname, sizeof (tempname)))
1083 /* Message contains a symbol and a value (form #2). */
1085 tempname[len] = '\0';
1086 add_symbol_to_list (tempname, (paddr_t) tempval, DEFINED);
1087 if (thread_agent != NULL)
1089 /* We now have a new symbol in the cache, which was
1090 requested by the last td_ta_new call. Delete the
1091 current (not-completely-valid) thread agent, so that
1092 a new one will have to be opened. */
1093 td_ta_delete_p (thread_agent);
1094 thread_agent = NULL;
1098 /* If we have no more symbols to look up, try opening a thread
1099 agent. It's possible that opening an agent could succeed
1100 before we have finished looking up all the symbols, but since
1101 we always loop until all the symbols we know about have been
1102 requested anyway, it's unnecessary.
1104 This ensures that ps_pglobal_lookup will always succeed in
1105 the case where we can obtain the full list of symbol names
1106 before opening the agent; this may be a little more robust
1107 than assuming it will handle all errors gracefully.
1109 Otherwise, if ps_pglobal_lookup fails, it will at least add
1110 the missing symbol's name to the list, and we'll request
1111 their values the next time around. */
1112 symbol_query = next_undefined_symbol ();
1115 thread_db_open (serv, process->pid);
1116 symbol_query = next_undefined_symbol ();
1119 /* Now the reply depends on whether there is another
1120 symbol in need of lookup. */
1123 gdbserv_output_string (serv, "OK");
1127 gdbserv_output_string (serv, "qSymbol:");
1128 gdbserv_output_bytes (serv, symbol_query, strlen (symbol_query));
1131 else if (gdbserv_input_string_match (serv, "GetTLSAddr:") >= 0)
1133 /* Message qGetTLSAddr:thread-id,offset,link-map-addr */
1134 unsigned long thread_id, offset, link_map_addr;
1136 if (thread_agent == NULL
1137 || td_thr_tls_get_addr_p == 0)
1139 /* Not supported by thread library. */
1140 gdbserv_output_string (serv, "E01");
1142 else if (gdbserv_input_hex_ulong (serv, &thread_id) >= 0
1143 && gdbserv_input_string_match (serv, ",") >= 0
1144 && gdbserv_input_hex_ulong (serv, &offset) >= 0
1145 && gdbserv_input_string_match (serv, ",") >= 0
1146 && gdbserv_input_hex_ulong (serv, &link_map_addr) >= 0)
1149 td_thrhandle_t thread_handle;
1150 ret = thread_db_map_id2thr (thread_agent,
1151 (thread_t) thread_id,
1158 ret = td_thr_tls_get_addr_p (&thread_handle,
1159 (void *) link_map_addr,
1164 struct gdbserv_reg addr_as_reg;
1166 gdbserv_ulonglong_to_reg (serv,
1167 (unsigned long long)
1168 (unsigned long) addr,
1170 gdbserv_output_reg_beb (serv, &addr_as_reg, 0);
1174 /* Can't find TLS address. */
1175 gdbserv_output_string (serv, "E04");
1180 /* Unable to find thread. */
1181 gdbserv_output_string (serv, "E03");
1186 /* Malformed qGetTLSAddr packet. */
1187 gdbserv_output_string (serv, "E02");
1190 else if (parentvec.process_get_gen)
1191 parentvec.process_get_gen (serv);
1194 /* Function: thread_db_set_gen
1195 Handle 'Q' requests:
1199 thread_db_set_gen (struct gdbserv *serv)
1201 if (parentvec.process_set_gen)
1202 parentvec.process_set_gen (serv);
1206 thread_db_thread_id (struct gdbserv *serv,
1207 struct gdbserv_thread *thread,
1208 struct gdbserv_reg *id)
1210 gdbserv_ulonglong_to_reg (serv,
1211 (unsigned long long) thread->ti.ti_tid,
1216 thread_db_thread_lookup_by_id (struct gdbserv *serv,
1217 const struct gdbserv_reg *thread_id,
1218 struct gdbserv_thread **thread)
1222 gdbserv_reg_to_ulong (serv, thread_id, &id);
1223 if (id == 0) /* any thread */
1225 *thread = next_thread_in_list (NULL); /* FIXME curthread? */
1230 *thread = thread_list_lookup_by_tid ((thread_t) id);
1231 if (*thread == NULL) /* bad thread id */
1233 *thread = next_thread_in_list (NULL); /* FIXME curthread? */
1238 return 1; /* success */
1244 thread_db_thread_info (struct gdbserv *serv, struct gdbserv_thread *thread)
1246 char *info = malloc (128);
1248 sprintf (info, "PID %d Type %s State %s",
1250 thread_db_type_str (thread->ti.ti_type),
1251 thread_db_state_str (thread->ti.ti_state));
1255 /* Function: get_target_int_by_name
1256 Read the value of a target integer, given its name and size.
1257 Returns -1 for failure, zero for success. */
1260 get_target_int_by_name (char *name, void *value, int size)
1264 if (ps_pglobal_lookup (&proc_handle, NULL, name, &addr) == PS_OK)
1266 if (ps_pdread (&proc_handle, addr,
1267 (gdb_ps_read_buf_t) value,
1268 (gdb_ps_size_t) size) == PS_OK)
1271 return -1; /* fail */
1274 /* Function: set_target_int_by_name
1275 Read the value of a target integer, given its name and size.
1276 Returns -1 for failure, zero for success. */
1279 set_target_int_by_name (char *name, void *value, int size)
1283 if (ps_pglobal_lookup (&proc_handle, NULL, name, &addr) == PS_OK)
1285 if (ps_pdwrite (&proc_handle, addr,
1286 (gdb_ps_write_buf_t) value,
1287 (gdb_ps_size_t) size) == PS_OK)
1290 return -1; /* fail */
1293 /* Function: get_thread_signals
1295 Obtain the values of the "cancel", "restart" and "debug" signals
1296 used by LinuxThreads, and store them in a set of global variables
1297 for use by check_child_state and friends.
1299 Recent versions of NPTL don't define these symbols at all; you must
1300 use the libthread_db event functions instead (td_ta_event_addr,
1301 ...) to find out about thread creation, thread exits, and so on.
1303 Older versions of LinuxThreads provide both interfaces. To avoid
1304 changing RDA's behavior on any system it supports, we use the older
1305 signal-based interface if present, and use the event-based
1306 interface as a fall-back. */
1308 static int cancel_signal;
1309 static int restart_signal;
1310 static int debug_signal;
1311 static int got_thread_signals;
1314 get_thread_signals (void)
1316 int cancel, restart, debug, debug_flag;
1318 if (!got_thread_signals)
1320 if (get_target_int_by_name ("__pthread_sig_cancel",
1321 &cancel, sizeof (cancel)) == 0 &&
1322 get_target_int_by_name ("__pthread_sig_restart",
1323 &restart, sizeof (restart)) == 0 &&
1324 get_target_int_by_name ("__pthread_sig_debug",
1325 &debug, sizeof (debug)) == 0)
1327 restart_signal = restart;
1328 cancel_signal = cancel;
1329 debug_signal = debug;
1330 got_thread_signals = 1;
1333 set_target_int_by_name ("__pthread_threads_debug",
1334 &debug_flag, sizeof (debug_flag));
1338 /* Function: stop_thread
1339 Use SIGSTOP to force a thread to stop. */
1342 stop_thread (struct gdbserv_thread *thread)
1344 if (thread->ti.ti_lid != 0)
1346 if (stop_lwp (thread->ti.ti_lid) == 0)
1347 thread->stopped = 1;
1349 thread->stopped = 0;
1353 /* Function: stop_all_threads
1354 Use SIGSTOP to make sure all child threads are stopped.
1355 Do not send SIGSTOP to the event thread, or to any
1356 new threads that have just been attached. */
1359 stop_all_threads (struct child_process *process)
1361 struct gdbserv_thread *thread;
1363 for (thread = first_thread_in_list ();
1365 thread = next_thread_in_list (thread))
1367 if (thread->ti.ti_lid == process->pid)
1369 /* HACK mark him signalled. */
1370 thread->stopped = 1;
1371 continue; /* This thread is already stopped. */
1373 /* All threads must be stopped, unles
1374 a) they have only just been attached, or
1375 b) they're already stopped. */
1376 if (!thread->attached && !thread->stopped &&
1377 thread->ti.ti_state != TD_THR_ZOMBIE &&
1378 thread->ti.ti_state != TD_THR_UNKNOWN)
1380 stop_thread (thread);
1385 /* A list of signals that have been prematurely sucked out of the threads.
1386 Because of the complexities of linux threads, we must send SIGSTOP to
1387 every thread, and then call waitpid on the thread to retrieve the
1388 SIGSTOP event. Sometimes another signal is pending on the thread,
1389 and we get that one by mistake. Throw all such signals into this
1390 list, and send them back to their respective threads once we're
1391 finished calling waitpid. */
1393 static struct event_list {
1394 struct gdbserv_thread *thread;
1398 static int pending_events_listsize;
1399 static int pending_events_top;
1401 /* Function: add_pending_event
1402 Helper function for wait_all_threads.
1404 When we call waitpid for each thread (trying to consume the SIGSTOP
1405 events that we sent from stop_all_threads), we sometimes inadvertantly
1406 get other events that we didn't send. We pend these to a list, and
1407 then resend them to the child threads after our own SIGSTOP events
1410 This list will be used to choose which of the possible events
1411 will be returned to the debugger by check_child_status. */
1414 add_pending_event (struct gdbserv_thread *thread, union wait waited)
1416 if (pending_events_top >= pending_events_listsize)
1418 pending_events_listsize += 64;
1420 realloc (pending_events,
1421 pending_events_listsize * sizeof (*pending_events));
1423 pending_events [pending_events_top].thread = thread;
1424 pending_events [pending_events_top].waited = waited;
1425 pending_events [pending_events_top].selected = 0;
1426 pending_events_top ++;
1429 /* Function: select_pending_event
1430 Helper function for wait_all_threads.
1432 Having collected a list of events from various threads,
1433 choose one "favored event" to be returned to the debugger. */
1437 select_pending_event (struct child_process *process)
1440 int num_wifstopped_events = 0;
1443 /* Select the event that will be returned to the debugger. */
1445 /* Selection criterion #0:
1446 If there are no events, don't do anything! (paranoia) */
1447 if (pending_events_top == 0)
1450 /* Selection criterion #1:
1451 If the thread pointer is null, then the thread library is
1452 not in play yet, so this is the only thread and the only event. */
1453 if (pending_events[0].thread == NULL)
1459 /* Selection criterion #2:
1460 Exit and terminate events take priority. */
1461 for (i = 0; i < pending_events_top; i++)
1462 if (WIFEXITED (pending_events[i].waited) ||
1463 WIFSIGNALED (pending_events[i].waited))
1468 /* Selection criterion #3:
1469 Give priority to a stepping SIGTRAP. */
1470 for (i = 0; i < pending_events_top; i++)
1471 if (pending_events[i].thread->stepping &&
1472 WIFSTOPPED (pending_events[i].waited) &&
1473 WSTOPSIG (pending_events[i].waited) == SIGTRAP)
1475 /* We don't actually know whether this sigtrap was the result
1476 of a singlestep, or of executing a trap instruction. But
1477 GDB has a better chance of figuring it out than we do. */
1481 /* Selection criterion #4:
1482 Count the WIFSTOPPED events and choose one at random. */
1483 for (i = 0; i < pending_events_top; i++)
1484 if (WIFSTOPPED (pending_events[i].waited))
1485 num_wifstopped_events ++;
1488 ((num_wifstopped_events * (double) rand ()) / (RAND_MAX + 1.0));
1490 for (i = pending_events_top - 1; i >= 0; i--)
1491 if (WIFSTOPPED (pending_events[i].waited))
1493 if (random_key == --num_wifstopped_events)
1497 else if (WSTOPSIG (pending_events[i].waited) == SIGINT)
1499 goto selected; /* Give preference to SIGINT. */
1503 /* Selection criterion #4 (should never get here):
1504 If all else fails, take the first event in the list. */
1507 selected: /* Got our favored event. */
1508 pending_events[i].selected = 1;
1509 process->event_thread = pending_events[i].thread;
1510 if (pending_events[i].thread)
1511 process->pid = pending_events[i].thread->ti.ti_lid;
1513 handle_waitstatus (process, pending_events[i].waited);
1514 if (thread_db_noisy)
1515 fprintf (stderr, "<select_pending_event: pid %d '%c' %d>\n",
1516 process->pid, process->stop_status, process->stop_signal);
1520 /* Function: send_pending_signals
1521 Helper function for wait_all_threads.
1523 When we call waitpid for each thread (trying to consume the SIGSTOP
1524 events that we sent from stop_all_threads), we sometimes inadvertantly
1525 get other events that we didn't send. We pend these to a list, and
1526 then resend them to the child threads after our own SIGSTOP events
1529 Some events in the list require special treatment:
1530 * One event is "selected" to be returned to the debugger.
1532 * Trap events may represent breakpoints. We can't just resend
1533 the signal. Instead we must arrange for the breakpoint to be
1534 hit again when the thread resumes. */
1537 send_pending_signals (struct child_process *process)
1542 for (i = 0; i < pending_events_top; i++)
1544 if (WIFSTOPPED (pending_events[i].waited) &&
1545 ! pending_events[i].selected)
1547 signum = WSTOPSIG (pending_events[i].waited);
1548 if (signum == SIGTRAP &&
1549 pending_events[i].thread->stepping == 0)
1551 /* Breakpoint. Push it back. */
1552 if (thread_db_noisy)
1553 fprintf (stderr, "<send_pending_events: pushing back SIGTRAP for %d>\n",
1554 pending_events[i].thread->ti.ti_lid);
1555 decr_pc_after_break (process->serv,
1556 pending_events[i].thread->ti.ti_lid);
1558 else /* FIXME we're letting SIGINT go thru as normal */
1560 /* Put the signal back into the child's queue. */
1561 kill (pending_events[i].thread->ti.ti_lid,
1562 WSTOPSIG (pending_events[i].waited));
1566 pending_events_top = 0;
1569 /* Function: wait_all_threads
1570 Use waitpid to close the loop on all threads that have been
1571 attached or SIGSTOP'd. Skip the eventpid -- it's already been waited.
1573 Special considerations:
1574 The debug signal does not go into the event queue,
1575 does not get forwarded to the thread etc. */
1578 wait_all_threads (struct child_process *process)
1580 struct gdbserv_thread *thread;
1584 for (thread = first_thread_in_list ();
1586 thread = next_thread_in_list (thread))
1588 /* Special handling for the thread that has already been waited. */
1589 if (thread->ti.ti_lid == process->pid)
1591 /* HACK mark him waited. */
1596 while ((thread->stopped || thread->attached) &&
1600 ret = waitpid (thread->ti.ti_lid, (int *) &w,
1601 thread->ti.ti_lid == proc_handle.pid ? 0 : __WCLONE);
1604 if (errno == ECHILD)
1605 fprintf (stderr, "<wait_all_threads: %d has disappeared>\n",
1608 fprintf (stderr, "<wait_all_threads: waitpid %d failed, '%s'>\n",
1609 thread->ti.ti_lid, strerror (errno));
1614 add_pending_event (thread, w);
1615 fprintf (stderr, "<wait_all_threads: %d has exited>\n",
1619 if (WIFSIGNALED (w))
1621 add_pending_event (thread, w);
1622 fprintf (stderr, "<wait_all_threads: %d died with signal %d>\n",
1623 thread->ti.ti_lid, WTERMSIG (w));
1626 stopsig = WSTOPSIG (w);
1629 /* This is the one we're looking for.
1630 Mark the thread as 'waited' and move on to the next thread. */
1631 #if 0 /* too noisy! */
1632 if (thread_db_noisy)
1633 fprintf (stderr, "<waitpid (%d, SIGSTOP)>\n", thread->ti.ti_lid);
1638 if (stopsig == debug_signal)
1640 /* This signal does not need to be forwarded. */
1641 if (thread_db_noisy)
1642 fprintf (stderr, "<wait_all_threads: ignoring SIGDEBUG (%d) for %d>\n",
1648 if (thread_db_noisy)
1649 fprintf (stderr, "<wait_all_threads: stash sig %d for %d at 0x%08x>\n",
1650 stopsig, thread->ti.ti_lid,
1651 (unsigned long) debug_get_pc (process->serv,
1652 thread->ti.ti_lid));
1653 add_pending_event (thread, w);
1657 if (!thread->waited) /* Signal was something other than STOP. */
1659 /* Continue the thread so it can stop on the next signal. */
1660 continue_lwp (thread->ti.ti_lid, 0);
1664 select_pending_event (process);
1665 send_pending_signals (process);
1668 /* Function: continue_thread
1669 Send continue to a struct gdbserv_thread. */
1672 continue_thread (struct gdbserv_thread *thread, int signal)
1674 thread_db_flush_regset_caches();
1676 /* Continue thread only if (a) it was just attached, or
1677 (b) we stopped it and waited for it. */
1678 if (thread->ti.ti_lid != 0)
1679 if (thread->attached || (thread->stopped && thread->waited))
1681 continue_lwp (thread->ti.ti_lid, signal);
1682 thread->stopped = thread->attached = thread->waited = 0;
1684 thread_db_invalidate_caches ();
1687 /* Function: continue_all_threads
1688 Send continue to all stopped or attached threads
1689 except the event thread (which will be continued separately). */
1692 continue_all_threads (struct gdbserv *serv)
1694 struct child_process *process = gdbserv_target_data (serv);
1695 struct gdbserv_thread *thread;
1698 for (thread = first_thread_in_list ();
1700 thread = next_thread_in_list (thread))
1702 /* Send any newly attached thread the restart signal. */
1703 if (thread->attached)
1704 continue_thread (thread, restart_signal);
1706 continue_thread (thread, 0);
1710 /* Function: continue_program
1711 Make sure every thread is running, starting with the event thread. */
1714 thread_db_continue_program (struct gdbserv *serv)
1716 struct child_process *process = gdbserv_target_data (serv);
1718 /* Synchronize the regset caches. */
1719 thread_db_flush_regset_caches();
1721 /* First resume the event thread. */
1722 if (process->event_thread)
1723 continue_thread (process->event_thread, process->signal_to_send);
1725 continue_lwp (process->pid, process->signal_to_send);
1727 process->stop_signal = process->stop_status =
1728 process->signal_to_send = 0;
1730 /* Then resume everyone else. */
1731 continue_all_threads (serv);
1732 process->running = 1;
1733 thread_db_invalidate_caches ();
1736 /* Function: singlestep_thread
1737 Send SINGLESTEP to a struct gdbserv_thread. */
1740 singlestep_thread (struct gdbserv *serv,
1741 struct gdbserv_thread *thread,
1744 singlestep_lwp (serv, thread->ti.ti_lid, signal);
1745 thread->stopped = thread->attached = thread->waited = 0;
1746 thread->stepping = 1;
1749 /* Function: singlestep_program
1750 Make sure every thread is runnable, while the event thread gets to
1754 thread_db_singlestep_program (struct gdbserv *serv)
1756 struct child_process *process = gdbserv_target_data (serv);
1758 /* Synchronize the regset caches. */
1759 thread_db_flush_regset_caches();
1761 /* First singlestep the event thread. */
1762 if (process->event_thread)
1763 singlestep_thread (serv, process->event_thread, process->signal_to_send);
1765 singlestep_lwp (serv, process->pid, process->signal_to_send);
1767 process->stop_status = process->stop_signal =
1768 process->signal_to_send = 0;
1770 /* Then resume everyone else. */
1771 continue_all_threads (serv); /* All but the event thread. */
1772 process->running = 1;
1773 thread_db_invalidate_caches ();
1776 /* Function: thread_db_continue_thread
1777 Let a single thread continue, while everyone else waits. */
1780 thread_db_continue_thread (struct gdbserv *serv,
1781 struct gdbserv_thread *thread,
1782 const struct gdbserv_reg *signum)
1784 struct child_process *process = gdbserv_target_data (serv);
1787 /* Synchronize the regset caches. */
1788 thread_db_flush_regset_caches();
1790 /* Handle the signal value. */
1791 if (parentvec.process_signal && signum)
1793 gdbserv_reg_to_ulong (serv, signum, &sig);
1794 parentvec.process_signal (serv, (int) sig);
1797 /* A null thread argument is to be taken as a continue for all. */
1799 thread_db_continue_program (serv);
1802 process->pid = thread->ti.ti_lid; /* thread to be continued */
1803 continue_thread (thread, process->signal_to_send);
1804 process->stop_status = process->stop_signal =
1805 process->signal_to_send = 0;
1806 process->running = 1;
1808 thread_db_invalidate_caches ();
1811 /* Function: singlestep_thread
1812 Let a single thread step, while everyone else waits. */
1815 thread_db_singlestep_thread (struct gdbserv *serv,
1816 struct gdbserv_thread *thread,
1817 const struct gdbserv_reg *signum)
1819 struct child_process *process = gdbserv_target_data (serv);
1822 /* Synchronize the regset caches. */
1823 thread_db_flush_regset_caches();
1825 /* Handle the signal value. */
1826 if (parentvec.process_signal && signum)
1828 gdbserv_reg_to_ulong (serv, signum, &sig);
1829 parentvec.process_signal (serv, (int) sig);
1832 /* A null thread argument is to be taken as a singlestep for all. */
1834 thread_db_singlestep_program (serv);
1837 singlestep_thread (serv, thread, process->signal_to_send);
1838 process->stop_status = process->stop_signal =
1839 process->signal_to_send = 0;
1840 process->running = 1;
1842 thread_db_invalidate_caches ();
1845 /* Function: exit_program
1846 Called by main loop when child exits. */
1849 thread_db_exit_program (struct gdbserv *serv)
1851 /* FIXME: stop and kill all threads. */
1853 /* Shut down the thread_db library interface. */
1854 td_ta_delete_p (thread_agent);
1855 thread_agent = NULL;
1857 /* Discard all cached symbol lookups. */
1858 free_symbol_list ();
1859 /* Discard all cached threads. */
1860 free_thread_list ();
1861 /* Call underlying exit_program method. */
1862 parentvec.exit_program (serv);
1865 /* Function: check_child_state
1867 This function checks for signal events in the running child processes.
1868 It does not block if there is no event in any child, but if there is
1869 an event, it selectively calls other functions that will, if appropriate,
1870 make sure that all the other children are stopped as well.
1872 This is a polling (non-blocking) function, and may be called when
1873 the child is already stopped. */
1876 thread_db_check_child_state (struct child_process *process)
1878 struct gdbserv *serv = process->serv;
1882 /* The "process" is likely to be the parent thread.
1883 We will have to manage a list of threads/pids. */
1885 /* Since this is a polling call, and threads don't all stop at once,
1886 it is possible for a subsequent call to intercept a new wait event
1887 before we've resumed from the previous wait event. Prevent this
1888 with a resume flag. */
1890 if (process->running)
1892 eventpid = waitpid (-1, (int *) &w, WNOHANG);
1893 /* If no event on main thread, check clone threads.
1894 It doesn't matter what event we find first, since we now have
1895 a fair algorithm for choosing which event to handle next. */
1897 eventpid = waitpid (-1, (int *) &w, WNOHANG | __WCLONE);
1899 if (eventpid > 0) /* found an event */
1901 /* Allow underlying target to use the event process by default,
1902 since it is stopped and the others are still running. */
1903 process->pid = eventpid;
1905 handle_waitstatus (process, w);
1907 /* Look for thread exit.
1908 This has to be done now -- if the eventpid has exited, I can't
1909 run update_thread_list because there is no stopped process
1910 thru which I can read memory. I could find another one to
1911 stop, but it's not really worth it. */
1912 if (process->stop_status == 'W')
1914 if (eventpid == proc_handle.pid)
1915 return 1; /* Main thread exited! */
1917 return 0; /* Just a thread exit, don't tell GDB. */
1920 /* FIXME: this debugging output will be removed soon, but
1921 putting it here before the update_thread_list etc. is
1922 bad from the point of view of synchronization. */
1923 handle_waitstatus (process, w);
1924 if (thread_db_noisy)
1925 fprintf (stderr, "<check_child_state: %d got '%c' - %d at 0x%08x>\n",
1926 process->pid, process->stop_status, process->stop_signal,
1927 (unsigned long) debug_get_pc (process->serv, process->pid));
1929 /* Update the thread list. */
1930 update_thread_list ();
1932 /* For now, call get_thread_signals from here (FIXME:) */
1933 get_thread_signals ();
1935 /* Put this child's event into the pending list. */
1936 add_pending_event (thread_list_lookup_by_lid ((lwpid_t) eventpid),
1939 stop_all_threads (process);
1940 wait_all_threads (process);
1941 /* Note: if more than one thread has an event ready to be
1942 handled, wait_all_threads will have chosen one at random. */
1944 if (got_thread_signals && process->stop_status == 'T')
1946 /* Child stopped with a signal.
1947 See if it was one of our special signals. */
1949 if (process->stop_signal == cancel_signal || /* ignore */
1950 process->stop_signal == restart_signal || /* ignore */
1951 process->stop_signal == debug_signal || /* ignore */
1952 process->stop_signal == SIGCHLD) /* ignore */
1954 /* Ignore this signal, restart the child. */
1955 if (thread_db_noisy)
1956 fprintf (stderr, "<check_child_state: ignoring signal %d for %d>\n",
1957 process->stop_signal, process->pid);
1958 if (process->stop_signal == debug_signal)
1960 /* The debug signal arrives under two circumstances:
1961 1) The main thread raises it once, upon the first call
1962 to pthread_create. This lets us detect the manager
1963 thread. The main thread MUST be given the restart
1964 signal when this occurs.
1965 2) The manager thread raises it each time a new
1966 child thread is created. The child thread will be
1967 in sigsuspend, and MUST be sent the restart signal.
1968 However, the manager thread, which raised the debug
1969 signal, does not need to be restarted.
1971 Sending the restart signal to the newly attached
1972 child thread (which is not the event thread) is
1973 handled in continue_all_threads. */
1975 if (process->pid == proc_handle.pid) /* main thread */
1976 process->stop_signal = restart_signal;
1977 else /* not main thread */
1978 process->stop_signal = 0;
1980 process->signal_to_send = process->stop_signal;
1981 currentvec->continue_program (serv);
1985 if (process->stop_status == 'W')
1987 if (process->pid == proc_handle.pid)
1988 return 1; /* Main thread exited! */
1991 currentvec->continue_program (serv);
1992 return 0; /* Just a thread exit, don't tell GDB. */
1996 process->running = 0;
1998 /* This is the place to cancel its 'stepping' flag. */
1999 if (process && process->event_thread)
2000 process->event_thread->stepping = 0;
2002 /* Pass this event back to GDB. */
2003 if (process->debug_backend)
2004 fprintf (stderr, "wait returned '%c' (%d) for %d.\n",
2005 process->stop_status, process->stop_signal, eventpid);
2010 /* NOTE: this function is called in a polling loop, so it
2011 probably (?) should not block. Return when there's no event. */
2015 /* Function: fromtarget_thread_break
2016 Called from the main loop when one of the child processes stops.
2017 Notifies the RDA library and lets it know which thread took the event. */
2020 thread_db_fromtarget_thread_break (struct child_process *process)
2022 int gdb_signal = parentvec.compute_signal (process->serv,
2023 process->stop_signal);
2025 gdbserv_fromtarget_thread_break (process->serv,
2026 process->event_thread,
2030 /* Function: get_thread_reg
2031 Get a register value for a specific thread. */
2034 thread_db_get_thread_reg (struct gdbserv *serv,
2035 struct gdbserv_thread *thread,
2037 struct gdbserv_reg *reg)
2039 struct child_process *process = gdbserv_target_data (serv);
2040 td_thrhandle_t thread_handle;
2042 FPREGSET_T fpregset;
2046 /* Initialize reg to 0 in the event that we return early due to a
2047 register being unsupported. */
2048 gdbserv_ulonglong_to_reg (serv, 0LL, reg);
2051 thread = process->event_thread; /* Default to the event thread. */
2053 if (thread_agent == NULL || /* Thread layer not alive yet? */
2054 thread == NULL) /* No thread specified? */
2056 /* Fall back on parentvec non-threaded method. */
2057 if (parentvec.get_reg)
2058 return parentvec.get_reg (serv, regnum, reg);
2060 return -1; /* give up. */
2063 /* Thread_db active, thread_agent valid.
2064 The request goes to the thread_db library.
2065 From there it will be dispatched to ps_lgetregs,
2066 and from there it will be kicked back to the parent. */
2068 if (thread->ti.ti_state == TD_THR_ZOMBIE ||
2069 thread->ti.ti_state == TD_THR_UNKNOWN)
2071 /* This thread is dead! Can't get its registers. */
2075 ret = thread_db_map_id2thr (thread_agent,
2078 if (ret == TD_NOTHR)
2080 /* Thread has exited, no registers. */
2083 else if (ret != TD_OK)
2085 fprintf (stderr, "<<< ERROR get_thread_reg map_id2thr %d >>>\n",
2087 return -1; /* fail */
2090 if (is_fp_reg (regnum))
2092 if (thread_db_getfpregs (&thread_handle, &fpregset) != TD_OK)
2094 /* Failure to get the fpregs isn't necessarily an error.
2095 Assume that the target just doesn't support fpregs. */
2098 /* Now extract the register from the fpregset. */
2099 if (reg_from_fpregset (serv, reg, regnum, &fpregset) < 0)
2101 fprintf (stderr, "<<< ERROR reg_from_fpregset %d %d>>>\n",
2102 thread->ti.ti_tid, regnum);
2106 else if (td_thr_getxregsize_p != NULL
2107 && td_thr_getxregs_p != NULL
2108 && is_extended_reg (regnum))
2113 if (td_thr_getxregsize_p (&thread_handle, &xregsize) != TD_OK)
2115 /* Failure to get the size of the extended regs isn't
2116 necessarily an error. Assume that the target just
2117 doesn't support them. */
2123 /* Another form of not being supported... */
2127 /* Allocate space for the extended registers. */
2128 xregset = alloca (xregsize);
2130 /* Fetch the extended registers. */
2131 if (td_thr_getxregs_p (&thread_handle, xregset) != TD_OK)
2133 /* Failure to get the extended regs isn't necessarily an error.
2134 Assume that the target just doesn't support them. */
2138 /* Now extract the register from the extended regset. */
2139 if (reg_from_xregset (serv, reg, regnum, xregset) < 0)
2141 fprintf (stderr, "<<< ERROR reg_from_xregset %d %d>>>\n",
2142 thread->ti.ti_tid, regnum);
2146 else if (is_gp_reg (regnum)) /* GP reg */
2148 if (thread_db_getgregs (&thread_handle, gregset) != TD_OK)
2150 fprintf (stderr, "<<< ERROR get_thread_reg td_thr_getgregs %d >>>\n",
2152 return -1; /* fail */
2154 /* Now extract the requested register from the gregset. */
2155 if (reg_from_gregset (serv, reg, regnum, gregset) < 0)
2157 fprintf (stderr, "<<< ERROR reg_from_gregset %d %d>>>\n",
2158 thread->ti.ti_tid, regnum);
2159 return -1; /* fail */
2164 /* Register not supported by this target. This shouldn't be
2165 construed as an error though. */
2169 return 0; /* success */
2172 /* Function: set_thread_reg
2173 Set a register value for a specific thread. */
2176 thread_db_set_thread_reg (struct gdbserv *serv,
2177 struct gdbserv_thread *thread,
2179 const struct gdbserv_reg *reg)
2181 struct child_process *process = gdbserv_target_data (serv);
2182 td_thrhandle_t thread_handle;
2183 FPREGSET_T fpregset;
2188 thread = process->event_thread; /* Default to the event thread. */
2190 if (thread_agent == NULL || /* Thread layer not alive yet? */
2191 thread == NULL) /* No thread specified? */
2193 /* Fall back on parentvec non-threaded method. */
2194 if (parentvec.set_reg)
2195 return parentvec.set_reg (serv, regnum, (struct gdbserv_reg *) reg);
2197 return -1; /* give up. */
2200 /* Thread_db active, thread_agent valid.
2201 The request goes to the thread_db library.
2202 From there it will be dispatched to ps_lsetregs,
2203 and from there it will be kicked back to the parent. */
2205 if (thread->ti.ti_state == TD_THR_ZOMBIE ||
2206 thread->ti.ti_state == TD_THR_UNKNOWN)
2208 /* This thread is dead! Can't get its registers. */
2212 ret = thread_db_map_id2thr (thread_agent,
2215 if (ret == TD_NOTHR)
2217 /* Thread has exited, no registers. */
2220 else if (ret != TD_OK)
2222 fprintf (stderr, "<<< ERROR set_thread_reg map_id2thr %d >>>\n",
2224 return -1; /* fail */
2227 if (is_fp_reg (regnum))
2229 /* Get the current fpregset. */
2230 if (thread_db_getfpregs (&thread_handle, &fpregset) != TD_OK)
2232 /* Failing to get the fpregs is not necessarily an error.
2233 Assume it simply means that this target doesn't support
2237 /* Now write the new reg value into the fpregset. */
2238 if (reg_to_fpregset (serv, reg, regnum, &fpregset) < 0)
2240 fprintf (stderr, "<<< ERROR reg_to_fpregset %d %d >>>\n",
2241 thread->ti.ti_tid, regnum);
2242 return -1; /* fail */
2244 /* Now write the fpregset back to the child. */
2245 if (thread_db_setfpregs (&thread_handle, &fpregset) != TD_OK)
2247 fprintf (stderr, "<<< ERROR set_thread_reg td_thr_setfpregs %d>>>\n",
2249 return -1; /* fail */
2252 else if (td_thr_getxregsize_p != NULL
2253 && td_thr_getxregs_p != NULL
2254 && td_thr_setxregs_p != NULL
2255 && is_extended_reg (regnum))
2260 if (td_thr_getxregsize_p (&thread_handle, &xregsize) != TD_OK)
2262 /* Failure to get the size of the extended regs isn't
2263 necessarily an error. Assume that the target just
2264 doesn't support them. */
2270 /* Another form of not being supported... */
2274 /* Allocate space for the extended registers. */
2275 xregset = alloca (xregsize);
2277 /* Fetch the extended registers. */
2278 if (td_thr_getxregs_p (&thread_handle, xregset) != TD_OK)
2280 /* Failure to get the extended regs isn't necessarily an error.
2281 Assume that the target just doesn't support them. */
2284 /* Now write the new reg value into the extended regset. */
2285 if (reg_to_xregset (serv, reg, regnum, xregset) < 0)
2287 fprintf (stderr, "<<< ERROR reg_to_xregset %d %d >>>\n",
2288 thread->ti.ti_tid, regnum);
2289 return -1; /* fail */
2291 /* Now write the extended regset back to the child. */
2292 if (td_thr_setxregs_p (&thread_handle, gregset) != TD_OK)
2294 fprintf (stderr, "<<< ERROR set_thread_reg td_thr_setxregs %d >>>\n",
2296 return -1; /* fail */
2299 else if (is_gp_reg (regnum))
2301 /* First get the current gregset. */
2302 if (thread_db_getgregs (&thread_handle, gregset) != TD_OK)
2304 fprintf (stderr, "<<< ERROR set_thread_reg td_thr_getgregs %d >>>\n",
2306 return -1; /* fail */
2308 /* Now write the new reg value into the gregset. */
2309 if (reg_to_gregset (serv, reg, regnum, gregset) < 0)
2311 fprintf (stderr, "<<< ERROR reg_to_gregset %d %d >>>\n",
2312 thread->ti.ti_tid, regnum);
2313 return -1; /* fail */
2315 /* Now write the gregset back to the child. */
2316 if (thread_db_setgregs (&thread_handle, gregset) != TD_OK)
2318 fprintf (stderr, "<<< ERROR set_thread_reg td_thr_setgregs %d >>>\n",
2320 return -1; /* fail */
2324 return 0; /* success */
2327 /* Function: thread_db_attach
2328 gdbserv target function called upon attaching to gdb.
2329 Return -1 for failure, zero for success.
2330 Note that this has nothing to do with attaching to a running process
2331 (which in fact we don't even know how to do), or a running thread. */
2334 thread_db_attach (struct gdbserv *serv, struct gdbserv_target *target)
2337 struct child_process *process = target->data;
2338 extern struct server_vector gdbserver;
2341 if ((thread_db_dlopen ()) < 0)
2342 return -1; /* fail */
2344 /* Save a copy of the existing target vector before we modify it. */
2345 memcpy (&parentvec, target, sizeof (parentvec));
2346 /* Save a pointer to the actual target vector. */
2347 currentvec = target;
2349 /* Initialize the library. */
2350 if ((ret = td_init_p ()) != TD_OK)
2353 "Cannot initialize libthread_db: %s", thread_db_err_str (ret));
2355 return -1; /* fail */
2358 /* Initialize threadish target methods. */
2359 target->thread_info = thread_db_thread_info;
2360 target->thread_next = thread_db_thread_next;
2361 target->thread_id = thread_db_thread_id;
2362 target->thread_lookup_by_id = thread_db_thread_lookup_by_id;
2363 target->process_set_gen = thread_db_set_gen;
2364 target->process_get_gen = thread_db_get_gen;
2365 target->detach = thread_db_detach;
2367 /* Take over selected target methods. */
2368 target->exit_program = thread_db_exit_program;
2369 target->continue_program = thread_db_continue_program;
2370 target->singlestep_program = thread_db_singlestep_program;
2372 target->continue_thread = thread_db_continue_thread;
2373 target->singlestep_thread = thread_db_singlestep_thread;
2375 /* Take over get_reg / set_reg methods with threaded versions. */
2376 if (target->next_gg_reg != NULL &&
2377 target->reg_format != NULL &&
2378 target->output_reg != NULL &&
2379 target->input_reg != NULL)
2381 target->get_thread_reg = thread_db_get_thread_reg;
2382 target->set_thread_reg = thread_db_set_thread_reg;
2385 fprintf (stderr, "< ERROR attach: GDB will not read thread regs. >>>\n");
2387 if (td_symbol_list_p)
2389 /* Take all the symbol names libthread_db might try to look up
2390 and place them in our cached symbol list, to be looked up
2391 when invited by GDB. */
2392 const char **symbol_list = td_symbol_list_p ();
2395 for (i = 0; symbol_list[i]; i++)
2396 add_symbol_to_list (symbol_list[i], 0, UNDEFINED);
2400 /* KLUDGE: Insert some magic symbols into the cached symbol list,
2401 to be looked up later. This is badly wrong -- we should be
2402 obtaining these values thru the thread_db interface. Their names
2403 should not be hard-coded here <sob>. */
2404 add_symbol_to_list ("__pthread_sig_restart", 0, UNDEFINED);
2405 add_symbol_to_list ("__pthread_sig_cancel", 0, UNDEFINED);
2406 add_symbol_to_list ("__pthread_sig_debug", 0, UNDEFINED);
2407 add_symbol_to_list ("__pthread_threads_debug", 0, UNDEFINED);
2410 /* Attempt to open the thread_db interface. This attempt will
2411 most likely fail (unles the child is statically linked). */
2412 thread_db_open (serv, process->pid); /* Don't test return value */
2414 /* Take over the "wait" vector. FIXME global object */
2415 gdbserver.check_child_state = thread_db_check_child_state;
2416 /* Take over the "fromtarget_break" vector. FIXME global object */
2417 gdbserver.fromtarget_break = thread_db_fromtarget_thread_break;
2418 /* FIXME what about terminate and exit? */
2420 /* Set up the regset caches. */
2421 initialize_regset_caches ();
2422 return 0; /* success */