[thirdparty/binutils-gdb.git] / gdb / bsd-uthread.c

/* BSD user-level threads support.

   Copyright (C) 2005-2014 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "gdbcore.h"
#include "gdbthread.h"
#include "inferior.h"
#include "objfiles.h"
#include "observer.h"
#include "regcache.h"
#include "solib.h"
#include "solist.h"
#include "symfile.h"
#include "target.h"

#include "gdb_assert.h"
#include "gdb_obstack.h"

#include "bsd-uthread.h"

/* HACK: Save the bsd_uthreads ops returned by bsd_uthread_target.  */
static struct target_ops *bsd_uthread_ops_hack;
\f

/* Architecture-specific operations.  */

/* Per-architecture data key.  */
static struct gdbarch_data *bsd_uthread_data;

struct bsd_uthread_ops
{
  /* Supply registers for an inactive thread to a register cache.  */
  void (*supply_uthread)(struct regcache *, int, CORE_ADDR);

  /* Collect registers for an inactive thread from a register cache.  */
  void (*collect_uthread)(const struct regcache *, int, CORE_ADDR);
};

static void *
bsd_uthread_init (struct obstack *obstack)
{
  struct bsd_uthread_ops *ops;

  ops = OBSTACK_ZALLOC (obstack, struct bsd_uthread_ops);
  return ops;
}

/* Set the function that supplies registers from an inactive thread
   for architecture GDBARCH to SUPPLY_UTHREAD.  */

void
bsd_uthread_set_supply_uthread (struct gdbarch *gdbarch,
				void (*supply_uthread) (struct regcache *,
							int, CORE_ADDR))
{
  struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
  ops->supply_uthread = supply_uthread;
}

/* Set the function that collects registers for an inactive thread for
   architecture GDBARCH to SUPPLY_UTHREAD.  */

void
bsd_uthread_set_collect_uthread (struct gdbarch *gdbarch,
			 void (*collect_uthread) (const struct regcache *,
						  int, CORE_ADDR))
{
  struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
  ops->collect_uthread = collect_uthread;
}

/* Magic number to help recognize a valid thread structure.  */
#define BSD_UTHREAD_PTHREAD_MAGIC	0xd09ba115

/* Check whether the thread structure at ADDR is valid.  */

static void
bsd_uthread_check_magic (CORE_ADDR addr)
{
  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  ULONGEST magic = read_memory_unsigned_integer (addr, 4, byte_order);

  if (magic != BSD_UTHREAD_PTHREAD_MAGIC)
    error (_("Bad magic"));
}

/* Thread states.  */
#define BSD_UTHREAD_PS_RUNNING	0
#define BSD_UTHREAD_PS_DEAD	18

/* Address of the pointer to the thread structure for the running
   thread.  */
static CORE_ADDR bsd_uthread_thread_run_addr;

/* Address of the list of all threads.  */
static CORE_ADDR bsd_uthread_thread_list_addr;

/* Offsets of various "interesting" bits in the thread structure.  */
static int bsd_uthread_thread_state_offset = -1;
static int bsd_uthread_thread_next_offset = -1;
static int bsd_uthread_thread_ctx_offset;

/* Name of shared threads library.  */
static const char *bsd_uthread_solib_name;

/* Non-zero if the thread startum implemented by this module is active.  */
static int bsd_uthread_active;

static CORE_ADDR
bsd_uthread_lookup_address (const char *name, struct objfile *objfile)
{
  struct bound_minimal_symbol sym;

  sym = lookup_minimal_symbol (name, NULL, objfile);
  if (sym.minsym)
    return MSYMBOL_VALUE_ADDRESS (sym.minsym);

  return 0;
}

static int
bsd_uthread_lookup_offset (const char *name, struct objfile *objfile)
{
  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  CORE_ADDR addr;

  addr = bsd_uthread_lookup_address (name, objfile);
  if (addr == 0)
    return 0;

  return read_memory_unsigned_integer (addr, 4, byte_order);
}

static CORE_ADDR
bsd_uthread_read_memory_address (CORE_ADDR addr)
{
  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
  return read_memory_typed_address (addr, ptr_type);
}

/* If OBJFILE contains the symbols corresponding to one of the
   supported user-level threads libraries, activate the thread stratum
   implemented by this module.  */

