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

/* BSD Kernel Data Access Library (libkvm) interface.

   Copyright (C) 2004-2025 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/>.  */

#define _KMEMUSER
#include "cli/cli-cmds.h"
#include "command.h"
#include "filenames.h"
#include "frame.h"
#include "regcache.h"
#include "target.h"
#include "process-stratum-target.h"
#include "value.h"
#include "gdbcore.h"
#include "inferior.h"
#include "gdbthread.h"
#include "gdbsupport/pathstuff.h"
#include "gdbsupport/gdb_tilde_expand.h"

#include <fcntl.h>
#include <kvm.h>
#ifdef HAVE_NLIST_H
#include <nlist.h>
#endif
#include <paths.h>
#include "readline/readline.h"
#include <sys/param.h>
#include <sys/proc.h>
#ifdef HAVE_SYS_USER_H
#include <sys/user.h>
#endif

#include "bsd-kvm.h"

/* Kernel memory device file.  */
static std::string bsd_kvm_corefile;

/* Kernel memory interface descriptor.  */
static kvm_t *core_kd;

/* Address of process control block.  */
static struct pcb *bsd_kvm_paddr;

/* Pointer to architecture-specific function that reconstructs the
   register state from PCB and supplies it to REGCACHE.  */
static int (*bsd_kvm_supply_pcb)(struct regcache *regcache, struct pcb *pcb);

/* This is the ptid we use while we're connected to kvm.  The kvm
   target currently doesn't export any view of the running processes,
   so this represents the kernel task.  */
static ptid_t bsd_kvm_ptid;

/* The libkvm target.  */

static const target_info bsd_kvm_target_info = {
  "kvm",
  N_("Kernel memory interface"),
  N_("Use a kernel virtual memory image as a target.\n\
Optionally specify the filename of a core dump.")
};

class bsd_kvm_target final : public process_stratum_target
{
public:
  bsd_kvm_target () = default;

  const target_info &info () const override
  { return bsd_kvm_target_info; }

  void close () override;

  void fetch_registers (struct regcache *, int) override;
  enum target_xfer_status xfer_partial (enum target_object object,
					const char *annex,
					gdb_byte *readbuf,
					const gdb_byte *writebuf,
					ULONGEST offset, ULONGEST len,
					ULONGEST *xfered_len) override;

  void files_info () override;
  bool thread_alive (ptid_t ptid) override;
  std::string pid_to_str (ptid_t) override;

  bool has_memory () override { return true; }
  bool has_stack () override { return true; }
  bool has_registers () override { return true; }
};

/* Target ops for libkvm interface.  */
static bsd_kvm_target bsd_kvm_ops;

static void
bsd_kvm_target_open (const char *arg, int from_tty)
{
  char errbuf[_POSIX2_LINE_MAX];
  kvm_t *temp_kd;
  std::string filename;

  target_preopen (from_tty);

  if (arg)
    {
      filename = gdb_tilde_expand (arg);
      if (!IS_ABSOLUTE_PATH (filename))
	filename = gdb_abspath (filename);
    }

  const char *execfile = current_program_space->exec_filename ();
  temp_kd = kvm_openfiles (execfile, filename.c_str (), NULL,
			   write_files ? O_RDWR : O_RDONLY, errbuf);
  if (temp_kd == NULL)
    error (("%s"), errbuf);

  bsd_kvm_corefile = filename;
  current_inferior ()->unpush_target (&bsd_kvm_ops);
  core_kd = temp_kd;
  current_inferior ()->push_target (&bsd_kvm_ops);

  thread_info *thr = add_thread_silent (&bsd_kvm_ops, bsd_kvm_ptid);
  switch_to_thread (thr);

  target_fetch_registers (get_thread_regcache (thr), -1);

  reinit_frame_cache ();
  print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
}

