1 /* BSD Kernel Data Access Library (libkvm) interface.
3 Copyright (C) 2004-2013 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"
43 /* Kernel memory device file. */
44 static const char *bsd_kvm_corefile
;
46 /* Kernel memory interface descriptor. */
47 static kvm_t
*core_kd
;
49 /* Address of process control block. */
50 static struct pcb
*bsd_kvm_paddr
;
52 /* Pointer to architecture-specific function that reconstructs the
53 register state from PCB and supplies it to REGCACHE. */
54 static int (*bsd_kvm_supply_pcb
)(struct regcache
*regcache
, struct pcb
*pcb
);
56 /* Target ops for libkvm interface. */
57 static struct target_ops bsd_kvm_ops
;
59 /* This is the ptid we use while we're connected to kvm. The kvm
60 target currently doesn't export any view of the running processes,
61 so this represents the kernel task. */
62 static ptid_t bsd_kvm_ptid
;
65 bsd_kvm_open (char *filename
, int from_tty
)
67 char errbuf
[_POSIX2_LINE_MAX
];
68 char *execfile
= NULL
;
71 target_preopen (from_tty
);
77 filename
= tilde_expand (filename
);
78 if (filename
[0] != '/')
80 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
86 execfile
= get_exec_file (0);
87 temp_kd
= kvm_openfiles (execfile
, filename
, NULL
,
88 write_files
? O_RDWR
: O_RDONLY
, errbuf
);
90 error (("%s"), errbuf
);
92 bsd_kvm_corefile
= filename
;
93 unpush_target (&bsd_kvm_ops
);
95 push_target (&bsd_kvm_ops
);
97 add_thread_silent (bsd_kvm_ptid
);
98 inferior_ptid
= bsd_kvm_ptid
;
100 target_fetch_registers (get_current_regcache (), -1);
102 reinit_frame_cache ();
103 print_stack_frame (get_selected_frame (NULL
), 0, SRC_AND_LOC
, 1);
111 if (kvm_close (core_kd
) == -1)
112 warning (("%s"), kvm_geterr(core_kd
));
116 inferior_ptid
= null_ptid
;
117 delete_thread_silent (bsd_kvm_ptid
);
121 bsd_kvm_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
122 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
124 ssize_t nbytes
= len
;
127 nbytes
= kvm_read (core_kd
, addr
, readbuf
, nbytes
);
128 if (writebuf
&& nbytes
> 0)
129 nbytes
= kvm_write (core_kd
, addr
, writebuf
, nbytes
);
134 bsd_kvm_xfer_partial (struct target_ops
*ops
, enum target_object object
,
135 const char *annex
, gdb_byte
*readbuf
,
136 const gdb_byte
*writebuf
,
137 ULONGEST offset
, LONGEST len
)
141 case TARGET_OBJECT_MEMORY
:
142 return bsd_kvm_xfer_memory (offset
, len
, readbuf
, writebuf
);
150 bsd_kvm_files_info (struct target_ops
*ops
)
152 if (bsd_kvm_corefile
&& strcmp (bsd_kvm_corefile
, _PATH_MEM
) != 0)
153 printf_filtered (_("\tUsing the kernel crash dump %s.\n"),
156 printf_filtered (_("\tUsing the currently running kernel.\n"));
159 /* Fetch process control block at address PADDR. */
162 bsd_kvm_fetch_pcb (struct regcache
*regcache
, struct pcb
*paddr
)
166 if (kvm_read (core_kd
, (unsigned long) paddr
, &pcb
, sizeof pcb
) == -1)
167 error (("%s"), kvm_geterr (core_kd
));
169 gdb_assert (bsd_kvm_supply_pcb
);
170 return bsd_kvm_supply_pcb (regcache
, &pcb
);
174 bsd_kvm_fetch_registers (struct target_ops
*ops
,
175 struct regcache
*regcache
, int regnum
)
181 bsd_kvm_fetch_pcb (regcache
, bsd_kvm_paddr
);
185 /* On dumping core, BSD kernels store the faulting context (PCB)
186 in the variable "dumppcb". */
187 memset (nl
, 0, sizeof nl
);
188 nl
[0].n_name
= "_dumppcb";
190 if (kvm_nlist (core_kd
, nl
) == -1)
191 error (("%s"), kvm_geterr (core_kd
));
193 if (nl
[0].n_value
!= 0)
195 /* Found dumppcb. If it contains a valid context, return
197 if (bsd_kvm_fetch_pcb (regcache
, (struct pcb
*) nl
[0].n_value
))
201 /* Traditional BSD kernels have a process proc0 that should always
202 be present. The address of proc0's PCB is stored in the variable
205 memset (nl
, 0, sizeof nl
);
206 nl
[0].n_name
= "_proc0paddr";
208 if (kvm_nlist (core_kd
, nl
) == -1)
209 error (("%s"), kvm_geterr (core_kd
));
211 if (nl
[0].n_value
!= 0)
215 /* Found proc0paddr. */
216 if (kvm_read (core_kd
, nl
[0].n_value
, &paddr
, sizeof paddr
) == -1)
217 error (("%s"), kvm_geterr (core_kd
));
219 bsd_kvm_fetch_pcb (regcache
, paddr
);
223 #ifdef HAVE_STRUCT_THREAD_TD_PCB
224 /* In FreeBSD kernels for 5.0-RELEASE and later, the PCB no longer
225 lives in `struct proc' but in `struct thread'. The `struct
226 thread' for the initial thread for proc0 can be found in the
227 variable "thread0". */
229 memset (nl
, 0, sizeof nl
);
230 nl
[0].n_name
= "_thread0";
232 if (kvm_nlist (core_kd
, nl
) == -1)
233 error (("%s"), kvm_geterr (core_kd
));
235 if (nl
[0].n_value
!= 0)
240 nl
[0].n_value
+= offsetof (struct thread
, td_pcb
);
241 if (kvm_read (core_kd
, nl
[0].n_value
, &paddr
, sizeof paddr
) == -1)
242 error (("%s"), kvm_geterr (core_kd
));
244 bsd_kvm_fetch_pcb (regcache
, paddr
);
249 /* i18n: PCB == "Process Control Block". */
250 error (_("Cannot find a valid PCB"));
254 /* Kernel memory interface commands. */
255 struct cmd_list_element
*bsd_kvm_cmdlist
;
258 bsd_kvm_cmd (char *arg
, int fromtty
)
260 /* ??? Should this become an alias for "target kvm"? */
263 #ifndef HAVE_STRUCT_THREAD_TD_PCB
266 bsd_kvm_proc_cmd (char *arg
, int fromtty
)
271 error_no_arg (_("proc address"));
274 error (_("No kernel memory image."));
276 addr
= parse_and_eval_address (arg
);
277 #ifdef HAVE_STRUCT_LWP
278 addr
+= offsetof (struct lwp
, l_addr
);
280 addr
+= offsetof (struct proc
, p_addr
);
283 if (kvm_read (core_kd
, addr
, &bsd_kvm_paddr
, sizeof bsd_kvm_paddr
) == -1)
284 error (("%s"), kvm_geterr (core_kd
));
286 target_fetch_registers (get_current_regcache (), -1);
288 reinit_frame_cache ();
289 print_stack_frame (get_selected_frame (NULL
), 0, SRC_AND_LOC
, 1);
295 bsd_kvm_pcb_cmd (char *arg
, int fromtty
)
298 /* i18n: PCB == "Process Control Block". */
299 error_no_arg (_("pcb address"));
302 error (_("No kernel memory image."));
304 bsd_kvm_paddr
= (struct pcb
*)(u_long
) parse_and_eval_address (arg
);
306 target_fetch_registers (get_current_regcache (), -1);
308 reinit_frame_cache ();
309 print_stack_frame (get_selected_frame (NULL
), 0, SRC_AND_LOC
, 1);
313 bsd_kvm_thread_alive (struct target_ops
*ops
,
320 bsd_kvm_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
323 xsnprintf (buf
, sizeof buf
, "<kvm>");
328 bsd_kvm_return_one (struct target_ops
*ops
)
333 /* Add the libkvm interface to the list of all possible targets and
334 register CUPPLY_PCB as the architecture-specific process control
335 block interpreter. */
338 bsd_kvm_add_target (int (*supply_pcb
)(struct regcache
*, struct pcb
*))
340 gdb_assert (bsd_kvm_supply_pcb
== NULL
);
341 bsd_kvm_supply_pcb
= supply_pcb
;
343 bsd_kvm_ops
.to_shortname
= "kvm";
344 bsd_kvm_ops
.to_longname
= _("Kernel memory interface");
345 bsd_kvm_ops
.to_doc
= _("Use a kernel virtual memory image as a target.\n\
346 Optionally specify the filename of a core dump.");
347 bsd_kvm_ops
.to_open
= bsd_kvm_open
;
348 bsd_kvm_ops
.to_close
= bsd_kvm_close
;
349 bsd_kvm_ops
.to_fetch_registers
= bsd_kvm_fetch_registers
;
350 bsd_kvm_ops
.to_xfer_partial
= bsd_kvm_xfer_partial
;
351 bsd_kvm_ops
.to_files_info
= bsd_kvm_files_info
;
352 bsd_kvm_ops
.to_thread_alive
= bsd_kvm_thread_alive
;
353 bsd_kvm_ops
.to_pid_to_str
= bsd_kvm_pid_to_str
;
354 bsd_kvm_ops
.to_stratum
= process_stratum
;
355 bsd_kvm_ops
.to_has_memory
= bsd_kvm_return_one
;
356 bsd_kvm_ops
.to_has_stack
= bsd_kvm_return_one
;
357 bsd_kvm_ops
.to_has_registers
= bsd_kvm_return_one
;
358 bsd_kvm_ops
.to_magic
= OPS_MAGIC
;
360 add_target (&bsd_kvm_ops
);
362 add_prefix_cmd ("kvm", class_obscure
, bsd_kvm_cmd
, _("\
363 Generic command for manipulating the kernel memory interface."),
364 &bsd_kvm_cmdlist
, "kvm ", 0, &cmdlist
);
366 #ifndef HAVE_STRUCT_THREAD_TD_PCB
367 add_cmd ("proc", class_obscure
, bsd_kvm_proc_cmd
,
368 _("Set current context from proc address"), &bsd_kvm_cmdlist
);
370 add_cmd ("pcb", class_obscure
, bsd_kvm_pcb_cmd
,
371 /* i18n: PCB == "Process Control Block". */
372 _("Set current context from pcb address"), &bsd_kvm_cmdlist
);
374 /* Some notes on the ptid usage on this target.
376 The pid field represents the kvm inferior instance. Currently,
377 we don't support multiple kvm inferiors, but we start at 1
378 anyway. The lwp field is set to != 0, in case the core wants to
379 refer to the whole kvm inferior with ptid(1,0,0).
381 If kvm is made to export running processes as gdb threads,
382 the following form can be used:
383 ptid (1, 1, 0) -> kvm inferior 1, in kernel
384 ptid (1, 1, 1) -> kvm inferior 1, process 1
385 ptid (1, 1, 2) -> kvm inferior 1, process 2
386 ptid (1, 1, n) -> kvm inferior 1, process n */
388 bsd_kvm_ptid
= ptid_build (1, 1, 0);
This page took 0.036042 seconds and 4 git commands to generate.