static int
bsd_uthread_activate (struct objfile *objfile)
{
  struct gdbarch *gdbarch = target_gdbarch ();
  struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);

  /* Skip if the thread stratum has already been activated.  */
  if (bsd_uthread_active)
    return 0;

  /* There's no point in enabling this module if no
     architecture-specific operations are provided.  */
  if (!ops->supply_uthread)
    return 0;

  bsd_uthread_thread_run_addr =
    bsd_uthread_lookup_address ("_thread_run", objfile);
  if (bsd_uthread_thread_run_addr == 0)
    return 0;

  bsd_uthread_thread_list_addr =
    bsd_uthread_lookup_address ("_thread_list", objfile);
  if (bsd_uthread_thread_list_addr == 0)
    return 0;

  bsd_uthread_thread_state_offset =
    bsd_uthread_lookup_offset ("_thread_state_offset", objfile);
  if (bsd_uthread_thread_state_offset == 0)
    return 0;

  bsd_uthread_thread_next_offset =
    bsd_uthread_lookup_offset ("_thread_next_offset", objfile);
  if (bsd_uthread_thread_next_offset == 0)
    return 0;

  bsd_uthread_thread_ctx_offset =
    bsd_uthread_lookup_offset ("_thread_ctx_offset", objfile);

  push_target (bsd_uthread_ops_hack);
  bsd_uthread_active = 1;
  return 1;
}

/* Cleanup due to deactivation.  */

static void
bsd_uthread_close (struct target_ops *self)
{
  bsd_uthread_active = 0;
  bsd_uthread_thread_run_addr = 0;
  bsd_uthread_thread_list_addr = 0;
  bsd_uthread_thread_state_offset = 0;
  bsd_uthread_thread_next_offset = 0;
  bsd_uthread_thread_ctx_offset = 0;
  bsd_uthread_solib_name = NULL;
}

/* Deactivate the thread stratum implemented by this module.  */

static void
bsd_uthread_deactivate (void)
{
  /* Skip if the thread stratum has already been deactivated.  */
  if (!bsd_uthread_active)
    return;

  unpush_target (bsd_uthread_ops_hack);
}

static void
bsd_uthread_inferior_created (struct target_ops *ops, int from_tty)
{
  bsd_uthread_activate (NULL);
}

/* Likely candidates for the threads library.  */
static const char *bsd_uthread_solib_names[] =
{
  "/usr/lib/libc_r.so",		/* FreeBSD */
  "/usr/lib/libpthread.so",	/* OpenBSD */
  NULL
};

static void
bsd_uthread_solib_loaded (struct so_list *so)
{
  const char **names = bsd_uthread_solib_names;

  for (names = bsd_uthread_solib_names; *names; names++)
    {
      if (strncmp (so->so_original_name, *names, strlen (*names)) == 0)
	{
	  solib_read_symbols (so, 0);

	  if (bsd_uthread_activate (so->objfile))
	    {
	      bsd_uthread_solib_name = so->so_original_name;
	      return;
	    }
	}
    }
}

static void
bsd_uthread_solib_unloaded (struct so_list *so)
{
  if (!bsd_uthread_solib_name)
    return;

  if (strcmp (so->so_original_name, bsd_uthread_solib_name) == 0)
    bsd_uthread_deactivate ();
}

static void
bsd_uthread_mourn_inferior (struct target_ops *ops)
{
  struct target_ops *beneath = find_target_beneath (ops);
  beneath->to_mourn_inferior (beneath);
  bsd_uthread_deactivate ();
}

static void
bsd_uthread_fetch_registers (struct target_ops *ops,
			     struct regcache *regcache, int regnum)
{
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
  struct bsd_uthread_ops *uthread_ops = gdbarch_data (gdbarch, bsd_uthread_data);
  CORE_ADDR addr = ptid_get_tid (inferior_ptid);
  struct target_ops *beneath = find_target_beneath (ops);
  CORE_ADDR active_addr;

  /* Always fetch the appropriate registers from the layer beneath.  */
  beneath->to_fetch_registers (beneath, regcache, regnum);

  /* FIXME: That might have gotten us more than we asked for.  Make
     sure we overwrite all relevant registers with values from the
     thread structure.  This can go once we fix the underlying target.  */
  regnum = -1;

  active_addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
  if (addr != 0 && addr != active_addr)
    {
      bsd_uthread_check_magic (addr);
      uthread_ops->supply_uthread (regcache, regnum,
				   addr + bsd_uthread_thread_ctx_offset);
    }
}

static void
bsd_uthread_store_registers (struct target_ops *ops,
			     struct regcache *regcache, int regnum)
{
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
  struct bsd_uthread_ops *uthread_ops = gdbarch_data (gdbarch, bsd_uthread_data);
  struct target_ops *beneath = find_target_beneath (ops);
  CORE_ADDR addr = ptid_get_tid (inferior_ptid);
  CORE_ADDR active_addr;

  active_addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
  if (addr != 0 && addr != active_addr)
    {
      bsd_uthread_check_magic (addr);
      uthread_ops->collect_uthread (regcache, regnum,
				    addr + bsd_uthread_thread_ctx_offset);
    }
  else
    {
      /* Updating the thread that is currently running; pass the
         request to the layer beneath.  */
      beneath->to_store_registers (beneath, regcache, regnum);
    }
}

