1 /* Copyright (C) 2008, 2009 Free Software Foundation, Inc.
3 This file is part of GDB.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include <sys/procfs.h>
27 #include "gdbthread.h"
29 #include <pthread_debug.h>
31 /* Print debugging traces if set to non-zero. */
32 static int debug_dec_thread = 0;
34 /* Non-zero if the dec-thread layer is active. */
35 static int dec_thread_active = 0;
37 /* The pthread_debug context. */
38 pthreadDebugContext_t debug_context;
40 /* The dec-thread target_ops structure. */
41 static struct target_ops dec_thread_ops;
43 /* Print a debug trace if DEBUG_DEC_THREAD is set (its value is adjusted
44 by the user using "set debug dec-thread ..."). */
47 debug (char *format, ...)
53 va_start (args, format);
54 printf_unfiltered ("DEC Threads: ");
55 vprintf_unfiltered (format, args);
56 printf_unfiltered ("\n");
61 /* pthread debug callbacks. */
64 suspend_clbk (void *caller_context)
70 resume_clbk (void *caller_context)
76 hold_clbk (void *caller_context, pthreadDebugKId_t kernel_tid)
82 unhold_clbk (void *caller_context, pthreadDebugKId_t kernel_tid)
88 read_clbk (void *caller_context, void *address, void *buffer,
91 int status = target_read_memory ((CORE_ADDR) address, buffer, size);
100 write_clbk (void *caller_context, void *address, void *buffer,
103 int status = target_write_memory ((CORE_ADDR) address, buffer, size);
111 /* Get integer regs */
114 get_reg_clbk(void *caller_context, pthreadDebugGetRegRtn_t regs,
115 pthreadDebugKId_t kernel_tid)
117 debug ("get_reg_clbk");
119 /* Not sure that we actually need to do anything in this callback. */
123 /* Set integer regs */
126 set_reg_clbk(void *caller_context, const pthreadDebugRegs_t *regs,
127 pthreadDebugKId_t kernel_tid)
129 debug ("set_reg_clbk");
131 /* Not sure that we actually need to do anything in this callback. */
136 output_clbk (void *caller_context, char *line)
138 printf_filtered ("%s\n", line);
143 error_clbk (void *caller_context, char *line)
145 fprintf_filtered (gdb_stderr, "%s\n", line);
149 /* Get floating-point regs. */
152 get_fpreg_clbk (void *caller_context, pthreadDebugFregs_p fregs,
153 pthreadDebugKId_t kernel_tid)
155 debug ("get_fpreg_clbk");
157 /* Not sure that we actually need to do anything in this callback. */
161 /* Set floating-point regs. */
164 set_fpreg_clbk (void *caller_context, const pthreadDebugFregs_t *fregs,
165 pthreadDebugKId_t kernel_tid)
167 debug ("set_fpreg_clbk");
169 /* Not sure that we actually need to do anything in this callback. */
174 malloc_clbk (void *caller_context, size_t size)
176 return xmalloc (size);
180 free_clbk (void *caller_context, void *address)
186 kthdinfo_clbk (pthreadDebugClient_t caller_context,
187 pthreadDebugKId_t kernel_tid,
188 pthreadDebugKThreadInfo_p thread_info)
194 speckthd_clbk (pthreadDebugClient_t caller_context,
195 pthreadDebugSpecialType_t type,
196 pthreadDebugKId_t *kernel_tid)
201 static pthreadDebugCallbacks_t debug_callbacks =
203 PTHREAD_DEBUG_VERSION,
204 (pthreadDebugGetMemRtn_t) read_clbk,
205 (pthreadDebugSetMemRtn_t) write_clbk,
211 (pthreadDebugGetFregRtn_t) get_fpreg_clbk,
212 (pthreadDebugSetFregRtn_t) set_fpreg_clbk,
213 (pthreadDebugGetRegRtn_t) get_reg_clbk,
214 (pthreadDebugSetRegRtn_t) set_reg_clbk,
215 (pthreadDebugOutputRtn_t) output_clbk,
216 (pthreadDebugOutputRtn_t) error_clbk,
222 /* Activate thread support if appropriate. Do nothing if thread
223 support is already active. */
226 enable_dec_thread (void)
228 struct minimal_symbol *msym;
229 void* caller_context;
232 /* If already active, nothing more to do. */
233 if (dec_thread_active)
236 msym = lookup_minimal_symbol ("__pthread_dbg_symtable", NULL, NULL);
239 debug ("enable_dec_thread: No __pthread_dbg_symtable");
243 status = pthreadDebugContextInit (&caller_context, &debug_callbacks,
244 (void *) SYMBOL_VALUE_ADDRESS (msym),
246 if (status != ESUCCESS)
248 debug ("enable_dec_thread: pthreadDebugContextInit -> %d",
253 push_target (&dec_thread_ops);
254 dec_thread_active = 1;
256 debug ("enable_dec_thread: Thread support enabled.");
259 /* Deactivate thread support. Do nothing is thread support is
263 disable_dec_thread (void)
265 if (!dec_thread_active)
268 pthreadDebugContextDestroy (debug_context);
269 unpush_target (&dec_thread_ops);
270 dec_thread_active = 0;
273 /* A structure that contains a thread ID and is associated
274 pthreadDebugThreadInfo_t data. */
276 struct dec_thread_info
278 pthreadDebugId_t thread;
279 pthreadDebugThreadInfo_t info;
281 typedef struct dec_thread_info dec_thread_info_s;
283 /* The list of user threads. */
285 DEF_VEC_O (dec_thread_info_s);
286 VEC(dec_thread_info_s) *dec_thread_list;
288 /* Release the memory used by the given VECP thread list pointer.
289 Then set *VECP to NULL. */
292 free_dec_thread_info_vec (VEC(dec_thread_info_s) **vecp)
295 struct dec_thread_info *item;
296 VEC(dec_thread_info_s) *vec = *vecp;
298 for (i = 0; VEC_iterate (dec_thread_info_s, vec, i, item); i++)
300 VEC_free (dec_thread_info_s, vec);
304 /* Return a thread's ptid given its associated INFO. */
307 ptid_build_from_info (struct dec_thread_info info)
309 int pid = ptid_get_pid (inferior_ptid);
311 return ptid_build (pid, 0, (long) info.thread);
314 /* Recompute the list of user threads and store the result in
318 update_dec_thread_list (void)
320 pthreadDebugId_t thread;
321 pthreadDebugThreadInfo_t info;
324 free_dec_thread_info_vec (&dec_thread_list);
325 res = pthreadDebugThdSeqInit (debug_context, &thread);
326 while (res == ESUCCESS)
329 res = pthreadDebugThdGetInfo (debug_context, thread, &info);
331 warning (_("unable to get thread info, ignoring thread %ld"),
333 else if (info.kind == PTHREAD_DEBUG_THD_KIND_INITIAL
334 || info.kind == PTHREAD_DEBUG_THD_KIND_NORMAL)
336 struct dec_thread_info *item =
337 xmalloc (sizeof (struct dec_thread_info));
339 item->thread = thread;
341 VEC_safe_push (dec_thread_info_s, dec_thread_list, item);
343 res = pthreadDebugThdSeqNext (debug_context, &thread);
345 pthreadDebugThdSeqDestroy (debug_context);
348 /* A callback to count the number of threads known to GDB. */
351 dec_thread_count_gdb_threads (struct thread_info *ignored, void *context)
353 int *count = (int *) context;
359 /* A callback that saves the given thread INFO at the end of an
360 array. The end of the array is given in the CONTEXT and is
361 incremented once the info has been added. */
364 dec_thread_add_gdb_thread (struct thread_info *info, void *context)
366 struct thread_info ***listp = (struct thread_info ***) context;
373 /* Resynchronize the list of threads known by GDB with the actual
374 list of threads reported by libpthread_debug. */
377 resync_thread_list (void)
380 struct dec_thread_info *info;
381 int num_gdb_threads = 0;
382 struct thread_info **gdb_thread_list;
383 struct thread_info **next_thread_info;
385 update_dec_thread_list ();
387 /* Add new threads. */
389 for (i = 0; VEC_iterate (dec_thread_info_s, dec_thread_list, i, info);
392 ptid_t ptid = ptid_build_from_info (*info);
394 if (!in_thread_list (ptid))
398 /* Remove threads that no longer exist. To help with the search,
399 we build an array of GDB threads, and then iterate over this
402 iterate_over_threads (dec_thread_count_gdb_threads,
403 (void *) &num_gdb_threads);
404 gdb_thread_list = alloca (num_gdb_threads * sizeof (struct thread_info *));
405 next_thread_info = gdb_thread_list;
406 iterate_over_threads (dec_thread_add_gdb_thread, (void *) &next_thread_info);
407 for (i = 0; i < num_gdb_threads; i++)
411 for (j = 0; VEC_iterate (dec_thread_info_s, dec_thread_list, j, info);
413 if (ptid_equal (gdb_thread_list[i]->ptid,
414 ptid_build_from_info (*info)))
416 delete_thread (gdb_thread_list[i]->ptid);
420 /* The "to_detach" method of the dec_thread_ops. */
423 dec_thread_detach (struct target_ops *ops, char *args, int from_tty)
425 struct target_ops *beneath = find_target_beneath (ops);
427 debug ("dec_thread_detach");
429 disable_dec_thread ();
430 beneath->to_detach (beneath, args, from_tty);
433 /* Return the ptid of the thread that is currently active. */
436 get_active_ptid (void)
439 struct dec_thread_info *info;
441 for (i = 0; VEC_iterate (dec_thread_info_s, dec_thread_list, i, info);
443 if (info->info.state == PTHREAD_DEBUG_STATE_RUNNING)
444 return ptid_build_from_info (*info);
446 /* No active thread found. This can happen when the program
451 /* The "to_wait" method of the dec_thread_ops. */
454 dec_thread_wait (struct target_ops *ops,
455 ptid_t ptid, struct target_waitstatus *status)
458 struct target_ops *beneath = find_target_beneath (ops);
460 debug ("dec_thread_wait");
462 ptid = beneath->to_wait (beneath, ptid, status);
464 /* The ptid returned by the target beneath us is the ptid of the process.
465 We need to find which thread is currently active and return its ptid. */
466 resync_thread_list ();
467 active_ptid = get_active_ptid ();
468 if (ptid_equal (active_ptid, null_ptid))
473 /* Fetch the general purpose and floating point registers for the given
474 thread TID, and store the result in GREGSET and FPREGSET. Return
475 zero if successful. */
478 dec_thread_get_regsets (pthreadDebugId_t tid, gdb_gregset_t *gregset,
479 gdb_fpregset_t *fpregset)
482 pthreadDebugRegs_t regs;
483 pthreadDebugFregs_t fregs;
485 res = pthreadDebugThdGetReg (debug_context, tid, ®s);
488 debug ("dec_thread_get_regsets: pthreadDebugThdGetReg -> %d", res);
491 memcpy (gregset->regs, ®s, sizeof (regs));
493 res = pthreadDebugThdGetFreg (debug_context, tid, &fregs);
496 debug ("dec_thread_get_regsets: pthreadDebugThdGetFreg -> %d", res);
499 memcpy (fpregset->regs, &fregs, sizeof (fregs));
504 /* The "to_fetch_registers" method of the dec_thread_ops.
506 Because the dec-thread debug API doesn't allow us to fetch
507 only one register, we simply ignore regno and fetch+supply all
511 dec_thread_fetch_registers (struct target_ops *ops,
512 struct regcache *regcache, int regno)
514 pthreadDebugId_t tid = ptid_get_tid (inferior_ptid);
519 debug ("dec_thread_fetch_registers (tid=%ld, regno=%d)", tid, regno);
522 if (tid == 0 || ptid_equal (inferior_ptid, get_active_ptid ()))
524 struct target_ops *beneath = find_target_beneath (ops);
526 beneath->to_fetch_registers (beneath, regcache, regno);
530 res = dec_thread_get_regsets (tid, &gregset, &fpregset);
534 supply_gregset (regcache, &gregset);
535 supply_fpregset (regcache, &fpregset);
538 /* Store the registers given in GREGSET and FPREGSET into the associated
539 general purpose and floating point registers of thread TID. Return
540 zero if successful. */
543 dec_thread_set_regsets (pthreadDebugId_t tid, gdb_gregset_t gregset,
544 gdb_fpregset_t fpregset)
547 pthreadDebugRegs_t regs;
548 pthreadDebugFregs_t fregs;
550 memcpy (®s, gregset.regs, sizeof (regs));
551 res = pthreadDebugThdSetReg (debug_context, tid, ®s);
554 debug ("dec_thread_set_regsets: pthreadDebugThdSetReg -> %d", res);
558 memcpy (&fregs, fpregset.regs, sizeof (fregs));
559 res = pthreadDebugThdSetFreg (debug_context, tid, &fregs);
562 debug ("dec_thread_set_regsets: pthreadDebugThdSetFreg -> %d", res);
569 /* The "to_store_registers" method of the dec_thread_ops.
571 Because the dec-thread debug API doesn't allow us to store
572 just one register, we store all the registers. */
575 dec_thread_store_registers (struct target_ops *ops,
576 struct regcache *regcache, int regno)
578 pthreadDebugId_t tid = ptid_get_tid (inferior_ptid);
583 debug ("dec_thread_store_registers (tid=%ld, regno=%d)", tid, regno);
585 if (tid == 0 || ptid_equal (inferior_ptid, get_active_ptid ()))
587 struct target_ops *beneath = find_target_beneath (ops);
589 beneath->to_store_registers (beneath, regcache, regno);
593 /* FIXME: brobecker/2008-05-28: I wonder if we could simply check
594 in which register set the register is and then only store the
595 registers for that register set, instead of storing both register
597 fill_gregset (regcache, &gregset, -1);
598 fill_fpregset (regcache, &fpregset, -1);
600 res = dec_thread_set_regsets (tid, gregset, fpregset);
602 warning (_("failed to store registers."));
605 /* The "to_mourn_inferior" method of the dec_thread_ops. */
608 dec_thread_mourn_inferior (struct target_ops *ops)
610 struct target_ops *beneath = find_target_beneath (ops);
612 debug ("dec_thread_mourn_inferior");
614 disable_dec_thread ();
615 beneath->to_mourn_inferior (beneath);
618 /* The "to_thread_alive" method of the dec_thread_ops. */
620 dec_thread_thread_alive (struct target_ops *ops, ptid_t ptid)
622 debug ("dec_thread_thread_alive (tid=%ld)", ptid_get_tid (ptid));
624 /* The thread list maintained by GDB is up to date, since we update
625 it everytime we stop. So check this list. */
626 return in_thread_list (ptid);
629 /* The "to_pid_to_str" method of the dec_thread_ops. */
632 dec_thread_pid_to_str (struct target_ops *ops, ptid_t ptid)
634 static char *ret = NULL;
636 if (ptid_get_tid (ptid) == 0)
638 struct target_ops *beneath = find_target_beneath (ops);
640 return beneath->to_pid_to_str (beneath, ptid);
643 /* Free previous return value; a new one will be allocated by
647 ret = xstrprintf (_("Thread %ld"), ptid_get_tid (ptid));
651 /* A "new-objfile" observer. Used to activate/deactivate dec-thread
655 dec_thread_new_objfile_observer (struct objfile *objfile)
658 enable_dec_thread ();
660 disable_dec_thread ();
664 init_dec_thread_ops (void)
666 dec_thread_ops.to_shortname = "dec-threads";
667 dec_thread_ops.to_longname = _("DEC threads support");
668 dec_thread_ops.to_doc = _("DEC threads support");
669 dec_thread_ops.to_detach = dec_thread_detach;
670 dec_thread_ops.to_wait = dec_thread_wait;
671 dec_thread_ops.to_fetch_registers = dec_thread_fetch_registers;
672 dec_thread_ops.to_store_registers = dec_thread_store_registers;
673 dec_thread_ops.to_mourn_inferior = dec_thread_mourn_inferior;
674 dec_thread_ops.to_thread_alive = dec_thread_thread_alive;
675 dec_thread_ops.to_pid_to_str = dec_thread_pid_to_str;
676 dec_thread_ops.to_stratum = thread_stratum;
677 dec_thread_ops.to_magic = OPS_MAGIC;
681 _initialize_dec_thread (void)
683 init_dec_thread_ops ();
684 add_target (&dec_thread_ops);
686 observer_attach_new_objfile (dec_thread_new_objfile_observer);
688 add_setshow_boolean_cmd ("dec-thread", class_maintenance, &debug_dec_thread,
689 _("Set debugging of DEC threads module."),
690 _("Show debugging of DEC threads module."),
691 _("Enables debugging output (used to debug GDB)."),
693 &setdebuglist, &showdebuglist);