1 /* BSD Kernel Data Access Library (libkvm) interface.
3 Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "cli/cli-cmds.h"
27 #include "gdbcore.h" /* for get_exec_file */
28 #include "gdbthread.h"
30 #include "gdb_assert.h"
37 #include "readline/readline.h"
38 #include <sys/param.h>
44 /* Kernel memory device file. */
45 static const char *bsd_kvm_corefile
;
47 /* Kernel memory interface descriptor. */
48 static kvm_t
*core_kd
;
50 /* Address of process control block. */
51 static struct pcb
*bsd_kvm_paddr
;
53 /* Pointer to architecture-specific function that reconstructs the
54 register state from PCB and supplies it to REGCACHE. */
55 static int (*bsd_kvm_supply_pcb
)(struct regcache
*regcache
, struct pcb
*pcb
);
57 /* Target ops for libkvm interface. */
58 static struct target_ops bsd_kvm_ops
;
60 /* This is the ptid we use while we're connected to kvm. The kvm
61 target currently doesn't export any view of the running processes,
62 so this represents the kernel task. */
63 static ptid_t bsd_kvm_ptid
;
66 bsd_kvm_open (char *filename
, int from_tty
)
68 char errbuf
[_POSIX2_LINE_MAX
];
69 char *execfile
= NULL
;
72 target_preopen (from_tty
);
78 filename
= tilde_expand (filename
);
79 if (filename
[0] != '/')
81 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
87 execfile
= get_exec_file (0);
88 temp_kd
= kvm_openfiles (execfile
, filename
, NULL
,
89 write_files
? O_RDWR
: O_RDONLY
, errbuf
);
91 error (("%s"), errbuf
);
93 bsd_kvm_corefile
= filename
;
94 unpush_target (&bsd_kvm_ops
);
96 push_target (&bsd_kvm_ops
);
98 add_thread_silent (bsd_kvm_ptid
);
99 inferior_ptid
= bsd_kvm_ptid
;
101 target_fetch_registers (get_current_regcache (), -1);
103 reinit_frame_cache ();
104 print_stack_frame (get_selected_frame (NULL
), -1, 1);
108 bsd_kvm_close (int quitting
)
112 if (kvm_close (core_kd
) == -1)
113 warning (("%s"), kvm_geterr(core_kd
));
117 inferior_ptid
= null_ptid
;
118 delete_thread_silent (bsd_kvm_ptid
);
122 bsd_kvm_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
123 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
125 ssize_t nbytes
= len
;
128 nbytes
= kvm_read (core_kd
, addr
, readbuf
, nbytes
);
129 if (writebuf
&& nbytes
> 0)
130 nbytes
= kvm_write (core_kd
, addr
, writebuf
, nbytes
);
135 bsd_kvm_xfer_partial (struct target_ops
*ops
, enum target_object object
,
136 const char *annex
, gdb_byte
*readbuf
,
137 const gdb_byte
*writebuf
,
138 ULONGEST offset
, LONGEST len
)
142 case TARGET_OBJECT_MEMORY
:
143 return bsd_kvm_xfer_memory (offset
, len
, readbuf
, writebuf
);
151 bsd_kvm_files_info (struct target_ops
*ops
)
153 if (bsd_kvm_corefile
&& strcmp (bsd_kvm_corefile
, _PATH_MEM
) != 0)
154 printf_filtered (_("\tUsing the kernel crash dump %s.\n"),
157 printf_filtered (_("\tUsing the currently running kernel.\n"));
160 /* Fetch process control block at address PADDR. */
163 bsd_kvm_fetch_pcb (struct regcache
*regcache
, struct pcb
*paddr
)
167 if (kvm_read (core_kd
, (unsigned long) paddr
, &pcb
, sizeof pcb
) == -1)
168 error (("%s"), kvm_geterr (core_kd
));
170 gdb_assert (bsd_kvm_supply_pcb
);
171 return bsd_kvm_supply_pcb (regcache
, &pcb
);
175 bsd_kvm_fetch_registers (struct target_ops
*ops
,
176 struct regcache
*regcache
, int regnum
)
182 bsd_kvm_fetch_pcb (regcache
, bsd_kvm_paddr
);
186 /* On dumping core, BSD kernels store the faulting context (PCB)
187 in the variable "dumppcb". */
188 memset (nl
, 0, sizeof nl
);
189 nl
[0].n_name
= "_dumppcb";
191 if (kvm_nlist (core_kd
, nl
) == -1)
192 error (("%s"), kvm_geterr (core_kd
));
194 if (nl
[0].n_value
!= 0)
196 /* Found dumppcb. If it contains a valid context, return
198 if (bsd_kvm_fetch_pcb (regcache
, (struct pcb
*) nl
[0].n_value
))
202 /* Traditional BSD kernels have a process proc0 that should always
203 be present. The address of proc0's PCB is stored in the variable
206 memset (nl
, 0, sizeof nl
);
207 nl
[0].n_name
= "_proc0paddr";
209 if (kvm_nlist (core_kd
, nl
) == -1)
210 error (("%s"), kvm_geterr (core_kd
));
212 if (nl
[0].n_value
!= 0)
216 /* Found proc0paddr. */
217 if (kvm_read (core_kd
, nl
[0].n_value
, &paddr
, sizeof paddr
) == -1)
218 error (("%s"), kvm_geterr (core_kd
));
220 bsd_kvm_fetch_pcb (regcache
, paddr
);
224 #ifdef HAVE_STRUCT_THREAD_TD_PCB
225 /* In FreeBSD kernels for 5.0-RELEASE and later, the PCB no longer
226 lives in `struct proc' but in `struct thread'. The `struct
227 thread' for the initial thread for proc0 can be found in the
228 variable "thread0". */
230 memset (nl
, 0, sizeof nl
);
231 nl
[0].n_name
= "_thread0";
233 if (kvm_nlist (core_kd
, nl
) == -1)
234 error (("%s"), kvm_geterr (core_kd
));
236 if (nl
[0].n_value
!= 0)
241 nl
[0].n_value
+= offsetof (struct thread
, td_pcb
);
242 if (kvm_read (core_kd
, nl
[0].n_value
, &paddr
, sizeof paddr
) == -1)
243 error (("%s"), kvm_geterr (core_kd
));
245 bsd_kvm_fetch_pcb (regcache
, paddr
);
250 /* i18n: PCB == "Process Control Block" */
251 error (_("Cannot find a valid PCB"));
255 /* Kernel memory interface commands. */
256 struct cmd_list_element
*bsd_kvm_cmdlist
;
259 bsd_kvm_cmd (char *arg
, int fromtty
)
261 /* ??? Should this become an alias for "target kvm"? */
264 #ifndef HAVE_STRUCT_THREAD_TD_PCB
267 bsd_kvm_proc_cmd (char *arg
, int fromtty
)
272 error_no_arg (_("proc address"));
275 error (_("No kernel memory image."));
277 addr
= parse_and_eval_address (arg
);
278 #ifdef HAVE_STRUCT_LWP
279 addr
+= offsetof (struct lwp
, l_addr
);
281 addr
+= offsetof (struct proc
, p_addr
);
284 if (kvm_read (core_kd
, addr
, &bsd_kvm_paddr
, sizeof bsd_kvm_paddr
) == -1)
285 error (("%s"), kvm_geterr (core_kd
));
287 target_fetch_registers (get_current_regcache (), -1);
289 reinit_frame_cache ();
290 print_stack_frame (get_selected_frame (NULL
), -1, 1);
296 bsd_kvm_pcb_cmd (char *arg
, int fromtty
)
299 /* i18n: PCB == "Process Control Block" */
300 error_no_arg (_("pcb address"));
303 error (_("No kernel memory image."));
305 bsd_kvm_paddr
= (struct pcb
*)(u_long
) parse_and_eval_address (arg
);
307 target_fetch_registers (get_current_regcache (), -1);
309 reinit_frame_cache ();
310 print_stack_frame (get_selected_frame (NULL
), -1, 1);
314 bsd_kvm_thread_alive (struct target_ops
*ops
,
321 bsd_kvm_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
324 xsnprintf (buf
, sizeof buf
, "<kvm>");
328 /* Add the libkvm interface to the list of all possible targets and
329 register CUPPLY_PCB as the architecture-specific process control
330 block interpreter. */
333 bsd_kvm_add_target (int (*supply_pcb
)(struct regcache
*, struct pcb
*))
335 gdb_assert (bsd_kvm_supply_pcb
== NULL
);
336 bsd_kvm_supply_pcb
= supply_pcb
;
338 bsd_kvm_ops
.to_shortname
= "kvm";
339 bsd_kvm_ops
.to_longname
= _("Kernel memory interface");
340 bsd_kvm_ops
.to_doc
= _("Use a kernel virtual memory image as a target.\n\
341 Optionally specify the filename of a core dump.");
342 bsd_kvm_ops
.to_open
= bsd_kvm_open
;
343 bsd_kvm_ops
.to_close
= bsd_kvm_close
;
344 bsd_kvm_ops
.to_fetch_registers
= bsd_kvm_fetch_registers
;
345 bsd_kvm_ops
.to_xfer_partial
= bsd_kvm_xfer_partial
;
346 bsd_kvm_ops
.to_files_info
= bsd_kvm_files_info
;
347 bsd_kvm_ops
.to_thread_alive
= bsd_kvm_thread_alive
;
348 bsd_kvm_ops
.to_pid_to_str
= bsd_kvm_pid_to_str
;
349 bsd_kvm_ops
.to_stratum
= process_stratum
;
350 bsd_kvm_ops
.to_has_memory
= 1;
351 bsd_kvm_ops
.to_has_stack
= 1;
352 bsd_kvm_ops
.to_has_registers
= 1;
353 bsd_kvm_ops
.to_magic
= OPS_MAGIC
;
355 add_target (&bsd_kvm_ops
);
357 add_prefix_cmd ("kvm", class_obscure
, bsd_kvm_cmd
, _("\
358 Generic command for manipulating the kernel memory interface."),
359 &bsd_kvm_cmdlist
, "kvm ", 0, &cmdlist
);
361 #ifndef HAVE_STRUCT_THREAD_TD_PCB
362 add_cmd ("proc", class_obscure
, bsd_kvm_proc_cmd
,
363 _("Set current context from proc address"), &bsd_kvm_cmdlist
);
365 add_cmd ("pcb", class_obscure
, bsd_kvm_pcb_cmd
,
366 /* i18n: PCB == "Process Control Block" */
367 _("Set current context from pcb address"), &bsd_kvm_cmdlist
);
369 /* Some notes on the ptid usage on this target.
371 The pid field represents the kvm inferior instance. Currently,
372 we don't support multiple kvm inferiors, but we start at 1
373 anyway. The lwp field is set to != 0, in case the core wants to
374 refer to the whole kvm inferior with ptid(1,0,0).
376 If kvm is made to export running processes as gdb threads,
377 the following form can be used:
378 ptid (1, 1, 0) -> kvm inferior 1, in kernel
379 ptid (1, 1, 1) -> kvm inferior 1, process 1
380 ptid (1, 1, 2) -> kvm inferior 1, process 2
381 ptid (1, 1, n) -> kvm inferior 1, process n
383 bsd_kvm_ptid
= ptid_build (1, 1, 0);
This page took 0.041463 seconds and 4 git commands to generate.