static ptid_t
bsd_uthread_wait (struct target_ops *ops,
		  ptid_t ptid, struct target_waitstatus *status, int options)
{
  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  CORE_ADDR addr;
  struct target_ops *beneath = find_target_beneath (ops);

  /* Pass the request to the layer beneath.  */
  ptid = beneath->to_wait (beneath, ptid, status, options);

  /* If the process is no longer alive, there's no point in figuring
     out the thread ID.  It will fail anyway.  */
  if (status->kind == TARGET_WAITKIND_SIGNALLED
      || status->kind == TARGET_WAITKIND_EXITED)
    return ptid;

  /* Fetch the corresponding thread ID, and augment the returned
     process ID with it.  */
  addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
  if (addr != 0)
    {
      gdb_byte buf[4];

      /* FIXME: For executables linked statically with the threads
         library, we end up here before the program has actually been
         executed.  In that case ADDR will be garbage since it has
         been read from the wrong virtual memory image.  */
      if (target_read_memory (addr, buf, 4) == 0)
	{
	  ULONGEST magic = extract_unsigned_integer (buf, 4, byte_order);
	  if (magic == BSD_UTHREAD_PTHREAD_MAGIC)
	    ptid = ptid_build (ptid_get_pid (ptid), 0, addr);
	}
    }

  /* If INFERIOR_PTID doesn't have a tid member yet, and we now have a
     ptid with tid set, then ptid is still the initial thread of
     the process.  Notify GDB core about it.  */
  if (ptid_get_tid (inferior_ptid) == 0
      && ptid_get_tid (ptid) != 0 && !in_thread_list (ptid))
    thread_change_ptid (inferior_ptid, ptid);

  /* Don't let the core see a ptid without a corresponding thread.  */
  if (!in_thread_list (ptid) || is_exited (ptid))
    add_thread (ptid);

  return ptid;
}

static void
bsd_uthread_resume (struct target_ops *ops,
		    ptid_t ptid, int step, enum gdb_signal sig)
{
  /* Pass the request to the layer beneath.  */
  struct target_ops *beneath = find_target_beneath (ops);
  beneath->to_resume (beneath, ptid, step, sig);
}

static int
bsd_uthread_thread_alive (struct target_ops *ops, ptid_t ptid)
{
  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  struct target_ops *beneath = find_target_beneath (ops);
  CORE_ADDR addr = ptid_get_tid (inferior_ptid);

  if (addr != 0)
    {
      int offset = bsd_uthread_thread_state_offset;
      ULONGEST state;

      bsd_uthread_check_magic (addr);

      state = read_memory_unsigned_integer (addr + offset, 4, byte_order);
      if (state == BSD_UTHREAD_PS_DEAD)
	return 0;
    }

  return beneath->to_thread_alive (beneath, ptid);
}

static void
bsd_uthread_find_new_threads (struct target_ops *ops)
{
  pid_t pid = ptid_get_pid (inferior_ptid);
  int offset = bsd_uthread_thread_next_offset;
  CORE_ADDR addr;

  addr = bsd_uthread_read_memory_address (bsd_uthread_thread_list_addr);
  while (addr != 0)
    {
      ptid_t ptid = ptid_build (pid, 0, addr);

      if (!in_thread_list (ptid) || is_exited (ptid))
	{
	  /* If INFERIOR_PTID doesn't have a tid member yet, then ptid
	     is still the initial thread of the process.  Notify GDB
	     core about it.  */
	  if (ptid_get_tid (inferior_ptid) == 0)
	    thread_change_ptid (inferior_ptid, ptid);
	  else
	    add_thread (ptid);
	}

      addr = bsd_uthread_read_memory_address (addr + offset);
    }
}

/* Possible states a thread can be in.  */
static char *bsd_uthread_state[] =
{
  "RUNNING",
  "SIGTHREAD",
  "MUTEX_WAIT",
  "COND_WAIT",
  "FDLR_WAIT",
  "FDLW_WAIT",
  "FDR_WAIT",
  "FDW_WAIT",
  "FILE_WAIT",
  "POLL_WAIT",
  "SELECT_WAIT",
  "SLEEP_WAIT",
  "WAIT_WAIT",
  "SIGSUSPEND",
  "SIGWAIT",
  "SPINBLOCK",
  "JOIN",
  "SUSPENDED",
  "DEAD",
  "DEADLOCK"
};

/* Return a string describing th state of the thread specified by
   INFO.  */

static char *
bsd_uthread_extra_thread_info (struct target_ops *self,
			       struct thread_info *info)
{
  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  CORE_ADDR addr = ptid_get_tid (info->ptid);

  if (addr != 0)
    {
      int offset = bsd_uthread_thread_state_offset;
      ULONGEST state;

      state = read_memory_unsigned_integer (addr + offset, 4, byte_order);
      if (state < ARRAY_SIZE (bsd_uthread_state))
	return bsd_uthread_state[state];
    }