void
bsd_kvm_target::close ()
{
  if (core_kd)
    {
      if (kvm_close (core_kd) == -1)
	warning (("%s"), kvm_geterr(core_kd));
      core_kd = NULL;
    }

  bsd_kvm_corefile.clear ();
  switch_to_no_thread ();
  exit_inferior (current_inferior ());
}

static LONGEST
bsd_kvm_xfer_memory (CORE_ADDR addr, ULONGEST len,
		     gdb_byte *readbuf, const gdb_byte *writebuf)
{
  ssize_t nbytes = len;

  if (readbuf)
    nbytes = kvm_read (core_kd, addr, readbuf, nbytes);
  if (writebuf && nbytes > 0)
    nbytes = kvm_write (core_kd, addr, writebuf, nbytes);
  return nbytes;
}

enum target_xfer_status
bsd_kvm_target::xfer_partial (enum target_object object,
			      const char *annex, gdb_byte *readbuf,
			      const gdb_byte *writebuf,
			      ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
{
  switch (object)
    {
    case TARGET_OBJECT_MEMORY:
      {
	LONGEST ret = bsd_kvm_xfer_memory (offset, len, readbuf, writebuf);

	if (ret < 0)
	  return TARGET_XFER_E_IO;
	else if (ret == 0)
	  return TARGET_XFER_EOF;
	else
	  {
	    *xfered_len = (ULONGEST) ret;
	    return TARGET_XFER_OK;
	  }
      }

    default:
      return TARGET_XFER_E_IO;
    }
}

void
bsd_kvm_target::files_info ()
{
  if (bsd_kvm_corefile != _PATH_MEM)
    gdb_printf (_("\tUsing the kernel crash dump %s.\n"),
		bsd_kvm_corefile.c_str ());
  else
    gdb_printf (_("\tUsing the currently running kernel.\n"));
}

/* Fetch process control block at address PADDR.  */

static int
bsd_kvm_fetch_pcb (struct regcache *regcache, struct pcb *paddr)
{
  struct pcb pcb;

  if (kvm_read (core_kd, (unsigned long) paddr, &pcb, sizeof pcb) == -1)
    error (("%s"), kvm_geterr (core_kd));

  gdb_assert (bsd_kvm_supply_pcb);
  return bsd_kvm_supply_pcb (regcache, &pcb);
}

void
bsd_kvm_target::fetch_registers (struct regcache *regcache, int regnum)
{
  struct nlist nl[2];

  if (bsd_kvm_paddr)
    {
      bsd_kvm_fetch_pcb (regcache, bsd_kvm_paddr);
      return;
    }

  /* On dumping core, BSD kernels store the faulting context (PCB)
     in the variable "dumppcb".  */
  memset (nl, 0, sizeof nl);
  nl[0].n_name = (char *) "_dumppcb";

  if (kvm_nlist (core_kd, nl) == -1)
    error (("%s"), kvm_geterr (core_kd));

  if (nl[0].n_value != 0)
    {
      /* Found dumppcb.  If it contains a valid context, return
	 immediately.  */
      if (bsd_kvm_fetch_pcb (regcache, (struct pcb *) nl[0].n_value))
	return;
    }

  /* Traditional BSD kernels have a process proc0 that should always
     be present.  The address of proc0's PCB is stored in the variable
     "proc0paddr".  */

  memset (nl, 0, sizeof nl);
  nl[0].n_name = (char *) "_proc0paddr";

  if (kvm_nlist (core_kd, nl) == -1)
    error (("%s"), kvm_geterr (core_kd));

  if (nl[0].n_value != 0)
    {
      struct pcb *paddr;

      /* Found proc0paddr.  */
      if (kvm_read (core_kd, nl[0].n_value, &paddr, sizeof paddr) == -1)
	error (("%s"), kvm_geterr (core_kd));

      bsd_kvm_fetch_pcb (regcache, paddr);
      return;
    }

#ifdef HAVE_STRUCT_THREAD_TD_PCB
  /* In FreeBSD kernels for 5.0-RELEASE and later, the PCB no longer
     lives in `struct proc' but in `struct thread'.  The `struct
     thread' for the initial thread for proc0 can be found in the
     variable "thread0".  */

  memset (nl, 0, sizeof nl);
  nl[0].n_name = (char *) "_thread0";

  if (kvm_nlist (core_kd, nl) == -1)
    error (("%s"), kvm_geterr (core_kd));

  if (nl[0].n_value != 0)
    {
      struct pcb *paddr;

      /* Found thread0.  */
      nl[0].n_value += offsetof (struct thread, td_pcb);
      if (kvm_read (core_kd, nl[0].n_value, &paddr, sizeof paddr) == -1)
	error (("%s"), kvm_geterr (core_kd));

      bsd_kvm_fetch_pcb (regcache, paddr);
      return;
    }
#endif

  /* i18n: PCB == "Process Control Block".  */
  error (_("Cannot find a valid PCB"));
}
\f

/* Kernel memory interface commands.  */
struct cmd_list_element *bsd_kvm_cmdlist;

static void
bsd_kvm_cmd (const char *arg, int fromtty)
{
  /* ??? Should this become an alias for "target kvm"?  */
}

#ifndef HAVE_STRUCT_THREAD_TD_PCB

static void
bsd_kvm_proc_cmd (const char *arg, int fromtty)
{
  CORE_ADDR addr;

  if (arg == NULL)
    error_no_arg (_("proc address"));

  if (core_kd == NULL)
    error (_("No kernel memory image."));

  addr = parse_and_eval_address (arg);
#ifdef HAVE_STRUCT_LWP
  addr += offsetof (struct lwp, l_addr);
#else
  addr += offsetof (struct proc, p_addr);
#endif

  if (kvm_read (core_kd, addr, &bsd_kvm_paddr, sizeof bsd_kvm_paddr) == -1)
    error (("%s"), kvm_geterr (core_kd));

  target_fetch_registers (get_thread_regcache (inferior_thread ()), -1);

  reinit_frame_cache ();
  print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
}

#endif

static void
bsd_kvm_pcb_cmd (const char *arg, int fromtty)
{
  if (arg == NULL)
    /* i18n: PCB == "Process Control Block".  */
    error_no_arg (_("pcb address"));

  if (core_kd == NULL)
    error (_("No kernel memory image."));

  bsd_kvm_paddr = (struct pcb *)(u_long) parse_and_eval_address (arg);

  target_fetch_registers (get_thread_regcache (inferior_thread ()), -1);

  reinit_frame_cache ();
  print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
}

bool
bsd_kvm_target::thread_alive (ptid_t ptid)
{
  return true;
}

std::string
bsd_kvm_target::pid_to_str (ptid_t ptid)
{
  return "<kvm>";
}

/* Add the libkvm interface to the list of all possible targets and
   register CUPPLY_PCB as the architecture-specific process control
   block interpreter.  */

void
bsd_kvm_add_target (int (*supply_pcb)(struct regcache *, struct pcb *))
{
  gdb_assert (bsd_kvm_supply_pcb == NULL);
  bsd_kvm_supply_pcb = supply_pcb;

  add_target (bsd_kvm_target_info, bsd_kvm_target_open);
  
  add_prefix_cmd ("kvm", class_obscure, bsd_kvm_cmd, _("\
Generic command for manipulating the kernel memory interface."),
		  &bsd_kvm_cmdlist, 0, &cmdlist);

#ifndef HAVE_STRUCT_THREAD_TD_PCB
  add_cmd ("proc", class_obscure, bsd_kvm_proc_cmd,
	   _("Set current context from proc address"), &bsd_kvm_cmdlist);
#endif
  add_cmd ("pcb", class_obscure, bsd_kvm_pcb_cmd,
	   /* i18n: PCB == "Process Control Block".  */
	   _("Set current context from pcb address"), &bsd_kvm_cmdlist);

  /* Some notes on the ptid usage on this target.

     The pid field represents the kvm inferior instance.  Currently,
     we don't support multiple kvm inferiors, but we start at 1
     anyway.  The lwp field is set to != 0, in case the core wants to
     refer to the whole kvm inferior with ptid(1,0,0).

     If kvm is made to export running processes as gdb threads,
     the following form can be used:
     ptid (1, 1, 0) -> kvm inferior 1, in kernel
     ptid (1, 1, 1) -> kvm inferior 1, process 1
     ptid (1, 1, 2) -> kvm inferior 1, process 2
     ptid (1, 1, n) -> kvm inferior 1, process n  */

  bsd_kvm_ptid = ptid_t (1, 1, 0);
}
Commit	Line	Data
	1	/* BSD Kernel Data Access Library (libkvm) interface.
	2
	3	Copyright (C) 2004-2025 Free Software Foundation, Inc.
	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
	9	the Free Software Foundation; either version 3 of the License, or
	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
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
	20	#define _KMEMUSER
	21	#include "cli/cli-cmds.h"
	22	#include "command.h"
	23	#include "filenames.h"
	24	#include "frame.h"
	25	#include "regcache.h"
	26	#include "target.h"
	27	#include "process-stratum-target.h"
	28	#include "value.h"
	29	#include "gdbcore.h"
	30	#include "inferior.h"
	31	#include "gdbthread.h"
	32	#include "gdbsupport/pathstuff.h"
	33	#include "gdbsupport/gdb_tilde_expand.h"
	34
	35	#include <fcntl.h>
	36	#include <kvm.h>
	37	#ifdef HAVE_NLIST_H
	38	#include <nlist.h>
	39	#endif
	40	#include <paths.h>
	41	#include "readline/readline.h"
	42	#include <sys/param.h>
	43	#include <sys/proc.h>
	44	#ifdef HAVE_SYS_USER_H
	45	#include <sys/user.h>
	46	#endif
	47
	48	#include "bsd-kvm.h"
	49
	50	/* Kernel memory device file. */
	51	static std::string bsd_kvm_corefile;
	52
	53	/* Kernel memory interface descriptor. */
	54	static kvm_t *core_kd;
	55
	56	/* Address of process control block. */
	57	static struct pcb *bsd_kvm_paddr;
	58
	59	/* Pointer to architecture-specific function that reconstructs the
	60	register state from PCB and supplies it to REGCACHE. */
	61	static int (bsd_kvm_supply_pcb)(struct regcache regcache, struct pcb *pcb);
	62
	63	/* This is the ptid we use while we're connected to kvm. The kvm
	64	target currently doesn't export any view of the running processes,
	65	so this represents the kernel task. */
	66	static ptid_t bsd_kvm_ptid;
	67
	68	/* The libkvm target. */
	69
	70	static const target_info bsd_kvm_target_info = {
	71	"kvm",
	72	N_("Kernel memory interface"),
	73	N_("Use a kernel virtual memory image as a target.\n\
	74	Optionally specify the filename of a core dump.")
	75	};
	76
	77	class bsd_kvm_target final : public process_stratum_target
	78	{
	79	public:
	80	bsd_kvm_target () = default;
	81
	82	const target_info &info () const override
	83	{ return bsd_kvm_target_info; }
	84
	85	void close () override;
	86
	87	void fetch_registers (struct regcache *, int) override;
	88	enum target_xfer_status xfer_partial (enum target_object object,
	89	const char *annex,
	90	gdb_byte *readbuf,
	91	const gdb_byte *writebuf,
	92	ULONGEST offset, ULONGEST len,
	93	ULONGEST *xfered_len) override;
	94
	95	void files_info () override;
	96	bool thread_alive (ptid_t ptid) override;
	97	std::string pid_to_str (ptid_t) override;
	98
	99	bool has_memory () override { return true; }
	100	bool has_stack () override { return true; }
	101	bool has_registers () override { return true; }
	102	};
	103
	104	/* Target ops for libkvm interface. */
	105	static bsd_kvm_target bsd_kvm_ops;
	106
	107	static void
	108	bsd_kvm_target_open (const char *arg, int from_tty)
	109	{
	110	char errbuf[_POSIX2_LINE_MAX];
	111	kvm_t *temp_kd;
	112	std::string filename;
	113
	114	target_preopen (from_tty);
	115
	116	if (arg)
	117	{
	118	filename = gdb_tilde_expand (arg);
	119	if (!IS_ABSOLUTE_PATH (filename))
	120	filename = gdb_abspath (filename);
	121	}
	122
	123	const char *execfile = current_program_space->exec_filename ();
	124	temp_kd = kvm_openfiles (execfile, filename.c_str (), NULL,
	125	write_files ? O_RDWR : O_RDONLY, errbuf);
	126	if (temp_kd == NULL)
	127	error (("%s"), errbuf);
	128
	129	bsd_kvm_corefile = filename;
	130	current_inferior ()->unpush_target (&bsd_kvm_ops);
	131	core_kd = temp_kd;
	132	current_inferior ()->push_target (&bsd_kvm_ops);
	133
	134	thread_info *thr = add_thread_silent (&bsd_kvm_ops, bsd_kvm_ptid);
	135	switch_to_thread (thr);
	136
	137	target_fetch_registers (get_thread_regcache (thr), -1);
	138
	139	reinit_frame_cache ();
	140	print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
	141	}
	142
	143	void
	144	bsd_kvm_target::close ()
	145	{
	146	if (core_kd)
	147	{
	148	if (kvm_close (core_kd) == -1)
	149	warning (("%s"), kvm_geterr(core_kd));
	150	core_kd = NULL;
	151	}
	152
	153	bsd_kvm_corefile.clear ();
	154	switch_to_no_thread ();
	155	exit_inferior (current_inferior ());
	156	}
	157
	158	static LONGEST
	159	bsd_kvm_xfer_memory (CORE_ADDR addr, ULONGEST len,
	160	gdb_byte readbuf, const gdb_byte writebuf)
	161	{
	162	ssize_t nbytes = len;
	163
	164	if (readbuf)
	165	nbytes = kvm_read (core_kd, addr, readbuf, nbytes);
	166	if (writebuf && nbytes > 0)
	167	nbytes = kvm_write (core_kd, addr, writebuf, nbytes);
	168	return nbytes;
	169	}
	170
	171	enum target_xfer_status
	172	bsd_kvm_target::xfer_partial (enum target_object object,
	173	const char annex, gdb_byte readbuf,
	174	const gdb_byte *writebuf,
	175	ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
	176	{
	177	switch (object)
	178	{
	179	case TARGET_OBJECT_MEMORY:
	180	{
	181	LONGEST ret = bsd_kvm_xfer_memory (offset, len, readbuf, writebuf);
	182
	183	if (ret < 0)
	184	return TARGET_XFER_E_IO;
	185	else if (ret == 0)
	186	return TARGET_XFER_EOF;
	187	else
	188	{
	189	*xfered_len = (ULONGEST) ret;
	190	return TARGET_XFER_OK;
	191	}
	192	}
	193
	194	default:
	195	return TARGET_XFER_E_IO;
	196	}
	197	}
	198
	199	void
	200	bsd_kvm_target::files_info ()
	201	{
	202	if (bsd_kvm_corefile != _PATH_MEM)
	203	gdb_printf (_("\tUsing the kernel crash dump %s.\n"),
	204	bsd_kvm_corefile.c_str ());
	205	else
	206	gdb_printf (_("\tUsing the currently running kernel.\n"));
	207	}
	208
	209	/* Fetch process control block at address PADDR. */
	210
	211	static int
	212	bsd_kvm_fetch_pcb (struct regcache regcache, struct pcb paddr)
	213	{
	214	struct pcb pcb;
	215
	216	if (kvm_read (core_kd, (unsigned long) paddr, &pcb, sizeof pcb) == -1)
	217	error (("%s"), kvm_geterr (core_kd));
	218
	219	gdb_assert (bsd_kvm_supply_pcb);
	220	return bsd_kvm_supply_pcb (regcache, &pcb);
	221	}
	222
	223	void
	224	bsd_kvm_target::fetch_registers (struct regcache *regcache, int regnum)
	225	{
	226	struct nlist nl[2];
	227
	228	if (bsd_kvm_paddr)
	229	{
	230	bsd_kvm_fetch_pcb (regcache, bsd_kvm_paddr);
	231	return;
	232	}
	233
	234	/* On dumping core, BSD kernels store the faulting context (PCB)
	235	in the variable "dumppcb". */
	236	memset (nl, 0, sizeof nl);
	237	nl[0].n_name = (char *) "_dumppcb";
	238
	239	if (kvm_nlist (core_kd, nl) == -1)
	240	error (("%s"), kvm_geterr (core_kd));
	241
	242	if (nl[0].n_value != 0)
	243	{
	244	/* Found dumppcb. If it contains a valid context, return
	245	immediately. */
	246	if (bsd_kvm_fetch_pcb (regcache, (struct pcb *) nl[0].n_value))
	247	return;
	248	}
	249
	250	/* Traditional BSD kernels have a process proc0 that should always
	251	be present. The address of proc0's PCB is stored in the variable
	252	"proc0paddr". */
	253
	254	memset (nl, 0, sizeof nl);
	255	nl[0].n_name = (char *) "_proc0paddr";
	256
	257	if (kvm_nlist (core_kd, nl) == -1)
	258	error (("%s"), kvm_geterr (core_kd));
	259
	260	if (nl[0].n_value != 0)
	261	{
	262	struct pcb *paddr;
	263
	264	/* Found proc0paddr. */
	265	if (kvm_read (core_kd, nl[0].n_value, &paddr, sizeof paddr) == -1)
	266	error (("%s"), kvm_geterr (core_kd));
	267
	268	bsd_kvm_fetch_pcb (regcache, paddr);
	269	return;
	270	}
	271
	272	#ifdef HAVE_STRUCT_THREAD_TD_PCB
	273	/* In FreeBSD kernels for 5.0-RELEASE and later, the PCB no longer
	274	lives in `struct proc' but in `struct thread'. The `struct
	275	thread' for the initial thread for proc0 can be found in the
	276	variable "thread0". */
	277
	278	memset (nl, 0, sizeof nl);
	279	nl[0].n_name = (char *) "_thread0";
	280
	281	if (kvm_nlist (core_kd, nl) == -1)
	282	error (("%s"), kvm_geterr (core_kd));
	283
	284	if (nl[0].n_value != 0)
	285	{
	286	struct pcb *paddr;
	287
	288	/* Found thread0. */
	289	nl[0].n_value += offsetof (struct thread, td_pcb);
	290	if (kvm_read (core_kd, nl[0].n_value, &paddr, sizeof paddr) == -1)
	291	error (("%s"), kvm_geterr (core_kd));
	292
	293	bsd_kvm_fetch_pcb (regcache, paddr);
	294	return;
	295	}
	296	#endif
	297
	298	/* i18n: PCB == "Process Control Block". */
	299	error (_("Cannot find a valid PCB"));
	300	}
	301	\f
	302
	303	/* Kernel memory interface commands. */
	304	struct cmd_list_element *bsd_kvm_cmdlist;
	305
	306	static void
	307	bsd_kvm_cmd (const char *arg, int fromtty)
	308	{
	309	/* ??? Should this become an alias for "target kvm"? */
	310	}
	311
	312	#ifndef HAVE_STRUCT_THREAD_TD_PCB
	313
	314	static void
	315	bsd_kvm_proc_cmd (const char *arg, int fromtty)
	316	{
	317	CORE_ADDR addr;
	318
	319	if (arg == NULL)
	320	error_no_arg (_("proc address"));
	321
	322	if (core_kd == NULL)
	323	error (_("No kernel memory image."));
	324
	325	addr = parse_and_eval_address (arg);
	326	#ifdef HAVE_STRUCT_LWP
	327	addr += offsetof (struct lwp, l_addr);
	328	#else
	329	addr += offsetof (struct proc, p_addr);
	330	#endif
	331
	332	if (kvm_read (core_kd, addr, &bsd_kvm_paddr, sizeof bsd_kvm_paddr) == -1)
	333	error (("%s"), kvm_geterr (core_kd));
	334
	335	target_fetch_registers (get_thread_regcache (inferior_thread ()), -1);
	336
	337	reinit_frame_cache ();
	338	print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
	339	}
	340
	341	#endif
	342
	343	static void
	344	bsd_kvm_pcb_cmd (const char *arg, int fromtty)
	345	{
	346	if (arg == NULL)
	347	/* i18n: PCB == "Process Control Block". */
	348	error_no_arg (_("pcb address"));
	349
	350	if (core_kd == NULL)
	351	error (_("No kernel memory image."));
	352
	353	bsd_kvm_paddr = (struct pcb *)(u_long) parse_and_eval_address (arg);
	354
	355	target_fetch_registers (get_thread_regcache (inferior_thread ()), -1);
	356
	357	reinit_frame_cache ();
	358	print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
	359	}
	360
	361	bool
	362	bsd_kvm_target::thread_alive (ptid_t ptid)
	363	{
	364	return true;
	365	}
	366
	367	std::string
	368	bsd_kvm_target::pid_to_str (ptid_t ptid)
	369	{
	370	return "<kvm>";
	371	}
	372
	373	/* Add the libkvm interface to the list of all possible targets and
	374	register CUPPLY_PCB as the architecture-specific process control
	375	block interpreter. */
	376
	377	void
	378	bsd_kvm_add_target (int (supply_pcb)(struct regcache , struct pcb *))
	379	{
	380	gdb_assert (bsd_kvm_supply_pcb == NULL);
	381	bsd_kvm_supply_pcb = supply_pcb;
	382
	383	add_target (bsd_kvm_target_info, bsd_kvm_target_open);
	384
	385	add_prefix_cmd ("kvm", class_obscure, bsd_kvm_cmd, _("\
	386	Generic command for manipulating the kernel memory interface."),
	387	&bsd_kvm_cmdlist, 0, &cmdlist);
	388
	389	#ifndef HAVE_STRUCT_THREAD_TD_PCB
	390	add_cmd ("proc", class_obscure, bsd_kvm_proc_cmd,
	391	_("Set current context from proc address"), &bsd_kvm_cmdlist);
	392	#endif
	393	add_cmd ("pcb", class_obscure, bsd_kvm_pcb_cmd,
	394	/* i18n: PCB == "Process Control Block". */
	395	_("Set current context from pcb address"), &bsd_kvm_cmdlist);
	396
	397	/* Some notes on the ptid usage on this target.
	398
	399	The pid field represents the kvm inferior instance. Currently,
	400	we don't support multiple kvm inferiors, but we start at 1
	401	anyway. The lwp field is set to != 0, in case the core wants to
	402	refer to the whole kvm inferior with ptid(1,0,0).
	403
	404	If kvm is made to export running processes as gdb threads,
	405	the following form can be used:
	406	ptid (1, 1, 0) -> kvm inferior 1, in kernel
	407	ptid (1, 1, 1) -> kvm inferior 1, process 1
	408	ptid (1, 1, 2) -> kvm inferior 1, process 2
	409	ptid (1, 1, n) -> kvm inferior 1, process n */
	410
	411	bsd_kvm_ptid = ptid_t (1, 1, 0);
	412	}