xref: /dragonfly/contrib/gdb-7/gdb/bsd-uthread.c (revision 6e278935)
1 /* BSD user-level threads support.
2 
3    Copyright (C) 2005, 2007, 2008, 2009, 2010, 2011
4    Free Software Foundation, Inc.
5 
6    This file is part of GDB.
7 
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12 
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17 
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20 
21 #include "defs.h"
22 #include "gdbcore.h"
23 #include "gdbthread.h"
24 #include "inferior.h"
25 #include "objfiles.h"
26 #include "observer.h"
27 #include "regcache.h"
28 #include "solib.h"
29 #include "solist.h"
30 #include "symfile.h"
31 #include "target.h"
32 
33 #include "gdb_assert.h"
34 #include "gdb_obstack.h"
35 
36 #include "bsd-uthread.h"
37 
38 /* HACK: Save the bsd_uthreads ops returned by bsd_uthread_target.  */
39 static struct target_ops *bsd_uthread_ops_hack;
40 
41 
42 /* Architecture-specific operations.  */
43 
44 /* Per-architecture data key.  */
45 static struct gdbarch_data *bsd_uthread_data;
46 
47 struct bsd_uthread_ops
48 {
49   /* Supply registers for an inactive thread to a register cache.  */
50   void (*supply_uthread)(struct regcache *, int, CORE_ADDR);
51 
52   /* Collect registers for an inactive thread from a register cache.  */
53   void (*collect_uthread)(const struct regcache *, int, CORE_ADDR);
54 };
55 
56 static void *
57 bsd_uthread_init (struct obstack *obstack)
58 {
59   struct bsd_uthread_ops *ops;
60 
61   ops = OBSTACK_ZALLOC (obstack, struct bsd_uthread_ops);
62   return ops;
63 }
64 
65 /* Set the function that supplies registers from an inactive thread
66    for architecture GDBARCH to SUPPLY_UTHREAD.  */
67 
68 void
69 bsd_uthread_set_supply_uthread (struct gdbarch *gdbarch,
70 				void (*supply_uthread) (struct regcache *,
71 							int, CORE_ADDR))
72 {
73   struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
74   ops->supply_uthread = supply_uthread;
75 }
76 
77 /* Set the function that collects registers for an inactive thread for
78    architecture GDBARCH to SUPPLY_UTHREAD.  */
79 
80 void
81 bsd_uthread_set_collect_uthread (struct gdbarch *gdbarch,
82 			 void (*collect_uthread) (const struct regcache *,
83 						  int, CORE_ADDR))
84 {
85   struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
86   ops->collect_uthread = collect_uthread;
87 }
88 
89 /* Magic number to help recognize a valid thread structure.  */
90 #define BSD_UTHREAD_PTHREAD_MAGIC	0xd09ba115
91 
92 /* Check whether the thread structure at ADDR is valid.  */
93 
94 static void
95 bsd_uthread_check_magic (CORE_ADDR addr)
96 {
97   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
98   ULONGEST magic = read_memory_unsigned_integer (addr, 4, byte_order);
99 
100   if (magic != BSD_UTHREAD_PTHREAD_MAGIC)
101     error (_("Bad magic"));
102 }
103 
104 /* Thread states.  */
105 #define BSD_UTHREAD_PS_RUNNING	0
106 #define BSD_UTHREAD_PS_DEAD	18
107 
108 /* Address of the pointer to the thread structure for the running
109    thread.  */
110 static CORE_ADDR bsd_uthread_thread_run_addr;
111 
112 /* Address of the list of all threads.  */
113 static CORE_ADDR bsd_uthread_thread_list_addr;
114 
115 /* Offsets of various "interesting" bits in the thread structure.  */
116 static int bsd_uthread_thread_state_offset = -1;
117 static int bsd_uthread_thread_next_offset = -1;
118 static int bsd_uthread_thread_ctx_offset;
119 
120 /* Name of shared threads library.  */
121 static const char *bsd_uthread_solib_name;
122 
123 /* Non-zero if the thread startum implemented by this module is active.  */
124 static int bsd_uthread_active;
125 
126 static CORE_ADDR
127 bsd_uthread_lookup_address (const char *name, struct objfile *objfile)
128 {
129   struct minimal_symbol *sym;
130 
131   sym = lookup_minimal_symbol (name, NULL, objfile);
132   if (sym)
133     return SYMBOL_VALUE_ADDRESS (sym);
134 
135   return 0;
136 }
137 
138 static int
139 bsd_uthread_lookup_offset (const char *name, struct objfile *objfile)
140 {
141   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
142   CORE_ADDR addr;
143 
144   addr = bsd_uthread_lookup_address (name, objfile);
145   if (addr == 0)
146     return 0;
147 
148   return read_memory_unsigned_integer (addr, 4, byte_order);
149 }
150 
151 static CORE_ADDR
152 bsd_uthread_read_memory_address (CORE_ADDR addr)
153 {
154   struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
155   return read_memory_typed_address (addr, ptr_type);
156 }
157 
158 /* If OBJFILE contains the symbols corresponding to one of the
159    supported user-level threads libraries, activate the thread stratum
160    implemented by this module.  */
161 
162 static int
163 bsd_uthread_activate (struct objfile *objfile)
164 {
165   struct gdbarch *gdbarch = target_gdbarch;
166   struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
167 
168   /* Skip if the thread stratum has already been activated.  */
169   if (bsd_uthread_active)
170     return 0;
171 
172   /* There's no point in enabling this module if no
173      architecture-specific operations are provided.  */
174   if (!ops->supply_uthread)
175     return 0;
176 
177   bsd_uthread_thread_run_addr =
178     bsd_uthread_lookup_address ("_thread_run", objfile);
179   if (bsd_uthread_thread_run_addr == 0)
180     return 0;
181 
182   bsd_uthread_thread_list_addr =
183     bsd_uthread_lookup_address ("_thread_list", objfile);
184   if (bsd_uthread_thread_list_addr == 0)
185     return 0;
186 
187   bsd_uthread_thread_state_offset =
188     bsd_uthread_lookup_offset ("_thread_state_offset", objfile);
189   if (bsd_uthread_thread_state_offset == 0)
190     return 0;
191 
192   bsd_uthread_thread_next_offset =
193     bsd_uthread_lookup_offset ("_thread_next_offset", objfile);
194   if (bsd_uthread_thread_next_offset == 0)
195     return 0;
196 
197   bsd_uthread_thread_ctx_offset =
198     bsd_uthread_lookup_offset ("_thread_ctx_offset", objfile);
199 
200   push_target (bsd_uthread_ops_hack);
201   bsd_uthread_active = 1;
202   return 1;
203 }
204 
205 /* Cleanup due to deactivation.  */
206 
207 static void
208 bsd_uthread_close (int quitting)
209 {
210   bsd_uthread_active = 0;
211   bsd_uthread_thread_run_addr = 0;
212   bsd_uthread_thread_list_addr = 0;
213   bsd_uthread_thread_state_offset = 0;
214   bsd_uthread_thread_next_offset = 0;
215   bsd_uthread_thread_ctx_offset = 0;
216   bsd_uthread_solib_name = NULL;
217 }
218 
219 /* Deactivate the thread stratum implemented by this module.  */
220 
221 static void
222 bsd_uthread_deactivate (void)
223 {
224   /* Skip if the thread stratum has already been deactivated.  */
225   if (!bsd_uthread_active)
226     return;
227 
228   unpush_target (bsd_uthread_ops_hack);
229 }
230 
231 static void
232 bsd_uthread_inferior_created (struct target_ops *ops, int from_tty)
233 {
234   bsd_uthread_activate (NULL);
235 }
236 
237 /* Likely candidates for the threads library.  */
238 static const char *bsd_uthread_solib_names[] =
239 {
240   "/usr/lib/libc_r.so",		/* FreeBSD */
241   "/usr/lib/libpthread.so",	/* OpenBSD */
242   NULL
243 };
244 
245 static void
246 bsd_uthread_solib_loaded (struct so_list *so)
247 {
248   const char **names = bsd_uthread_solib_names;
249 
250   for (names = bsd_uthread_solib_names; *names; names++)
251     {
252       if (strncmp (so->so_original_name, *names, strlen (*names)) == 0)
253 	{
254 	  solib_read_symbols (so, 0);
255 
256 	  if (bsd_uthread_activate (so->objfile))
257 	    {
258 	      bsd_uthread_solib_name = so->so_original_name;
259 	      return;
260 	    }
261 	}
262     }
263 }
264 
265 static void
266 bsd_uthread_solib_unloaded (struct so_list *so)
267 {
268   if (!bsd_uthread_solib_name)
269     return;
270 
271   if (strcmp (so->so_original_name, bsd_uthread_solib_name) == 0)
272     bsd_uthread_deactivate ();
273 }
274 
275 static void
276 bsd_uthread_mourn_inferior (struct target_ops *ops)
277 {
278   struct target_ops *beneath = find_target_beneath (ops);
279   beneath->to_mourn_inferior (beneath);
280   bsd_uthread_deactivate ();
281 }
282 
283 static void
284 bsd_uthread_fetch_registers (struct target_ops *ops,
285 			     struct regcache *regcache, int regnum)
286 {
287   struct gdbarch *gdbarch = get_regcache_arch (regcache);
288   struct bsd_uthread_ops *uthread_ops = gdbarch_data (gdbarch, bsd_uthread_data);
289   CORE_ADDR addr = ptid_get_tid (inferior_ptid);
290   struct target_ops *beneath = find_target_beneath (ops);
291   CORE_ADDR active_addr;
292 
293   /* Always fetch the appropriate registers from the layer beneath.  */
294   beneath->to_fetch_registers (beneath, regcache, regnum);
295 
296   /* FIXME: That might have gotten us more than we asked for.  Make
297      sure we overwrite all relevant registers with values from the
298      thread structure.  This can go once we fix the underlying target.  */
299   regnum = -1;
300 
301   active_addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
302   if (addr != 0 && addr != active_addr)
303     {
304       bsd_uthread_check_magic (addr);
305       uthread_ops->supply_uthread (regcache, regnum,
306 				   addr + bsd_uthread_thread_ctx_offset);
307     }
308 }
309 
310 static void
311 bsd_uthread_store_registers (struct target_ops *ops,
312 			     struct regcache *regcache, int regnum)
313 {
314   struct gdbarch *gdbarch = get_regcache_arch (regcache);
315   struct bsd_uthread_ops *uthread_ops = gdbarch_data (gdbarch, bsd_uthread_data);
316   struct target_ops *beneath = find_target_beneath (ops);
317   CORE_ADDR addr = ptid_get_tid (inferior_ptid);
318   CORE_ADDR active_addr;
319 
320   active_addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
321   if (addr != 0 && addr != active_addr)
322     {
323       bsd_uthread_check_magic (addr);
324       uthread_ops->collect_uthread (regcache, regnum,
325 				    addr + bsd_uthread_thread_ctx_offset);
326     }
327   else
328     {
329       /* Updating the thread that is currently running; pass the
330          request to the layer beneath.  */
331       beneath->to_store_registers (beneath, regcache, regnum);
332     }
333 }
334 
335 /* FIXME: This function is only there because otherwise GDB tries to
336    invoke deprecate_xfer_memory.  */
337 
338 static LONGEST
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, LONGEST len)
343 {
344   gdb_assert (ops->beneath->to_xfer_partial);
345   return ops->beneath->to_xfer_partial (ops->beneath, object, annex, readbuf,
346 					writebuf, offset, len);
347 }
348 
349 static ptid_t
350 bsd_uthread_wait (struct target_ops *ops,
351 		  ptid_t ptid, struct target_waitstatus *status, int options)
352 {
353   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
354   CORE_ADDR addr;
355   struct target_ops *beneath = find_target_beneath (ops);
356 
357   /* Pass the request to the layer beneath.  */
358   ptid = beneath->to_wait (beneath, ptid, status, options);
359 
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)
364     return ptid;
365 
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);
369   if (addr != 0)
370     {
371       gdb_byte buf[4];
372 
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)
378 	{
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);
382 	}
383     }
384 
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);
391 
392   /* Don't let the core see a ptid without a corresponding thread.  */
393   if (!in_thread_list (ptid) || is_exited (ptid))
394     add_thread (ptid);
395 
396   return ptid;
397 }
398 
399 static void
400 bsd_uthread_resume (struct target_ops *ops,
401 		    ptid_t ptid, int step, enum target_signal sig)
402 {
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);
406 }
407 
408 static int
409 bsd_uthread_thread_alive (struct target_ops *ops, ptid_t ptid)
410 {
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);
414 
415   if (addr != 0)
416     {
417       int offset = bsd_uthread_thread_state_offset;
418       ULONGEST state;
419 
420       bsd_uthread_check_magic (addr);
421 
422       state = read_memory_unsigned_integer (addr + offset, 4, byte_order);
423       if (state == BSD_UTHREAD_PS_DEAD)
424 	return 0;
425     }
426 
427   return beneath->to_thread_alive (beneath, ptid);
428 }
429 
430 static void
431 bsd_uthread_find_new_threads (struct target_ops *ops)
432 {
433   pid_t pid = ptid_get_pid (inferior_ptid);
434   int offset = bsd_uthread_thread_next_offset;
435   CORE_ADDR addr;
436 
437   addr = bsd_uthread_read_memory_address (bsd_uthread_thread_list_addr);
438   while (addr != 0)
439     {
440       ptid_t ptid = ptid_build (pid, 0, addr);
441 
442       if (!in_thread_list (ptid) || is_exited (ptid))
443 	{
444 	  /* If INFERIOR_PTID doesn't have a tid member yet, then ptid
445 	     is still the initial thread of the process.  Notify GDB
446 	     core about it.  */
447 	  if (ptid_get_tid (inferior_ptid) == 0)
448 	    thread_change_ptid (inferior_ptid, ptid);
449 	  else
450 	    add_thread (ptid);
451 	}
452 
453       addr = bsd_uthread_read_memory_address (addr + offset);
454     }
455 }
456 
457 /* Possible states a thread can be in.  */
458 static char *bsd_uthread_state[] =
459 {
460   "RUNNING",
461   "SIGTHREAD",
462   "MUTEX_WAIT",
463   "COND_WAIT",
464   "FDLR_WAIT",
465   "FDLW_WAIT",
466   "FDR_WAIT",
467   "FDW_WAIT",
468   "FILE_WAIT",
469   "POLL_WAIT",
470   "SELECT_WAIT",
471   "SLEEP_WAIT",
472   "WAIT_WAIT",
473   "SIGSUSPEND",
474   "SIGWAIT",
475   "SPINBLOCK",
476   "JOIN",
477   "SUSPENDED",
478   "DEAD",
479   "DEADLOCK"
480 };
481 
482 /* Return a string describing th state of the thread specified by
483    INFO.  */
484 
485 static char *
486 bsd_uthread_extra_thread_info (struct thread_info *info)
487 {
488   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
489   CORE_ADDR addr = ptid_get_tid (info->ptid);
490 
491   if (addr != 0)
492     {
493       int offset = bsd_uthread_thread_state_offset;
494       ULONGEST state;
495 
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];
499     }
500 
501   return NULL;
502 }
503 
504 static char *
505 bsd_uthread_pid_to_str (struct target_ops *ops, ptid_t ptid)
506 {
507   if (ptid_get_tid (ptid) != 0)
508     {
509       static char buf[64];
510 
511       xsnprintf (buf, sizeof buf, "process %d, thread 0x%lx",
512 		 ptid_get_pid (ptid), ptid_get_tid (ptid));
513       return buf;
514     }
515 
516   return normal_pid_to_str (ptid);
517 }
518 
519 static struct target_ops *
520 bsd_uthread_target (void)
521 {
522   struct target_ops *t = XZALLOC (struct target_ops);
523 
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;
541 
542   return t;
543 }
544 
545 /* Provide a prototype to silence -Wmissing-prototypes.  */
546 extern initialize_file_ftype _initialize_bsd_uthread;
547 
548 void
549 _initialize_bsd_uthread (void)
550 {
551   add_target (bsd_uthread_target ());
552 
553   bsd_uthread_data = gdbarch_data_register_pre_init (bsd_uthread_init);
554 
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);
558 }
559