  return NULL;
}

static char *
bsd_uthread_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
  if (ptid_get_tid (ptid) != 0)
    {
      static char buf[64];

      xsnprintf (buf, sizeof buf, "process %d, thread 0x%lx",
		 ptid_get_pid (ptid), ptid_get_tid (ptid));
      return buf;
    }

  return normal_pid_to_str (ptid);
}

static struct target_ops *
bsd_uthread_target (void)
{
  struct target_ops *t = XCNEW (struct target_ops);

  t->to_shortname = "bsd-uthreads";
  t->to_longname = "BSD user-level threads";
  t->to_doc = "BSD user-level threads";
  t->to_close = bsd_uthread_close;
  t->to_mourn_inferior = bsd_uthread_mourn_inferior;
  t->to_fetch_registers = bsd_uthread_fetch_registers;
  t->to_store_registers = bsd_uthread_store_registers;
  t->to_wait = bsd_uthread_wait;
  t->to_resume = bsd_uthread_resume;
  t->to_thread_alive = bsd_uthread_thread_alive;
  t->to_find_new_threads = bsd_uthread_find_new_threads;
  t->to_extra_thread_info = bsd_uthread_extra_thread_info;
  t->to_pid_to_str = bsd_uthread_pid_to_str;
  t->to_stratum = thread_stratum;
  t->to_magic = OPS_MAGIC;
  bsd_uthread_ops_hack = t;

  return t;
}

/* Provide a prototype to silence -Wmissing-prototypes.  */
extern initialize_file_ftype _initialize_bsd_uthread;

void
_initialize_bsd_uthread (void)
{
  complete_target_initialization (bsd_uthread_target ());

  bsd_uthread_data = gdbarch_data_register_pre_init (bsd_uthread_init);

  observer_attach_inferior_created (bsd_uthread_inferior_created);
  observer_attach_solib_loaded (bsd_uthread_solib_loaded);
  observer_attach_solib_unloaded (bsd_uthread_solib_unloaded);
}
Commit	Line	Data
82f5c14f MK	1	/* BSD user-level threads support.
82f5c14f MK	2
ecd75fc8	3	Copyright (C) 2005-2014 Free Software Foundation, Inc.
82f5c14f MK	4
	5	This file is part of GDB.
	6
	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
a9762ec7	9	the Free Software Foundation; either version 3 of the License, or
82f5c14f MK	10	(at your option) any later version.
	11
	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.
	16
	17	You should have received a copy of the GNU General Public License
a9762ec7	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
82f5c14f MK	19
	20	#include "defs.h"
	21	#include "gdbcore.h"
	22	#include "gdbthread.h"
	23	#include "inferior.h"
	24	#include "objfiles.h"
	25	#include "observer.h"
	26	#include "regcache.h"
5ebc08b0	27	#include "solib.h"
82f5c14f MK	28	#include "solist.h"
	29	#include "symfile.h"
	30	#include "target.h"
	31
	32	#include "gdb_assert.h"
	33	#include "gdb_obstack.h"
	34
	35	#include "bsd-uthread.h"
	36
	37	/* HACK: Save the bsd_uthreads ops returned by bsd_uthread_target. */
	38	static struct target_ops *bsd_uthread_ops_hack;
	39	\f
	40
	41	/* Architecture-specific operations. */
	42
	43	/* Per-architecture data key. */
	44	static struct gdbarch_data *bsd_uthread_data;
	45
	46	struct bsd_uthread_ops
	47	{
	48	/* Supply registers for an inactive thread to a register cache. */
	49	void (supply_uthread)(struct regcache , int, CORE_ADDR);
	50
	51	/* Collect registers for an inactive thread from a register cache. */
	52	void (collect_uthread)(const struct regcache , int, CORE_ADDR);
	53	};
	54
	55	static void *
	56	bsd_uthread_init (struct obstack *obstack)
	57	{
	58	struct bsd_uthread_ops *ops;
	59
	60	ops = OBSTACK_ZALLOC (obstack, struct bsd_uthread_ops);
	61	return ops;
	62	}
	63
	64	/* Set the function that supplies registers from an inactive thread
	65	for architecture GDBARCH to SUPPLY_UTHREAD. */
	66
	67	void
	68	bsd_uthread_set_supply_uthread (struct gdbarch *gdbarch,
	69	void (supply_uthread) (struct regcache ,
	70	int, CORE_ADDR))
	71	{
	72	struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
	73	ops->supply_uthread = supply_uthread;
	74	}
	75
	76	/* Set the function that collects registers for an inactive thread for
	77	architecture GDBARCH to SUPPLY_UTHREAD. */
	78
	79	void
	80	bsd_uthread_set_collect_uthread (struct gdbarch *gdbarch,
	81	void (collect_uthread) (const struct regcache ,
	82	int, CORE_ADDR))
	83	{
	84	struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
	85	ops->collect_uthread = collect_uthread;
	86	}
	87
	88	/* Magic number to help recognize a valid thread structure. */
	89	#define BSD_UTHREAD_PTHREAD_MAGIC 0xd09ba115
	90
	91	/* Check whether the thread structure at ADDR is valid. */
