gdb6/files/kvm-fbsd.c

/* Kernel core dump functions below target vector, for GDB.
   Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995
   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 2 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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/

#include <sys/cdefs.h>
__FBSDID("$FreeBSD: ports/devel/gdb6/files/kvm-fbsd.c,v 1.2 2004/06/20 22:22:02 obrien Exp $");

/*
 * This works like "remote" but, you use it like this:
 *     target kcore /dev/mem
 * or
 *     target kcore /var/crash/host/core.0
 *
 * This way makes it easy to short-circut the whole bfd monster,
 * and direct the inferior stuff to our libkvm implementation.
 *
 */

#include <sys/param.h>
#include <sys/user.h>
#include <machine/frame.h>
//#include <sys/proc.h>
//#include <sys/sysctl.h>
//#include <sys/time.h>
//#include <sys/user.h>

#include <ctype.h>
//#include <errno.h>
//#include <signal.h>
#include <fcntl.h>
#include <kvm.h>
#include <sys/sysctl.h>
#include <paths.h>

#include "defs.h"
#include "gdb_string.h"
#include "frame.h"  /* required by inferior.h */
#include "inferior.h"
//#include "symtab.h"
#include "symfile.h"
#include "objfiles.h"
#include "command.h"
#include "bfd.h"
//#include "target.h"
#include "gdbcore.h"
#include "solist.h"
#include "regcache.h"
#include <readline/tilde.h>

#include "kvm-fbsd.h"

#if __FreeBSD_version >= 500032
static void
kcore_files_info (struct target_ops *);

static void
kcore_close (int);

static void
get_kcore_registers (int);


        /*
static int
xfer_mem (CORE_ADDR, char *, int, int, struct mem_attrib *,
          struct target_ops *);
        */

static int
xfer_umem (CORE_ADDR, char *, int, int);

static char             *core_file;
static kvm_t            *core_kd;
static struct pcb       cur_pcb;
static struct kinfo_proc *cur_proc;

static struct target_ops kcore_ops;

int kernel_debugging;
int kernel_writablecore;

/* Read the "thing" at kernel address 'addr' into the space pointed to
   by point.  The length of the "thing" is determined by the type of p.
   Result is non-zero if transfer fails.  */

#define kvread(addr, p) \
  (target_read_memory ((CORE_ADDR) (addr), (char *) (p), sizeof (*(p))))

static CORE_ADDR
ksym_kernbase (void)
{
  static CORE_ADDR kernbase;
  struct minimal_symbol *sym;

  if (kernbase == 0)
    {
      sym = lookup_minimal_symbol ("kernbase", NULL, NULL);
      if (sym == NULL) {
        kernbase = KERNBASE;
      } else {
        kernbase = SYMBOL_VALUE_ADDRESS (sym);
      }
    }
  return kernbase;
}

#define KERNOFF         (ksym_kernbase ())
#define INKERNEL(x)     ((x) >= KERNOFF)

CORE_ADDR
ksym_lookup(const char *name)
{
  struct minimal_symbol *sym;

  sym = lookup_minimal_symbol (name, NULL, NULL);
  if (sym == NULL)
    error ("kernel symbol `%s' not found.", name);

  return SYMBOL_VALUE_ADDRESS (sym);
}

/* Provide the address of an initial PCB to use.
   If this is a crash dump, try for "dumppcb".
   If no "dumppcb" or it's /dev/mem, use proc0.
   Return the core address of the PCB we found.  */

static CORE_ADDR
initial_pcb (void)
{
  struct minimal_symbol *sym;
  CORE_ADDR addr;
  void *val;

  /* Make sure things are open...  */
  if (!core_kd || !core_file)
    return (0);

  /* If this is NOT /dev/mem try for dumppcb.  */
  if (strncmp (core_file, _PATH_DEV, sizeof _PATH_DEV - 1))
    {
      sym = lookup_minimal_symbol ("dumppcb", NULL, NULL);
      if (sym != NULL)
        {
          addr = SYMBOL_VALUE_ADDRESS (sym);
          return (addr);
        }
  }

  /* OK, just use thread0's pcb.  Note that curproc might
     not exist, and if it does, it will point to gdb.
     Therefore, just use proc0 and let the user set
     some other context if they care about it.  */

  addr = ksym_lookup ("thread0");
  if (kvread (addr, &val))
    {
      error ("cannot read thread0 pointer at %lx\n", addr);
      val = 0;
    }
  else
    {
      /* Read the PCB address in thread structure.  */
      addr += offsetof (struct thread, td_pcb);
      if (kvread (addr, &val))
        {
          error ("cannot read thread0->td_pcb pointer at %lx\n", addr);
          val = 0;
        }
    }

  /* thread0 is wholly in the kernel and cur_proc is only used for
     reading user mem, so no point in setting this up.  */
  cur_proc = 0;

  return ((CORE_ADDR)val);
}

