1 /* BSD user-level threads support.
3 Copyright (C) 2005-2014 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/>. */
22 #include "gdbthread.h"
32 #include "gdb_assert.h"
33 #include "gdb_obstack.h"
35 #include "bsd-uthread.h"
37 /* HACK: Save the bsd_uthreads ops returned by bsd_uthread_target. */
38 static struct target_ops *bsd_uthread_ops_hack;
41 /* Architecture-specific operations. */
43 /* Per-architecture data key. */
44 static struct gdbarch_data *bsd_uthread_data;
46 struct bsd_uthread_ops
48 /* Supply registers for an inactive thread to a register cache. */
49 void (*supply_uthread)(struct regcache *, int, CORE_ADDR);
51 /* Collect registers for an inactive thread from a register cache. */
52 void (*collect_uthread)(const struct regcache *, int, CORE_ADDR);
56 bsd_uthread_init (struct obstack *obstack)
58 struct bsd_uthread_ops *ops;
60 ops = OBSTACK_ZALLOC (obstack, struct bsd_uthread_ops);
64 /* Set the function that supplies registers from an inactive thread
65 for architecture GDBARCH to SUPPLY_UTHREAD. */
68 bsd_uthread_set_supply_uthread (struct gdbarch *gdbarch,
69 void (*supply_uthread) (struct regcache *,
72 struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
73 ops->supply_uthread = supply_uthread;
76 /* Set the function that collects registers for an inactive thread for
77 architecture GDBARCH to SUPPLY_UTHREAD. */
80 bsd_uthread_set_collect_uthread (struct gdbarch *gdbarch,
81 void (*collect_uthread) (const struct regcache *,
84 struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
85 ops->collect_uthread = collect_uthread;
88 /* Magic number to help recognize a valid thread structure. */
89 #define BSD_UTHREAD_PTHREAD_MAGIC 0xd09ba115
91 /* Check whether the thread structure at ADDR is valid. */
94 bsd_uthread_check_magic (CORE_ADDR addr)
96 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
97 ULONGEST magic = read_memory_unsigned_integer (addr, 4, byte_order);
99 if (magic != BSD_UTHREAD_PTHREAD_MAGIC)
100 error (_("Bad magic"));
104 #define BSD_UTHREAD_PS_RUNNING 0
105 #define BSD_UTHREAD_PS_DEAD 18
107 /* Address of the pointer to the thread structure for the running
109 static CORE_ADDR bsd_uthread_thread_run_addr;
111 /* Address of the list of all threads. */
112 static CORE_ADDR bsd_uthread_thread_list_addr;
114 /* Offsets of various "interesting" bits in the thread structure. */
115 static int bsd_uthread_thread_state_offset = -1;
116 static int bsd_uthread_thread_next_offset = -1;
117 static int bsd_uthread_thread_ctx_offset;
119 /* Name of shared threads library. */
120 static const char *bsd_uthread_solib_name;
122 /* Non-zero if the thread startum implemented by this module is active. */
123 static int bsd_uthread_active;
126 bsd_uthread_lookup_address (const char *name, struct objfile *objfile)
128 struct minimal_symbol *sym;
130 sym = lookup_minimal_symbol (name, NULL, objfile);
132 return SYMBOL_VALUE_ADDRESS (sym);
138 bsd_uthread_lookup_offset (const char *name, struct objfile *objfile)
140 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
143 addr = bsd_uthread_lookup_address (name, objfile);
147 return read_memory_unsigned_integer (addr, 4, byte_order);
151 bsd_uthread_read_memory_address (CORE_ADDR addr)
153 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
154 return read_memory_typed_address (addr, ptr_type);
157 /* If OBJFILE contains the symbols corresponding to one of the
158 supported user-level threads libraries, activate the thread stratum
159 implemented by this module. */
162 bsd_uthread_activate (struct objfile *objfile)
164 struct gdbarch *gdbarch = target_gdbarch ();
165 struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
167 /* Skip if the thread stratum has already been activated. */
168 if (bsd_uthread_active)
171 /* There's no point in enabling this module if no
172 architecture-specific operations are provided. */
173 if (!ops->supply_uthread)
176 bsd_uthread_thread_run_addr =
177 bsd_uthread_lookup_address ("_thread_run", objfile);
178 if (bsd_uthread_thread_run_addr == 0)
181 bsd_uthread_thread_list_addr =
182 bsd_uthread_lookup_address ("_thread_list", objfile);
183 if (bsd_uthread_thread_list_addr == 0)
186 bsd_uthread_thread_state_offset =
187 bsd_uthread_lookup_offset ("_thread_state_offset", objfile);
188 if (bsd_uthread_thread_state_offset == 0)
191 bsd_uthread_thread_next_offset =
192 bsd_uthread_lookup_offset ("_thread_next_offset", objfile);
193 if (bsd_uthread_thread_next_offset == 0)
196 bsd_uthread_thread_ctx_offset =
197 bsd_uthread_lookup_offset ("_thread_ctx_offset", objfile);
199 push_target (bsd_uthread_ops_hack);
200 bsd_uthread_active = 1;
204 /* Cleanup due to deactivation. */
207 bsd_uthread_close (void)
209 bsd_uthread_active = 0;
210 bsd_uthread_thread_run_addr = 0;
211 bsd_uthread_thread_list_addr = 0;
212 bsd_uthread_thread_state_offset = 0;
213 bsd_uthread_thread_next_offset = 0;
214 bsd_uthread_thread_ctx_offset = 0;
215 bsd_uthread_solib_name = NULL;
218 /* Deactivate the thread stratum implemented by this module. */
221 bsd_uthread_deactivate (void)
223 /* Skip if the thread stratum has already been deactivated. */
224 if (!bsd_uthread_active)
227 unpush_target (bsd_uthread_ops_hack);
231 bsd_uthread_inferior_created (struct target_ops *ops, int from_tty)
233 bsd_uthread_activate (NULL);
236 /* Likely candidates for the threads library. */
237 static const char *bsd_uthread_solib_names[] =
239 "/usr/lib/libc_r.so", /* FreeBSD */
240 "/usr/lib/libpthread.so", /* OpenBSD */
245 bsd_uthread_solib_loaded (struct so_list *so)
247 const char **names = bsd_uthread_solib_names;
249 for (names = bsd_uthread_solib_names; *names; names++)
251 if (strncmp (so->so_original_name, *names, strlen (*names)) == 0)
253 solib_read_symbols (so, 0);
255 if (bsd_uthread_activate (so->objfile))
257 bsd_uthread_solib_name = so->so_original_name;
265 bsd_uthread_solib_unloaded (struct so_list *so)
267 if (!bsd_uthread_solib_name)
270 if (strcmp (so->so_original_name, bsd_uthread_solib_name) == 0)
271 bsd_uthread_deactivate ();
275 bsd_uthread_mourn_inferior (struct target_ops *ops)
277 struct target_ops *beneath = find_target_beneath (ops);
278 beneath->to_mourn_inferior (beneath);
279 bsd_uthread_deactivate ();
283 bsd_uthread_fetch_registers (struct target_ops *ops,
284 struct regcache *regcache, int regnum)
286 struct gdbarch *gdbarch = get_regcache_arch (regcache);
287 struct bsd_uthread_ops *uthread_ops = gdbarch_data (gdbarch, bsd_uthread_data);
288 CORE_ADDR addr = ptid_get_tid (inferior_ptid);
289 struct target_ops *beneath = find_target_beneath (ops);
290 CORE_ADDR active_addr;
292 /* Always fetch the appropriate registers from the layer beneath. */
293 beneath->to_fetch_registers (beneath, regcache, regnum);
295 /* FIXME: That might have gotten us more than we asked for. Make
296 sure we overwrite all relevant registers with values from the
297 thread structure. This can go once we fix the underlying target. */
300 active_addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
301 if (addr != 0 && addr != active_addr)
303 bsd_uthread_check_magic (addr);
304 uthread_ops->supply_uthread (regcache, regnum,
305 addr + bsd_uthread_thread_ctx_offset);
310 bsd_uthread_store_registers (struct target_ops *ops,
311 struct regcache *regcache, int regnum)
313 struct gdbarch *gdbarch = get_regcache_arch (regcache);
314 struct bsd_uthread_ops *uthread_ops = gdbarch_data (gdbarch, bsd_uthread_data);
315 struct target_ops *beneath = find_target_beneath (ops);
316 CORE_ADDR addr = ptid_get_tid (inferior_ptid);
317 CORE_ADDR active_addr;
319 active_addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
320 if (addr != 0 && addr != active_addr)
322 bsd_uthread_check_magic (addr);
323 uthread_ops->collect_uthread (regcache, regnum,
324 addr + bsd_uthread_thread_ctx_offset);
328 /* Updating the thread that is currently running; pass the
329 request to the layer beneath. */
330 beneath->to_store_registers (beneath, regcache, regnum);
334 /* Implement the to_xfer_partial target_ops method. FIXME: This
335 function is only there because otherwise GDB tries to invoke
336 deprecate_xfer_memory. */
338 static enum target_xfer_status
339 bsd_uthread_xfer_partial (struct target_ops *ops, enum target_object object,
340 const char *annex, gdb_byte *readbuf,
341 const gdb_byte *writebuf,
342 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
344 gdb_assert (ops->beneath->to_xfer_partial);
345 return ops->beneath->to_xfer_partial (ops->beneath, object, annex, readbuf,
346 writebuf, offset, len, xfered_len);
350 bsd_uthread_wait (struct target_ops *ops,
351 ptid_t ptid, struct target_waitstatus *status, int options)
353 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
355 struct target_ops *beneath = find_target_beneath (ops);
357 /* Pass the request to the layer beneath. */
358 ptid = beneath->to_wait (beneath, ptid, status, options);
360 /* If the process is no longer alive, there's no point in figuring
361 out the thread ID. It will fail anyway. */
362 if (status->kind == TARGET_WAITKIND_SIGNALLED
363 || status->kind == TARGET_WAITKIND_EXITED)
366 /* Fetch the corresponding thread ID, and augment the returned
367 process ID with it. */
368 addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
373 /* FIXME: For executables linked statically with the threads
374 library, we end up here before the program has actually been
375 executed. In that case ADDR will be garbage since it has
376 been read from the wrong virtual memory image. */
377 if (target_read_memory (addr, buf, 4) == 0)
379 ULONGEST magic = extract_unsigned_integer (buf, 4, byte_order);
380 if (magic == BSD_UTHREAD_PTHREAD_MAGIC)
381 ptid = ptid_build (ptid_get_pid (ptid), 0, addr);
385 /* If INFERIOR_PTID doesn't have a tid member yet, and we now have a
386 ptid with tid set, then ptid is still the initial thread of
387 the process. Notify GDB core about it. */
388 if (ptid_get_tid (inferior_ptid) == 0
389 && ptid_get_tid (ptid) != 0 && !in_thread_list (ptid))
390 thread_change_ptid (inferior_ptid, ptid);
392 /* Don't let the core see a ptid without a corresponding thread. */
393 if (!in_thread_list (ptid) || is_exited (ptid))
400 bsd_uthread_resume (struct target_ops *ops,
401 ptid_t ptid, int step, enum gdb_signal sig)
403 /* Pass the request to the layer beneath. */
404 struct target_ops *beneath = find_target_beneath (ops);
405 beneath->to_resume (beneath, ptid, step, sig);
409 bsd_uthread_thread_alive (struct target_ops *ops, ptid_t ptid)
411 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
412 struct target_ops *beneath = find_target_beneath (ops);
413 CORE_ADDR addr = ptid_get_tid (inferior_ptid);
417 int offset = bsd_uthread_thread_state_offset;
420 bsd_uthread_check_magic (addr);
422 state = read_memory_unsigned_integer (addr + offset, 4, byte_order);
423 if (state == BSD_UTHREAD_PS_DEAD)
427 return beneath->to_thread_alive (beneath, ptid);
431 bsd_uthread_find_new_threads (struct target_ops *ops)
433 pid_t pid = ptid_get_pid (inferior_ptid);
434 int offset = bsd_uthread_thread_next_offset;
437 addr = bsd_uthread_read_memory_address (bsd_uthread_thread_list_addr);
440 ptid_t ptid = ptid_build (pid, 0, addr);
442 if (!in_thread_list (ptid) || is_exited (ptid))
444 /* If INFERIOR_PTID doesn't have a tid member yet, then ptid
445 is still the initial thread of the process. Notify GDB
447 if (ptid_get_tid (inferior_ptid) == 0)
448 thread_change_ptid (inferior_ptid, ptid);
453 addr = bsd_uthread_read_memory_address (addr + offset);
457 /* Possible states a thread can be in. */
458 static char *bsd_uthread_state[] =
482 /* Return a string describing th state of the thread specified by
486 bsd_uthread_extra_thread_info (struct thread_info *info)
488 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
489 CORE_ADDR addr = ptid_get_tid (info->ptid);
493 int offset = bsd_uthread_thread_state_offset;
496 state = read_memory_unsigned_integer (addr + offset, 4, byte_order);
497 if (state < ARRAY_SIZE (bsd_uthread_state))
498 return bsd_uthread_state[state];
505 bsd_uthread_pid_to_str (struct target_ops *ops, ptid_t ptid)
507 if (ptid_get_tid (ptid) != 0)
511 xsnprintf (buf, sizeof buf, "process %d, thread 0x%lx",
512 ptid_get_pid (ptid), ptid_get_tid (ptid));
516 return normal_pid_to_str (ptid);
519 static struct target_ops *
520 bsd_uthread_target (void)
522 struct target_ops *t = XCNEW (struct target_ops);
524 t->to_shortname = "bsd-uthreads";
525 t->to_longname = "BSD user-level threads";
526 t->to_doc = "BSD user-level threads";
527 t->to_close = bsd_uthread_close;
528 t->to_mourn_inferior = bsd_uthread_mourn_inferior;
529 t->to_fetch_registers = bsd_uthread_fetch_registers;
530 t->to_store_registers = bsd_uthread_store_registers;
531 t->to_xfer_partial = bsd_uthread_xfer_partial;
532 t->to_wait = bsd_uthread_wait;
533 t->to_resume = bsd_uthread_resume;
534 t->to_thread_alive = bsd_uthread_thread_alive;
535 t->to_find_new_threads = bsd_uthread_find_new_threads;
536 t->to_extra_thread_info = bsd_uthread_extra_thread_info;
537 t->to_pid_to_str = bsd_uthread_pid_to_str;
538 t->to_stratum = thread_stratum;
539 t->to_magic = OPS_MAGIC;
540 bsd_uthread_ops_hack = t;
545 /* Provide a prototype to silence -Wmissing-prototypes. */
546 extern initialize_file_ftype _initialize_bsd_uthread;
549 _initialize_bsd_uthread (void)
551 complete_target_initialization (bsd_uthread_target ());
553 bsd_uthread_data = gdbarch_data_register_pre_init (bsd_uthread_init);
555 observer_attach_inferior_created (bsd_uthread_inferior_created);
556 observer_attach_solib_loaded (bsd_uthread_solib_loaded);
557 observer_attach_solib_unloaded (bsd_uthread_solib_unloaded);