92
93	static void
94	bsd_uthread_check_magic (CORE_ADDR addr)
95	{
f5656ead	96	enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
e17a4113	97	ULONGEST magic = read_memory_unsigned_integer (addr, 4, byte_order);
82f5c14f MK	98
82f5c14f MK	99	if (magic != BSD_UTHREAD_PTHREAD_MAGIC)
8a3fe4f8	100	error (_("Bad magic"));
82f5c14f MK	101	}
	102
	103	/* Thread states. */
	104	#define BSD_UTHREAD_PS_RUNNING 0
	105	#define BSD_UTHREAD_PS_DEAD 18
	106
b021a221	107	/* Address of the pointer to the thread structure for the running
82f5c14f MK	108	thread. */
	109	static CORE_ADDR bsd_uthread_thread_run_addr;
	110
	111	/* Address of the list of all threads. */
	112	static CORE_ADDR bsd_uthread_thread_list_addr;
	113
	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;
	118
	119	/* Name of shared threads library. */
	120	static const char *bsd_uthread_solib_name;
	121
	122	/* Non-zero if the thread startum implemented by this module is active. */
	123	static int bsd_uthread_active;
	124
	125	static CORE_ADDR
	126	bsd_uthread_lookup_address (const char name, struct objfile objfile)
	127	{
3b7344d5	128	struct bound_minimal_symbol sym;
82f5c14f MK	129
82f5c14f MK	130	sym = lookup_minimal_symbol (name, NULL, objfile);
3b7344d5 TT	131	if (sym.minsym)
3b7344d5 TT	132	return MSYMBOL_VALUE_ADDRESS (sym.minsym);
82f5c14f MK	133
	134	return 0;
	135	}
	136
	137	static int
	138	bsd_uthread_lookup_offset (const char name, struct objfile objfile)
	139	{
f5656ead	140	enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
82f5c14f MK	141	CORE_ADDR addr;
	142
	143	addr = bsd_uthread_lookup_address (name, objfile);
	144	if (addr == 0)
	145	return 0;
	146
e17a4113	147	return read_memory_unsigned_integer (addr, 4, byte_order);
82f5c14f MK	148	}
82f5c14f MK	149
ff7da468 UW	150	static CORE_ADDR
	151	bsd_uthread_read_memory_address (CORE_ADDR addr)
	152	{
f5656ead	153	struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
ff7da468 UW	154	return read_memory_typed_address (addr, ptr_type);
	155	}
	156
82f5c14f MK	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. */
	160
	161	static int
	162	bsd_uthread_activate (struct objfile *objfile)
	163	{
f5656ead	164	struct gdbarch *gdbarch = target_gdbarch ();
82f5c14f MK	165	struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
	166
	167	/* Skip if the thread stratum has already been activated. */
	168	if (bsd_uthread_active)
	169	return 0;
	170
	171	/* There's no point in enabling this module if no
	172	architecture-specific operations are provided. */
	173	if (!ops->supply_uthread)
	174	return 0;
	175
	176	bsd_uthread_thread_run_addr =
	177	bsd_uthread_lookup_address ("_thread_run", objfile);
	178	if (bsd_uthread_thread_run_addr == 0)
	179	return 0;
	180
	181	bsd_uthread_thread_list_addr =
	182	bsd_uthread_lookup_address ("_thread_list", objfile);
	183	if (bsd_uthread_thread_list_addr == 0)
	184	return 0;
	185
	186	bsd_uthread_thread_state_offset =
	187	bsd_uthread_lookup_offset ("_thread_state_offset", objfile);
	188	if (bsd_uthread_thread_state_offset == 0)
	189	return 0;
	190
	191	bsd_uthread_thread_next_offset =
	192	bsd_uthread_lookup_offset ("_thread_next_offset", objfile);
	193	if (bsd_uthread_thread_next_offset == 0)
	194	return 0;
	195
	196	bsd_uthread_thread_ctx_offset =
	197	bsd_uthread_lookup_offset ("_thread_ctx_offset", objfile);
	198
	199	push_target (bsd_uthread_ops_hack);
	200	bsd_uthread_active = 1;
	201	return 1;
	202	}
	203