/* Set the current context to that of the PCB struct at the system address
   passed.  */

static int
set_context (CORE_ADDR addr)
{
  CORE_ADDR procaddr = 0;

  if (kvread (addr, &cur_pcb))
    error ("cannot read pcb at %#lx", addr);

  /* Fetch all registers from core file.  */
  target_fetch_registers (-1);

  /* Now, set up the frame cache, and print the top of stack.  */
  flush_cached_frames ();
/*DEO XXX
  set_current_frame (create_new_frame (read_fp (), read_pc ()));
  set_current_frame (create_new_frame (deprecated_read_fp (), read_pc ()));
  select_frame (get_current_frame ());
*/
  print_stack_frame (get_selected_frame (), -1, 1);
  return (0);
}

/* Discard all vestiges of any previous core file and mark data and stack
   spaces as empty.  */

/* ARGSUSED */
static void
kcore_close (int quitting)
{

  inferior_ptid = null_ptid;    /* Avoid confusion from thread stuff.  */

  if (core_kd)
    {
      kvm_close (core_kd);
      free (core_file);
      core_file = NULL;
      core_kd = NULL;
    }
}

/* This routine opens and sets up the core file bfd.  */

static void
kcore_open (char *filename /* the core file */, int from_tty)
{
  kvm_t *kd;
  const char *p;
  struct cleanup *old_chain;
  char buf[256], *cp;
  int ontop;
  CORE_ADDR addr;

  target_preopen (from_tty);

  /* The exec file is required for symbols.  */
  if (exec_bfd == NULL)
    error ("No kernel exec file specified");

  if (core_kd)
    {
      error ("No core file specified."
             "  (Use `detach' to stop debugging a core file.)");
      return;
    }

  if (!filename)
    {
      error ("No core file specified.");
      return;
    }

  filename = tilde_expand (filename);
  if (filename[0] != '/')
    {
      cp = concat (current_directory, "/", filename, NULL);
      free (filename);
      filename = cp;
    }

  old_chain = make_cleanup (free, filename);

  kd = kvm_open (bfd_get_filename(exec_bfd), filename, NULL,
                 kernel_writablecore ? O_RDWR: O_RDONLY, 0);
  if (kd == NULL)
    {
      perror_with_name (filename);
      return;
    }

  /* Looks semi-reasonable.  Toss the old core file and work on the new.  */

  discard_cleanups (old_chain);         /* Don't free filename any more.  */
  core_file = filename;
  unpush_target (&kcore_ops);
  ontop = !push_target (&kcore_ops);

  /* Note unpush_target (above) calls kcore_close.  */
  core_kd = kd;

  /* Print out the panic string if there is one.  */
  if (kvread (ksym_lookup ("panicstr"), &addr) == 0 &&
      addr != 0 &&
      target_read_memory (addr, buf, sizeof(buf)) == 0)
    {

      for (cp = buf; cp < &buf[sizeof(buf)] && *cp; cp++)
        if (!isascii (*cp) || (!isprint (*cp) && !isspace (*cp)))
          *cp = '?';
      *cp = '\0';
      if (buf[0] != '\0')
        printf_filtered ("panic: %s\n", buf);
    }

  /* Print all the panic messages if possible.  */
  if (symfile_objfile != NULL)
    {
      printf ("panic messages:\n---\n");
      snprintf (buf, sizeof buf,
                "/sbin/dmesg -N %s -M %s | \
                 /usr/bin/awk '/^(panic:|Fatal trap) / { printing = 1 } \
                               { if (printing) print $0 }'",
                symfile_objfile->name, filename);
      fflush (stdout);
      system (buf);
      printf ("---\n");
    }

  if (!ontop)
    {
      warning ("you won't be able to access this core file until you terminate\n"
                "your %s; do ``info files''", target_longname);
      return;
    }

  /* Now, set up process context, and print the top of stack.  */
  (void)set_context (initial_pcb());
  print_stack_frame (get_selected_frame (),
                     frame_relative_level (get_selected_frame ()), 1);
}

