1 /* BSD Kernel Data Access Library (libkvm) interface.
3 Copyright (C) 2004-2018 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/>. */
22 #include "cli/cli-cmds.h"
28 #include "gdbcore.h" /* for get_exec_file */
29 #include "gdbthread.h"
37 #include "readline/readline.h"
38 #include <sys/param.h>
40 #ifdef HAVE_SYS_USER_H
46 /* Kernel memory device file. */
47 static const char *bsd_kvm_corefile
;
49 /* Kernel memory interface descriptor. */
50 static kvm_t
*core_kd
;
52 /* Address of process control block. */
53 static struct pcb
*bsd_kvm_paddr
;
55 /* Pointer to architecture-specific function that reconstructs the
56 register state from PCB and supplies it to REGCACHE. */
57 static int (*bsd_kvm_supply_pcb
)(struct regcache
*regcache
, struct pcb
*pcb
);
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
;
64 /* The libkvm target. */
66 class bsd_kvm_target final
: public target_ops
70 { this->to_stratum
= process_stratum
; }
72 const char *shortname () override
75 const char *longname () override
76 { return _("Kernel memory interface"); }
78 const char *doc () override
80 return _("Use a kernel virtual memory image as a target.\n\
81 Optionally specify the filename of a core dump.");
84 void open (const char *, int) override
;
85 void close () override
;
87 void fetch_registers (struct regcache
*, int) override
;
88 enum target_xfer_status
xfer_partial (enum target_object object
,
91 const gdb_byte
*writebuf
,
92 ULONGEST offset
, ULONGEST len
,
93 ULONGEST
*xfered_len
) override
;
95 void files_info () override
;
96 int thread_alive (ptid_t ptid
) override
;
97 const char *pid_to_str (ptid_t
) override
;
99 int has_memory () override
{ return 1; }
100 int has_stack () override
{ return 1; }
101 int has_registers () override
{ return 1; }
104 /* Target ops for libkvm interface. */
105 static bsd_kvm_target bsd_kvm_ops
;
108 bsd_kvm_target::open (const char *arg
, int from_tty
)
110 char errbuf
[_POSIX2_LINE_MAX
];
111 char *execfile
= NULL
;
113 char *filename
= NULL
;
115 target_preopen (from_tty
);
121 filename
= tilde_expand (arg
);
122 if (filename
[0] != '/')
124 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
130 execfile
= get_exec_file (0);
131 temp_kd
= kvm_openfiles (execfile
, filename
, NULL
,
132 write_files
? O_RDWR
: O_RDONLY
, errbuf
);
134 error (("%s"), errbuf
);
136 bsd_kvm_corefile
= filename
;
137 unpush_target (&bsd_kvm_ops
);
139 push_target (&bsd_kvm_ops
);
141 add_thread_silent (bsd_kvm_ptid
);
142 inferior_ptid
= bsd_kvm_ptid
;
144 target_fetch_registers (get_current_regcache (), -1);
146 reinit_frame_cache ();
147 print_stack_frame (get_selected_frame (NULL
), 0, SRC_AND_LOC
, 1);
151 bsd_kvm_target::close ()
155 if (kvm_close (core_kd
) == -1)
156 warning (("%s"), kvm_geterr(core_kd
));
160 inferior_ptid
= null_ptid
;
161 delete_thread_silent (bsd_kvm_ptid
);
165 bsd_kvm_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
166 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
168 ssize_t nbytes
= len
;
171 nbytes
= kvm_read (core_kd
, addr
, readbuf
, nbytes
);
172 if (writebuf
&& nbytes
> 0)
173 nbytes
= kvm_write (core_kd
, addr
, writebuf
, nbytes
);
177 enum target_xfer_status
178 bsd_kvm_target::xfer_partial (enum target_object object
,
179 const char *annex
, gdb_byte
*readbuf
,
180 const gdb_byte
*writebuf
,
181 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
185 case TARGET_OBJECT_MEMORY
:
187 LONGEST ret
= bsd_kvm_xfer_memory (offset
, len
, readbuf
, writebuf
);
190 return TARGET_XFER_E_IO
;
192 return TARGET_XFER_EOF
;
195 *xfered_len
= (ULONGEST
) ret
;
196 return TARGET_XFER_OK
;
201 return TARGET_XFER_E_IO
;
206 bsd_kvm_target::files_info ()
208 if (bsd_kvm_corefile
&& strcmp (bsd_kvm_corefile
, _PATH_MEM
) != 0)
209 printf_filtered (_("\tUsing the kernel crash dump %s.\n"),
212 printf_filtered (_("\tUsing the currently running kernel.\n"));
215 /* Fetch process control block at address PADDR. */
218 bsd_kvm_fetch_pcb (struct regcache
*regcache
, struct pcb
*paddr
)
222 if (kvm_read (core_kd
, (unsigned long) paddr
, &pcb
, sizeof pcb
) == -1)
223 error (("%s"), kvm_geterr (core_kd
));
225 gdb_assert (bsd_kvm_supply_pcb
);
226 return bsd_kvm_supply_pcb (regcache
, &pcb
);
230 bsd_kvm_target::fetch_registers (struct regcache
*regcache
, int regnum
)
236 bsd_kvm_fetch_pcb (regcache
, bsd_kvm_paddr
);
240 /* On dumping core, BSD kernels store the faulting context (PCB)
241 in the variable "dumppcb". */
242 memset (nl
, 0, sizeof nl
);
243 nl
[0].n_name
= "_dumppcb";
245 if (kvm_nlist (core_kd
, nl
) == -1)
246 error (("%s"), kvm_geterr (core_kd
));
248 if (nl
[0].n_value
!= 0)
250 /* Found dumppcb. If it contains a valid context, return
252 if (bsd_kvm_fetch_pcb (regcache
, (struct pcb
*) nl
[0].n_value
))
256 /* Traditional BSD kernels have a process proc0 that should always
257 be present. The address of proc0's PCB is stored in the variable
260 memset (nl
, 0, sizeof nl
);
261 nl
[0].n_name
= "_proc0paddr";
263 if (kvm_nlist (core_kd
, nl
) == -1)
264 error (("%s"), kvm_geterr (core_kd
));
266 if (nl
[0].n_value
!= 0)
270 /* Found proc0paddr. */
271 if (kvm_read (core_kd
, nl
[0].n_value
, &paddr
, sizeof paddr
) == -1)
272 error (("%s"), kvm_geterr (core_kd
));
274 bsd_kvm_fetch_pcb (regcache
, paddr
);
278 #ifdef HAVE_STRUCT_THREAD_TD_PCB
279 /* In FreeBSD kernels for 5.0-RELEASE and later, the PCB no longer
280 lives in `struct proc' but in `struct thread'. The `struct
281 thread' for the initial thread for proc0 can be found in the
282 variable "thread0". */
284 memset (nl
, 0, sizeof nl
);
285 nl
[0].n_name
= "_thread0";
287 if (kvm_nlist (core_kd
, nl
) == -1)
288 error (("%s"), kvm_geterr (core_kd
));
290 if (nl
[0].n_value
!= 0)
295 nl
[0].n_value
+= offsetof (struct thread
, td_pcb
);
296 if (kvm_read (core_kd
, nl
[0].n_value
, &paddr
, sizeof paddr
) == -1)
297 error (("%s"), kvm_geterr (core_kd
));
299 bsd_kvm_fetch_pcb (regcache
, paddr
);
304 /* i18n: PCB == "Process Control Block". */
305 error (_("Cannot find a valid PCB"));
309 /* Kernel memory interface commands. */
310 struct cmd_list_element
*bsd_kvm_cmdlist
;
313 bsd_kvm_cmd (const char *arg
, int fromtty
)
315 /* ??? Should this become an alias for "target kvm"? */
318 #ifndef HAVE_STRUCT_THREAD_TD_PCB
321 bsd_kvm_proc_cmd (const char *arg
, int fromtty
)
326 error_no_arg (_("proc address"));
329 error (_("No kernel memory image."));
331 addr
= parse_and_eval_address (arg
);
332 #ifdef HAVE_STRUCT_LWP
333 addr
+= offsetof (struct lwp
, l_addr
);
335 addr
+= offsetof (struct proc
, p_addr
);
338 if (kvm_read (core_kd
, addr
, &bsd_kvm_paddr
, sizeof bsd_kvm_paddr
) == -1)
339 error (("%s"), kvm_geterr (core_kd
));
341 target_fetch_registers (get_current_regcache (), -1);
343 reinit_frame_cache ();
344 print_stack_frame (get_selected_frame (NULL
), 0, SRC_AND_LOC
, 1);
350 bsd_kvm_pcb_cmd (const char *arg
, int fromtty
)
353 /* i18n: PCB == "Process Control Block". */
354 error_no_arg (_("pcb address"));
357 error (_("No kernel memory image."));
359 bsd_kvm_paddr
= (struct pcb
*)(u_long
) parse_and_eval_address (arg
);
361 target_fetch_registers (get_current_regcache (), -1);
363 reinit_frame_cache ();
364 print_stack_frame (get_selected_frame (NULL
), 0, SRC_AND_LOC
, 1);
368 bsd_kvm_target::thread_alive (ptid_t ptid
)
374 bsd_kvm_target::pid_to_str (ptid_t ptid
)
377 xsnprintf (buf
, sizeof buf
, "<kvm>");
381 /* Add the libkvm interface to the list of all possible targets and
382 register CUPPLY_PCB as the architecture-specific process control
383 block interpreter. */
386 bsd_kvm_add_target (int (*supply_pcb
)(struct regcache
*, struct pcb
*))
388 gdb_assert (bsd_kvm_supply_pcb
== NULL
);
389 bsd_kvm_supply_pcb
= supply_pcb
;
391 add_target (&bsd_kvm_ops
);
393 add_prefix_cmd ("kvm", class_obscure
, bsd_kvm_cmd
, _("\
394 Generic command for manipulating the kernel memory interface."),
395 &bsd_kvm_cmdlist
, "kvm ", 0, &cmdlist
);
397 #ifndef HAVE_STRUCT_THREAD_TD_PCB
398 add_cmd ("proc", class_obscure
, bsd_kvm_proc_cmd
,
399 _("Set current context from proc address"), &bsd_kvm_cmdlist
);
401 add_cmd ("pcb", class_obscure
, bsd_kvm_pcb_cmd
,
402 /* i18n: PCB == "Process Control Block". */
403 _("Set current context from pcb address"), &bsd_kvm_cmdlist
);
405 /* Some notes on the ptid usage on this target.
407 The pid field represents the kvm inferior instance. Currently,
408 we don't support multiple kvm inferiors, but we start at 1
409 anyway. The lwp field is set to != 0, in case the core wants to
410 refer to the whole kvm inferior with ptid(1,0,0).
412 If kvm is made to export running processes as gdb threads,
413 the following form can be used:
414 ptid (1, 1, 0) -> kvm inferior 1, in kernel
415 ptid (1, 1, 1) -> kvm inferior 1, process 1
416 ptid (1, 1, 2) -> kvm inferior 1, process 2
417 ptid (1, 1, n) -> kvm inferior 1, process n */
419 bsd_kvm_ptid
= ptid_build (1, 1, 0);