39540081	204	/* Cleanup due to deactivation. */
82f5c14f MK	205
82f5c14f MK	206	static void
de90e03d	207	bsd_uthread_close (struct target_ops *self)
82f5c14f	208	{
82f5c14f	209	bsd_uthread_active = 0;
82f5c14f MK	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;
	216	}
	217
39540081 PA	218	/* Deactivate the thread stratum implemented by this module. */
	219
	220	static void
	221	bsd_uthread_deactivate (void)
	222	{
	223	/* Skip if the thread stratum has already been deactivated. */
	224	if (!bsd_uthread_active)
	225	return;
	226
	227	unpush_target (bsd_uthread_ops_hack);
	228	}
	229
63807e1d	230	static void
82f5c14f MK	231	bsd_uthread_inferior_created (struct target_ops *ops, int from_tty)
	232	{
	233	bsd_uthread_activate (NULL);
	234	}
	235
	236	/* Likely candidates for the threads library. */
	237	static const char *bsd_uthread_solib_names[] =
	238	{
	239	"/usr/lib/libc_r.so", /* FreeBSD */
	240	"/usr/lib/libpthread.so", /* OpenBSD */
	241	NULL
	242	};
	243
63807e1d	244	static void
82f5c14f MK	245	bsd_uthread_solib_loaded (struct so_list *so)
	246	{
	247	const char **names = bsd_uthread_solib_names;
	248
	249	for (names = bsd_uthread_solib_names; *names; names++)
	250	{
	251	if (strncmp (so->so_original_name, names, strlen (names)) == 0)
	252	{
048d532d	253	solib_read_symbols (so, 0);
82f5c14f MK	254
	255	if (bsd_uthread_activate (so->objfile))
	256	{
39540081	257	bsd_uthread_solib_name = so->so_original_name;
82f5c14f MK	258	return;
	259	}
	260	}
	261	}
	262	}
	263
63807e1d	264	static void
82f5c14f MK	265	bsd_uthread_solib_unloaded (struct so_list *so)
	266	{
	267	if (!bsd_uthread_solib_name)
	268	return;
	269
	270	if (strcmp (so->so_original_name, bsd_uthread_solib_name) == 0)
	271	bsd_uthread_deactivate ();
	272	}
	273
	274	static void
136d6dae	275	bsd_uthread_mourn_inferior (struct target_ops *ops)
82f5c14f	276	{
28439f5e	277	struct target_ops *beneath = find_target_beneath (ops);
136d6dae	278	beneath->to_mourn_inferior (beneath);
82f5c14f MK	279	bsd_uthread_deactivate ();
	280	}
	281
	282	static void
28439f5e PA	283	bsd_uthread_fetch_registers (struct target_ops *ops,
28439f5e PA	284	struct regcache *regcache, int regnum)
82f5c14f	285	{
27524c05	286	struct gdbarch *gdbarch = get_regcache_arch (regcache);
28439f5e	287	struct bsd_uthread_ops *uthread_ops = gdbarch_data (gdbarch, bsd_uthread_data);
82f5c14f	288	CORE_ADDR addr = ptid_get_tid (inferior_ptid);
28439f5e	289	struct target_ops *beneath = find_target_beneath (ops);
82f5c14f MK	290	CORE_ADDR active_addr;
	291
	292	/* Always fetch the appropriate registers from the layer beneath. */
28439f5e	293	beneath->to_fetch_registers (beneath, regcache, regnum);
82f5c14f MK	294
	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. */
	298	regnum = -1;
	299
ff7da468	300	active_addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
82f5c14f MK	301	if (addr != 0 && addr != active_addr)
	302	{
	303	bsd_uthread_check_magic (addr);
28439f5e PA	304	uthread_ops->supply_uthread (regcache, regnum,
28439f5e PA	305	addr + bsd_uthread_thread_ctx_offset);
82f5c14f MK	306	}
	307	}
	308
	309	static void
28439f5e PA	310	bsd_uthread_store_registers (struct target_ops *ops,
28439f5e PA	311	struct regcache *regcache, int regnum)
82f5c14f	312	{
27524c05	313	struct gdbarch *gdbarch = get_regcache_arch (regcache);
28439f5e PA	314	struct bsd_uthread_ops *uthread_ops = gdbarch_data (gdbarch, bsd_uthread_data);
28439f5e PA	315	struct target_ops *beneath = find_target_beneath (ops);
82f5c14f MK	316	CORE_ADDR addr = ptid_get_tid (inferior_ptid);
	317	CORE_ADDR active_addr;
	318
ff7da468	319	active_addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
82f5c14f MK	320	if (addr != 0 && addr != active_addr)
	321	{
	322	bsd_uthread_check_magic (addr);
28439f5e PA	323	uthread_ops->collect_uthread (regcache, regnum,
28439f5e PA	324	addr + bsd_uthread_thread_ctx_offset);
82f5c14f MK	325	}
	326	else
	327	{
	328	/* Updating the thread that is currently running; pass the
	329	request to the layer beneath. */
28439f5e	330	beneath->to_store_registers (beneath, regcache, regnum);
82f5c14f MK	331	}
	332	}
	333