static void
kcore_detach (char *args, int from_tty)
{
  if (args)
    error ("Too many arguments");
  unpush_target (&kcore_ops);
  reinit_frame_cache ();
  if (from_tty)
    printf_filtered ("No kernel core file now.\n");
}

/* Get the registers out of a core file.  This is the machine-
   independent part.  Fetch_core_registers is the machine-dependent
   part, typically implemented in the xm-file for each architecture.  */

/* We just get all the registers, so we don't use regno.  */

/* ARGSUSED */
static void
get_kcore_registers (int regno)
{

  /* XXX - Only read the pcb when set_context() is called.
     When looking at a live kernel this may be a problem,
     but the user can do another "proc" or "pcb" command to
     grab a new copy of the pcb...  */

  /* Zero out register set then fill in the ones we know about.  */
  fetch_kcore_registers (&cur_pcb);
}

static void
kcore_files_info (t)
  struct target_ops *t;
{
  printf_filtered ("\t`%s'\n", core_file);
}

/* If mourn is being called in all the right places, this could be say
   `gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */

        /*
static int
ignore (CORE_ADDR addr, char *contents)
{
  return 0;
}
        */

static int
xfer_kmem (CORE_ADDR memaddr, char *myaddr, int len, int write,
           struct mem_attrib *attrib, struct target_ops *target)
{
  int n;


  if (!INKERNEL (memaddr))
    return xfer_umem (memaddr, myaddr, len, write);

  if (core_kd == NULL)
    return 0;

  if (write)
    n = kvm_write (core_kd, memaddr, myaddr, len);
  else
    n = kvm_read (core_kd, memaddr, myaddr, len) ;
  if (n < 0) {
    fprintf_unfiltered (gdb_stderr, "can not access 0x%lx, %s\n",
                        memaddr, kvm_geterr (core_kd));
    n = 0;
  }

  return n;
}


static int
xfer_umem (CORE_ADDR memaddr, char *myaddr, int len, int write /* ignored */)
{
  int n = 0;

  if (cur_proc == 0)
    {
      error ("---Can't read userspace from dump, or kernel process---\n");
      return 0;
    }

  if (write)
    error ("kvm_uwrite unimplemented\n");
  else
    n = kvm_uread (core_kd, cur_proc, memaddr, myaddr, len) ;

  if (n < 0)
    return 0;

  return n;
}

static void
set_proc_cmd (char *arg, int from_tty)
{
  CORE_ADDR addr, pid_addr, first_td;
  void *val;
  struct kinfo_proc *kp;
  int cnt;
  pid_t pid;

  if (!arg)
    error_no_arg ("proc address for the new context");

  if (core_kd == NULL)
    error ("no kernel core file");

  addr = (CORE_ADDR) parse_and_eval_address (arg);

  if (!INKERNEL (addr))
    {
      kp = kvm_getprocs (core_kd, KERN_PROC_PID, addr, &cnt);
      if (!cnt)
        error ("invalid pid");
      addr = (CORE_ADDR)kp->ki_paddr;
      cur_proc = kp;
    }
  else
    {
      /* Update cur_proc.  */
      pid_addr = addr + offsetof (struct proc, p_pid);
      if (kvread (pid_addr, &pid))
        error ("cannot read pid ptr");
      cur_proc = kvm_getprocs (core_kd, KERN_PROC_PID, pid, &cnt);
      if (!cnt)
        error("invalid pid");
    }

  /* Find the first thread in the process.  XXXKSE  */
  addr += offsetof (struct proc, p_threads.tqh_first);
  if (kvread (addr, &first_td))
    error ("cannot read thread ptr");

  /* Read the PCB address in thread structure. */
  addr = first_td + offsetof (struct thread, td_pcb);
  if (kvread (addr, &val))
    error("cannot read pcb ptr");

  /* Read the PCB address in proc structure. */
  if (set_context ((CORE_ADDR) val))
    error ("invalid proc address");
}
#else
int kernel_debugging = 0;
int kernel_writablecore = 0;