82f5c14f	334	static ptid_t
117de6a9	335	bsd_uthread_wait (struct target_ops *ops,
47608cb1	336	ptid_t ptid, struct target_waitstatus *status, int options)
82f5c14f	337	{
f5656ead	338	enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
82f5c14f	339	CORE_ADDR addr;
28439f5e	340	struct target_ops *beneath = find_target_beneath (ops);
82f5c14f MK	341
82f5c14f MK	342	/* Pass the request to the layer beneath. */
47608cb1	343	ptid = beneath->to_wait (beneath, ptid, status, options);
82f5c14f	344
a4e7b2e7 MK	345	/* If the process is no longer alive, there's no point in figuring
	346	out the thread ID. It will fail anyway. */
	347	if (status->kind == TARGET_WAITKIND_SIGNALLED
	348	\|\| status->kind == TARGET_WAITKIND_EXITED)
	349	return ptid;
	350
82f5c14f MK	351	/* Fetch the corresponding thread ID, and augment the returned
82f5c14f MK	352	process ID with it. */
ff7da468	353	addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
82f5c14f MK	354	if (addr != 0)
82f5c14f MK	355	{
df80278b	356	gdb_byte buf[4];
82f5c14f MK	357
	358	/* FIXME: For executables linked statically with the threads
	359	library, we end up here before the program has actually been
	360	executed. In that case ADDR will be garbage since it has
	361	been read from the wrong virtual memory image. */
	362	if (target_read_memory (addr, buf, 4) == 0)
	363	{
e17a4113	364	ULONGEST magic = extract_unsigned_integer (buf, 4, byte_order);
82f5c14f MK	365	if (magic == BSD_UTHREAD_PTHREAD_MAGIC)
	366	ptid = ptid_build (ptid_get_pid (ptid), 0, addr);
	367	}
	368	}
	369
fb5e7258 PA	370	/* If INFERIOR_PTID doesn't have a tid member yet, and we now have a
	371	ptid with tid set, then ptid is still the initial thread of
	372	the process. Notify GDB core about it. */
	373	if (ptid_get_tid (inferior_ptid) == 0
	374	&& ptid_get_tid (ptid) != 0 && !in_thread_list (ptid))
	375	thread_change_ptid (inferior_ptid, ptid);
	376
	377	/* Don't let the core see a ptid without a corresponding thread. */
	378	if (!in_thread_list (ptid) \|\| is_exited (ptid))
	379	add_thread (ptid);
82f5c14f MK	380
	381	return ptid;
	382	}
	383
	384	static void
28439f5e	385	bsd_uthread_resume (struct target_ops *ops,
2ea28649	386	ptid_t ptid, int step, enum gdb_signal sig)
82f5c14f MK	387	{
82f5c14f MK	388	/* Pass the request to the layer beneath. */
28439f5e PA	389	struct target_ops *beneath = find_target_beneath (ops);
28439f5e PA	390	beneath->to_resume (beneath, ptid, step, sig);
82f5c14f MK	391	}
	392
	393	static int
28439f5e	394	bsd_uthread_thread_alive (struct target_ops *ops, ptid_t ptid)
82f5c14f	395	{
f5656ead	396	enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
28439f5e	397	struct target_ops *beneath = find_target_beneath (ops);
82f5c14f MK	398	CORE_ADDR addr = ptid_get_tid (inferior_ptid);
	399
	400	if (addr != 0)
	401	{
	402	int offset = bsd_uthread_thread_state_offset;
	403	ULONGEST state;
	404
	405	bsd_uthread_check_magic (addr);
	406
e17a4113	407	state = read_memory_unsigned_integer (addr + offset, 4, byte_order);
82f5c14f MK	408	if (state == BSD_UTHREAD_PS_DEAD)
	409	return 0;
	410	}
	411
28439f5e	412	return beneath->to_thread_alive (beneath, ptid);
82f5c14f MK	413	}
	414
	415	static void
28439f5e	416	bsd_uthread_find_new_threads (struct target_ops *ops)
82f5c14f MK	417	{
	418	pid_t pid = ptid_get_pid (inferior_ptid);
	419	int offset = bsd_uthread_thread_next_offset;
	420	CORE_ADDR addr;
	421
ff7da468	422	addr = bsd_uthread_read_memory_address (bsd_uthread_thread_list_addr);
82f5c14f MK	423	while (addr != 0)
	424	{
	425	ptid_t ptid = ptid_build (pid, 0, addr);
	426
fb5e7258	427	if (!in_thread_list (ptid) \|\| is_exited (ptid))
757f359d PA	428	{
	429	/* If INFERIOR_PTID doesn't have a tid member yet, then ptid
	430	is still the initial thread of the process. Notify GDB
	431	core about it. */
	432	if (ptid_get_tid (inferior_ptid) == 0)
	433	thread_change_ptid (inferior_ptid, ptid);
	434	else
	435	add_thread (ptid);
	436	}
82f5c14f	437
ff7da468	438	addr = bsd_uthread_read_memory_address (addr + offset);
82f5c14f MK	439	}
	440	}
	441
	442	/* Possible states a thread can be in. */
	443	static char *bsd_uthread_state[] =
	444	{
	445	"RUNNING",
	446	"SIGTHREAD",
	447	"MUTEX_WAIT",
	448	"COND_WAIT",
	449	"FDLR_WAIT",
	450	"FDLW_WAIT",
	451	"FDR_WAIT",
	452	"FDW_WAIT",
	453	"FILE_WAIT",
	454	"POLL_WAIT",
	455	"SELECT_WAIT",
	456	"SLEEP_WAIT",
	457	"WAIT_WAIT",
	458	"SIGSUSPEND",
	459	"SIGWAIT",
	460	"SPINBLOCK",
	461	"JOIN",
	462	"SUSPENDED",
	463	"DEAD",
	464	"DEADLOCK"
	465	};
	466
	467	/* Return a string describing th state of the thread specified by
	468	INFO. */
	469
	470	static char *
c15906d8 TT	471	bsd_uthread_extra_thread_info (struct target_ops *self,
c15906d8 TT	472	struct thread_info *info)
82f5c14f	473	{
f5656ead	474	enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
82f5c14f MK	475	CORE_ADDR addr = ptid_get_tid (info->ptid);
	476
	477	if (addr != 0)
	478	{
	479	int offset = bsd_uthread_thread_state_offset;
	480	ULONGEST state;
	481
e17a4113	482	state = read_memory_unsigned_integer (addr + offset, 4, byte_order);
82f5c14f MK	483	if (state < ARRAY_SIZE (bsd_uthread_state))
	484	return bsd_uthread_state[state];
	485	}
	486
	487	return NULL;
	488	}
	489
	490	static char *
117de6a9	491	bsd_uthread_pid_to_str (struct target_ops *ops, ptid_t ptid)
82f5c14f MK	492	{
	493	if (ptid_get_tid (ptid) != 0)
	494	{
	495	static char buf[64];
82f5c14f	496
5fff8fc0 MK	497	xsnprintf (buf, sizeof buf, "process %d, thread 0x%lx",
5fff8fc0 MK	498	ptid_get_pid (ptid), ptid_get_tid (ptid));
82f5c14f MK	499	return buf;
	500	}
	501
	502	return normal_pid_to_str (ptid);
	503	}
	504
63807e1d	505	static struct target_ops *
82f5c14f MK	506	bsd_uthread_target (void)
82f5c14f MK	507	{
41bf6aca	508	struct target_ops *t = XCNEW (struct target_ops);
82f5c14f MK	509
	510	t->to_shortname = "bsd-uthreads";
	511	t->to_longname = "BSD user-level threads";
	512	t->to_doc = "BSD user-level threads";
39540081	513	t->to_close = bsd_uthread_close;
82f5c14f MK	514	t->to_mourn_inferior = bsd_uthread_mourn_inferior;
	515	t->to_fetch_registers = bsd_uthread_fetch_registers;
	516	t->to_store_registers = bsd_uthread_store_registers;
82f5c14f MK	517	t->to_wait = bsd_uthread_wait;
	518	t->to_resume = bsd_uthread_resume;
	519	t->to_thread_alive = bsd_uthread_thread_alive;
	520	t->to_find_new_threads = bsd_uthread_find_new_threads;
	521	t->to_extra_thread_info = bsd_uthread_extra_thread_info;
	522	t->to_pid_to_str = bsd_uthread_pid_to_str;
	523	t->to_stratum = thread_stratum;
	524	t->to_magic = OPS_MAGIC;
	525	bsd_uthread_ops_hack = t;
	526
	527	return t;
	528	}
	529
63807e1d PA	530	/* Provide a prototype to silence -Wmissing-prototypes. */
	531	extern initialize_file_ftype _initialize_bsd_uthread;
	532
82f5c14f MK	533	void
	534	_initialize_bsd_uthread (void)
	535	{
12070676	536	complete_target_initialization (bsd_uthread_target ());
82f5c14f MK	537
	538	bsd_uthread_data = gdbarch_data_register_pre_init (bsd_uthread_init);
	539
	540	observer_attach_inferior_created (bsd_uthread_inferior_created);
	541	observer_attach_solib_loaded (bsd_uthread_solib_loaded);
	542	observer_attach_solib_unloaded (bsd_uthread_solib_unloaded);
	543	}