CORE_ADDR
fbsd_kern_frame_saved_pc (struct frame_info *fi)
{
  return 0;
}
#endif

void
_initialize_kcorelow (void)
{
#if __FreeBSD_version >= 500032
  kcore_ops.to_shortname = "kcore";
  kcore_ops.to_longname = "Kernel core dump file";
  kcore_ops.to_doc =
    "Use a core file as a target.  Specify the filename of the core file.";
  kcore_ops.to_open = kcore_open;
  kcore_ops.to_close = kcore_close;
  kcore_ops.to_attach = find_default_attach;
  kcore_ops.to_detach = kcore_detach;
  kcore_ops.to_fetch_registers = get_kcore_registers;
  kcore_ops.to_xfer_memory = xfer_kmem;
  kcore_ops.to_files_info = kcore_files_info;
  kcore_ops.to_create_inferior = find_default_create_inferior;
  kcore_ops.to_stratum = kcore_stratum;
  kcore_ops.to_has_memory = 1;
  kcore_ops.to_has_stack = 1;
  kcore_ops.to_has_registers = 1;
  kcore_ops.to_magic = OPS_MAGIC;

  add_target (&kcore_ops);
  add_com ("proc", class_obscure, set_proc_cmd, "Set current process context");
#endif
}
Revision:	2
Committed:	2007-01-31T14:59:36-08:00 (18 years, 4 months ago) by douglas
Content type:	text/x-c
File size:	12876 byte(s)
Log Message:	This needs fixing...
#	Content
1	/* Kernel core dump functions below target vector, for GDB.
2	Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995
3	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 2 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, write to the Free Software
19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20	*/
21
22	#include <sys/cdefs.h>
23	__FBSDID("$FreeBSD: ports/devel/gdb6/files/kvm-fbsd.c,v 1.2 2004/06/20 22:22:02 obrien Exp $");
24
25	/*
26	* This works like "remote" but, you use it like this:
27	* target kcore /dev/mem
28	* or
29	* target kcore /var/crash/host/core.0
30	*
31	* This way makes it easy to short-circut the whole bfd monster,
32	* and direct the inferior stuff to our libkvm implementation.
33	*
34	*/
35
36	#include <sys/param.h>
37	#include <sys/user.h>
38	#include <machine/frame.h>
39	//#include <sys/proc.h>
40	//#include <sys/sysctl.h>
41	//#include <sys/time.h>
42	//#include <sys/user.h>
43
44	#include <ctype.h>
45	//#include <errno.h>
46	//#include <signal.h>
47	#include <fcntl.h>
48	#include <kvm.h>
49	#include <sys/sysctl.h>
50	#include <paths.h>
51
52	#include "defs.h"
53	#include "gdb_string.h"
54	#include "frame.h" /* required by inferior.h */
55	#include "inferior.h"
56	//#include "symtab.h"
57	#include "symfile.h"
58	#include "objfiles.h"
59	#include "command.h"
60	#include "bfd.h"
61	//#include "target.h"
62	#include "gdbcore.h"
63	#include "solist.h"
64	#include "regcache.h"
65	#include <readline/tilde.h>
66
67	#include "kvm-fbsd.h"
68
69	#if __FreeBSD_version >= 500032
70	static void
71	kcore_files_info (struct target_ops *);
72
73	static void
74	kcore_close (int);
75
76	static void
77	get_kcore_registers (int);
78
79
80	/*
81	static int
82	xfer_mem (CORE_ADDR, char , int, int, struct mem_attrib ,
83	struct target_ops *);
84	*/
85
86	static int
87	xfer_umem (CORE_ADDR, char *, int, int);
88
89	static char *core_file;
90	static kvm_t *core_kd;
91	static struct pcb cur_pcb;
92	static struct kinfo_proc *cur_proc;
93
94	static struct target_ops kcore_ops;
95
96	int kernel_debugging;
97	int kernel_writablecore;
98
99	/* Read the "thing" at kernel address 'addr' into the space pointed to
100	by point. The length of the "thing" is determined by the type of p.
101	Result is non-zero if transfer fails. */
102
103	#define kvread(addr, p) \
104	(target_read_memory ((CORE_ADDR) (addr), (char ) (p), sizeof ((p))))
105
106	static CORE_ADDR
107	ksym_kernbase (void)
108	{
109	static CORE_ADDR kernbase;
110	struct minimal_symbol *sym;
111
112	if (kernbase == 0)
113	{
114	sym = lookup_minimal_symbol ("kernbase", NULL, NULL);
115	if (sym == NULL) {
116	kernbase = KERNBASE;
117	} else {
118	kernbase = SYMBOL_VALUE_ADDRESS (sym);
119	}
120	}
121	return kernbase;
122	}
123
124	#define KERNOFF (ksym_kernbase ())
125	#define INKERNEL(x) ((x) >= KERNOFF)
126
127	CORE_ADDR
128	ksym_lookup(const char *name)
129	{
130	struct minimal_symbol *sym;
131
132	sym = lookup_minimal_symbol (name, NULL, NULL);
133	if (sym == NULL)
134	error ("kernel symbol `%s' not found.", name);
135
136	return SYMBOL_VALUE_ADDRESS (sym);
137	}
138
139	/* Provide the address of an initial PCB to use.
140	If this is a crash dump, try for "dumppcb".
141	If no "dumppcb" or it's /dev/mem, use proc0.
142	Return the core address of the PCB we found. */
143
144	static CORE_ADDR
145	initial_pcb (void)
146	{
147	struct minimal_symbol *sym;
148	CORE_ADDR addr;
149	void *val;
150
151	/* Make sure things are open... */
152	if (!core_kd \|\| !core_file)
153	return (0);
154
155	/* If this is NOT /dev/mem try for dumppcb. */
156	if (strncmp (core_file, _PATH_DEV, sizeof _PATH_DEV - 1))
157	{
158	sym = lookup_minimal_symbol ("dumppcb", NULL, NULL);
159	if (sym != NULL)
160	{
161	addr = SYMBOL_VALUE_ADDRESS (sym);
162	return (addr);
163	}
164	}
165
166	/* OK, just use thread0's pcb. Note that curproc might
167	not exist, and if it does, it will point to gdb.
168	Therefore, just use proc0 and let the user set
169	some other context if they care about it. */
170
171	addr = ksym_lookup ("thread0");
172	if (kvread (addr, &val))
173	{
174	error ("cannot read thread0 pointer at %lx\n", addr);
175	val = 0;
176	}
177	else
178	{
179	/* Read the PCB address in thread structure. */
180	addr += offsetof (struct thread, td_pcb);
181	if (kvread (addr, &val))
182	{
183	error ("cannot read thread0->td_pcb pointer at %lx\n", addr);
184	val = 0;
185	}
186	}
187
188	/* thread0 is wholly in the kernel and cur_proc is only used for
189	reading user mem, so no point in setting this up. */
190	cur_proc = 0;
191
192	return ((CORE_ADDR)val);
193	}
194
195	/* Set the current context to that of the PCB struct at the system address
196	passed. */
197
198	static int
199	set_context (CORE_ADDR addr)
200	{
201	CORE_ADDR procaddr = 0;
202
203	if (kvread (addr, &cur_pcb))
204	error ("cannot read pcb at %#lx", addr);
205
206	/* Fetch all registers from core file. */
207	target_fetch_registers (-1);
208
209	/* Now, set up the frame cache, and print the top of stack. */
210	flush_cached_frames ();
211	/*DEO XXX
212	set_current_frame (create_new_frame (read_fp (), read_pc ()));
213	set_current_frame (create_new_frame (deprecated_read_fp (), read_pc ()));
214	select_frame (get_current_frame ());
215	*/
216	print_stack_frame (get_selected_frame (), -1, 1);
217	return (0);
218	}
219
220	/* Discard all vestiges of any previous core file and mark data and stack
221	spaces as empty. */
222
223	/* ARGSUSED */
224	static void
225	kcore_close (int quitting)
226	{
227
228	inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */
229
230	if (core_kd)
231	{
232	kvm_close (core_kd);
233	free (core_file);
234	core_file = NULL;
235	core_kd = NULL;
236	}
237	}
238
239	/* This routine opens and sets up the core file bfd. */
240
241	static void
242	kcore_open (char filename / the core file */, int from_tty)
243	{
244	kvm_t *kd;
245	const char *p;
246	struct cleanup *old_chain;
247	char buf[256], *cp;
248	int ontop;
249	CORE_ADDR addr;
250
251	target_preopen (from_tty);
252
253	/* The exec file is required for symbols. */
254	if (exec_bfd == NULL)
255	error ("No kernel exec file specified");
256
257	if (core_kd)
258	{
259	error ("No core file specified."
260	" (Use `detach' to stop debugging a core file.)");
261	return;
262	}
263
264	if (!filename)
265	{
266	error ("No core file specified.");
267	return;
268	}
269
270	filename = tilde_expand (filename);
271	if (filename[0] != '/')
272	{
273	cp = concat (current_directory, "/", filename, NULL);
274	free (filename);
275	filename = cp;
276	}
277
278	old_chain = make_cleanup (free, filename);
279
280	kd = kvm_open (bfd_get_filename(exec_bfd), filename, NULL,
281	kernel_writablecore ? O_RDWR: O_RDONLY, 0);
282	if (kd == NULL)
283	{
284	perror_with_name (filename);
285	return;
286	}
287
288	/* Looks semi-reasonable. Toss the old core file and work on the new. */
289
290	discard_cleanups (old_chain); /* Don't free filename any more. */
291	core_file = filename;
292	unpush_target (&kcore_ops);
293	ontop = !push_target (&kcore_ops);
294
295	/* Note unpush_target (above) calls kcore_close. */
296	core_kd = kd;
297
298	/* Print out the panic string if there is one. */
299	if (kvread (ksym_lookup ("panicstr"), &addr) == 0 &&
300	addr != 0 &&
301	target_read_memory (addr, buf, sizeof(buf)) == 0)
302	{
303
304	for (cp = buf; cp < &buf[sizeof(buf)] && *cp; cp++)
305	if (!isascii (cp) \|\| (!isprint (cp) && !isspace (*cp)))
306	*cp = '?';
307	*cp = '\0';
308	if (buf[0] != '\0')
309	printf_filtered ("panic: %s\n", buf);
310	}
311
312	/* Print all the panic messages if possible. */
313	if (symfile_objfile != NULL)
314	{
315	printf ("panic messages:\n---\n");
316	snprintf (buf, sizeof buf,
317	"/sbin/dmesg -N %s -M %s \| \
318	/usr/bin/awk '/^(panic:\|Fatal trap) / { printing = 1 } \
319	{ if (printing) print $0 }'",
320	symfile_objfile->name, filename);
321	fflush (stdout);
322	system (buf);
323	printf ("---\n");
324	}
325
326	if (!ontop)
327	{
328	warning ("you won't be able to access this core file until you terminate\n"
329	"your %s; do ``info files''", target_longname);
330	return;
331	}
332
333	/* Now, set up process context, and print the top of stack. */
334	(void)set_context (initial_pcb());
335	print_stack_frame (get_selected_frame (),
336	frame_relative_level (get_selected_frame ()), 1);
337	}
338
339	static void
340	kcore_detach (char *args, int from_tty)
341	{
342	if (args)
343	error ("Too many arguments");
344	unpush_target (&kcore_ops);
345	reinit_frame_cache ();
346	if (from_tty)
347	printf_filtered ("No kernel core file now.\n");
348	}
349
350	/* Get the registers out of a core file. This is the machine-
351	independent part. Fetch_core_registers is the machine-dependent
352	part, typically implemented in the xm-file for each architecture. */
353
354	/* We just get all the registers, so we don't use regno. */
355
356	/* ARGSUSED */
357	static void
358	get_kcore_registers (int regno)
359	{
360
361	/* XXX - Only read the pcb when set_context() is called.
362	When looking at a live kernel this may be a problem,
363	but the user can do another "proc" or "pcb" command to
364	grab a new copy of the pcb... */
365
366	/* Zero out register set then fill in the ones we know about. */
367	fetch_kcore_registers (&cur_pcb);
368	}
369
370	static void
371	kcore_files_info (t)
372	struct target_ops *t;
373	{
374	printf_filtered ("\t`%s'\n", core_file);
375	}
376
377	/* If mourn is being called in all the right places, this could be say
378	`gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */
379
380	/*
381	static int
382	ignore (CORE_ADDR addr, char *contents)
383	{
384	return 0;
385	}
386	*/
387
388	static int
389	xfer_kmem (CORE_ADDR memaddr, char *myaddr, int len, int write,
390	struct mem_attrib attrib, struct target_ops target)
391	{
392	int n;
393
394
395	if (!INKERNEL (memaddr))
396	return xfer_umem (memaddr, myaddr, len, write);
397
398	if (core_kd == NULL)
399	return 0;
400
401	if (write)
402	n = kvm_write (core_kd, memaddr, myaddr, len);
403	else
404	n = kvm_read (core_kd, memaddr, myaddr, len) ;
405	if (n < 0) {
406	fprintf_unfiltered (gdb_stderr, "can not access 0x%lx, %s\n",
407	memaddr, kvm_geterr (core_kd));
408	n = 0;
409	}
410
411	return n;
412	}
413
414
415	static int
416	xfer_umem (CORE_ADDR memaddr, char myaddr, int len, int write / ignored */)
417	{
418	int n = 0;
419
420	if (cur_proc == 0)
421	{
422	error ("---Can't read userspace from dump, or kernel process---\n");
423	return 0;
424	}
425
426	if (write)
427	error ("kvm_uwrite unimplemented\n");
428	else
429	n = kvm_uread (core_kd, cur_proc, memaddr, myaddr, len) ;
430
431	if (n < 0)
432	return 0;
433
434	return n;
435	}
436
437	static void
438	set_proc_cmd (char *arg, int from_tty)
439	{
440	CORE_ADDR addr, pid_addr, first_td;
441	void *val;
442	struct kinfo_proc *kp;
443	int cnt;
444	pid_t pid;
445
446	if (!arg)
447	error_no_arg ("proc address for the new context");
448
449	if (core_kd == NULL)
450	error ("no kernel core file");
451
452	addr = (CORE_ADDR) parse_and_eval_address (arg);
453
454	if (!INKERNEL (addr))
455	{
456	kp = kvm_getprocs (core_kd, KERN_PROC_PID, addr, &cnt);
457	if (!cnt)
458	error ("invalid pid");
459	addr = (CORE_ADDR)kp->ki_paddr;
460	cur_proc = kp;
461	}
462	else
463	{
464	/* Update cur_proc. */
465	pid_addr = addr + offsetof (struct proc, p_pid);
466	if (kvread (pid_addr, &pid))
467	error ("cannot read pid ptr");
468	cur_proc = kvm_getprocs (core_kd, KERN_PROC_PID, pid, &cnt);
469	if (!cnt)
470	error("invalid pid");
471	}
472
473	/* Find the first thread in the process. XXXKSE */
474	addr += offsetof (struct proc, p_threads.tqh_first);
475	if (kvread (addr, &first_td))
476	error ("cannot read thread ptr");
477
478	/* Read the PCB address in thread structure. */
479	addr = first_td + offsetof (struct thread, td_pcb);
480	if (kvread (addr, &val))
481	error("cannot read pcb ptr");
482
483	/* Read the PCB address in proc structure. */
484	if (set_context ((CORE_ADDR) val))
485	error ("invalid proc address");
486	}
487	#else
488	int kernel_debugging = 0;
489	int kernel_writablecore = 0;
490
491	CORE_ADDR
492	fbsd_kern_frame_saved_pc (struct frame_info *fi)
493	{
494	return 0;
495	}
496	#endif
497
498	void
499	_initialize_kcorelow (void)
500	{
501	#if __FreeBSD_version >= 500032
502	kcore_ops.to_shortname = "kcore";
503	kcore_ops.to_longname = "Kernel core dump file";
504	kcore_ops.to_doc =
505	"Use a core file as a target. Specify the filename of the core file.";
506	kcore_ops.to_open = kcore_open;
507	kcore_ops.to_close = kcore_close;
508	kcore_ops.to_attach = find_default_attach;
509	kcore_ops.to_detach = kcore_detach;
510	kcore_ops.to_fetch_registers = get_kcore_registers;
511	kcore_ops.to_xfer_memory = xfer_kmem;
512	kcore_ops.to_files_info = kcore_files_info;
513	kcore_ops.to_create_inferior = find_default_create_inferior;
514	kcore_ops.to_stratum = kcore_stratum;
515	kcore_ops.to_has_memory = 1;
516	kcore_ops.to_has_stack = 1;
517	kcore_ops.to_has_registers = 1;
518	kcore_ops.to_magic = OPS_MAGIC;
519
520	add_target (&kcore_ops);
521	add_com ("proc", class_obscure, set_proc_cmd, "Set current process context");
522	#endif
523	}