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 /* Target ops for libkvm interface. */
60 static struct target_ops bsd_kvm_ops
;
62 /* This is the ptid we use while we're connected to kvm. The kvm
63 target currently doesn't export any view of the running processes,
64 so this represents the kernel task. */
65 static ptid_t bsd_kvm_ptid
;
68 bsd_kvm_open (const char *arg
, int from_tty
)
70 char errbuf
[_POSIX2_LINE_MAX
];
71 char *execfile
= NULL
;
73 char *filename
= NULL
;
75 target_preopen (from_tty
);
81 filename
= tilde_expand (arg
);
82 if (filename
[0] != '/')
84 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
90 execfile
= get_exec_file (0);
91 temp_kd
= kvm_openfiles (execfile
, filename
, NULL
,
92 write_files
? O_RDWR
: O_RDONLY
, errbuf
);
94 error (("%s"), errbuf
);
96 bsd_kvm_corefile
= filename
;
97 unpush_target (&bsd_kvm_ops
);
99 push_target (&bsd_kvm_ops
);
101 add_thread_silent (bsd_kvm_ptid
);
102 inferior_ptid
= bsd_kvm_ptid
;
104 target_fetch_registers (get_current_regcache (), -1);
106 reinit_frame_cache ();
107 print_stack_frame (get_selected_frame (NULL
), 0, SRC_AND_LOC
, 1);
111 bsd_kvm_close (struct target_ops
*self
)
115 if (kvm_close (core_kd
) == -1)
116 warning (("%s"), kvm_geterr(core_kd
));
120 inferior_ptid
= null_ptid
;
121 delete_thread_silent (bsd_kvm_ptid
);
125 bsd_kvm_xfer_memory (CORE_ADDR addr
, ULONGEST len
,
126 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
128 ssize_t nbytes
= len
;
131 nbytes
= kvm_read (core_kd
, addr
, readbuf
, nbytes
);
132 if (writebuf
&& nbytes
> 0)
133 nbytes
= kvm_write (core_kd
, addr
, writebuf
, nbytes
);
137 static enum target_xfer_status
138 bsd_kvm_xfer_partial (struct target_ops
*ops
, enum target_object object
,
139 const char *annex
, gdb_byte
*readbuf
,
140 const gdb_byte
*writebuf
,
141 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
145 case TARGET_OBJECT_MEMORY
:
147 LONGEST ret
= bsd_kvm_xfer_memory (offset
, len
, readbuf
, writebuf
);
150 return TARGET_XFER_E_IO
;
152 return TARGET_XFER_EOF
;
155 *xfered_len
= (ULONGEST
) ret
;
156 return TARGET_XFER_OK
;
161 return TARGET_XFER_E_IO
;
166 bsd_kvm_files_info (struct target_ops
*ops
)
168 if (bsd_kvm_corefile
&& strcmp (bsd_kvm_corefile
, _PATH_MEM
) != 0)
169 printf_filtered (_("\tUsing the kernel crash dump %s.\n"),
172 printf_filtered (_("\tUsing the currently running kernel.\n"));
175 /* Fetch process control block at address PADDR. */
178 bsd_kvm_fetch_pcb (struct regcache
*regcache
, struct pcb
*paddr
)
182 if (kvm_read (core_kd
, (unsigned long) paddr
, &pcb
, sizeof pcb
) == -1)
183 error (("%s"), kvm_geterr (core_kd
));
185 gdb_assert (bsd_kvm_supply_pcb
);
186 return bsd_kvm_supply_pcb (regcache
, &pcb
);
190 bsd_kvm_fetch_registers (struct target_ops
*ops
,
191 struct regcache
*regcache
, int regnum
)
197 bsd_kvm_fetch_pcb (regcache
, bsd_kvm_paddr
);
201 /* On dumping core, BSD kernels store the faulting context (PCB)
202 in the variable "dumppcb". */
203 memset (nl
, 0, sizeof nl
);
204 nl
[0].n_name
= "_dumppcb";
206 if (kvm_nlist (core_kd
, nl
) == -1)
207 error (("%s"), kvm_geterr (core_kd
));
209 if (nl
[0].n_value
!= 0)
211 /* Found dumppcb. If it contains a valid context, return
213 if (bsd_kvm_fetch_pcb (regcache
, (struct pcb
*) nl
[0].n_value
))
217 /* Traditional BSD kernels have a process proc0 that should always
218 be present. The address of proc0's PCB is stored in the variable
221 memset (nl
, 0, sizeof nl
);
222 nl
[0].n_name
= "_proc0paddr";
224 if (kvm_nlist (core_kd
, nl
) == -1)
225 error (("%s"), kvm_geterr (core_kd
));
227 if (nl
[0].n_value
!= 0)
231 /* Found proc0paddr. */
232 if (kvm_read (core_kd
, nl
[0].n_value
, &paddr
, sizeof paddr
) == -1)
233 error (("%s"), kvm_geterr (core_kd
));
235 bsd_kvm_fetch_pcb (regcache
, paddr
);
239 #ifdef HAVE_STRUCT_THREAD_TD_PCB
240 /* In FreeBSD kernels for 5.0-RELEASE and later, the PCB no longer
241 lives in `struct proc' but in `struct thread'. The `struct
242 thread' for the initial thread for proc0 can be found in the
243 variable "thread0". */
245 memset (nl
, 0, sizeof nl
);
246 nl
[0].n_name
= "_thread0";
248 if (kvm_nlist (core_kd
, nl
) == -1)
249 error (("%s"), kvm_geterr (core_kd
));
251 if (nl
[0].n_value
!= 0)
256 nl
[0].n_value
+= offsetof (struct thread
, td_pcb
);
257 if (kvm_read (core_kd
, nl
[0].n_value
, &paddr
, sizeof paddr
) == -1)
258 error (("%s"), kvm_geterr (core_kd
));
260 bsd_kvm_fetch_pcb (regcache
, paddr
);
265 /* i18n: PCB == "Process Control Block". */
266 error (_("Cannot find a valid PCB"));
270 /* Kernel memory interface commands. */
271 struct cmd_list_element
*bsd_kvm_cmdlist
;
274 bsd_kvm_cmd (const char *arg
, int fromtty
)
276 /* ??? Should this become an alias for "target kvm"? */
279 #ifndef HAVE_STRUCT_THREAD_TD_PCB
282 bsd_kvm_proc_cmd (const char *arg
, int fromtty
)
287 error_no_arg (_("proc address"));
290 error (_("No kernel memory image."));
292 addr
= parse_and_eval_address (arg
);
293 #ifdef HAVE_STRUCT_LWP
294 addr
+= offsetof (struct lwp
, l_addr
);
296 addr
+= offsetof (struct proc
, p_addr
);
299 if (kvm_read (core_kd
, addr
, &bsd_kvm_paddr
, sizeof bsd_kvm_paddr
) == -1)
300 error (("%s"), kvm_geterr (core_kd
));
302 target_fetch_registers (get_current_regcache (), -1);
304 reinit_frame_cache ();
305 print_stack_frame (get_selected_frame (NULL
), 0, SRC_AND_LOC
, 1);
311 bsd_kvm_pcb_cmd (const char *arg
, int fromtty
)
314 /* i18n: PCB == "Process Control Block". */
315 error_no_arg (_("pcb address"));
318 error (_("No kernel memory image."));
320 bsd_kvm_paddr
= (struct pcb
*)(u_long
) parse_and_eval_address (arg
);
322 target_fetch_registers (get_current_regcache (), -1);
324 reinit_frame_cache ();
325 print_stack_frame (get_selected_frame (NULL
), 0, SRC_AND_LOC
, 1);
329 bsd_kvm_thread_alive (struct target_ops
*ops
,
336 bsd_kvm_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
339 xsnprintf (buf
, sizeof buf
, "<kvm>");
344 bsd_kvm_return_one (struct target_ops
*ops
)
349 /* Add the libkvm interface to the list of all possible targets and
350 register CUPPLY_PCB as the architecture-specific process control
351 block interpreter. */
354 bsd_kvm_add_target (int (*supply_pcb
)(struct regcache
*, struct pcb
*))
356 gdb_assert (bsd_kvm_supply_pcb
== NULL
);
357 bsd_kvm_supply_pcb
= supply_pcb
;
359 bsd_kvm_ops
.to_shortname
= "kvm";
360 bsd_kvm_ops
.to_longname
= _("Kernel memory interface");
361 bsd_kvm_ops
.to_doc
= _("Use a kernel virtual memory image as a target.\n\
362 Optionally specify the filename of a core dump.");
363 bsd_kvm_ops
.to_open
= bsd_kvm_open
;
364 bsd_kvm_ops
.to_close
= bsd_kvm_close
;
365 bsd_kvm_ops
.to_fetch_registers
= bsd_kvm_fetch_registers
;
366 bsd_kvm_ops
.to_xfer_partial
= bsd_kvm_xfer_partial
;
367 bsd_kvm_ops
.to_files_info
= bsd_kvm_files_info
;
368 bsd_kvm_ops
.to_thread_alive
= bsd_kvm_thread_alive
;
369 bsd_kvm_ops
.to_pid_to_str
= bsd_kvm_pid_to_str
;
370 bsd_kvm_ops
.to_stratum
= process_stratum
;
371 bsd_kvm_ops
.to_has_memory
= bsd_kvm_return_one
;
372 bsd_kvm_ops
.to_has_stack
= bsd_kvm_return_one
;
373 bsd_kvm_ops
.to_has_registers
= bsd_kvm_return_one
;
374 bsd_kvm_ops
.to_magic
= OPS_MAGIC
;
376 add_target (&bsd_kvm_ops
);
378 add_prefix_cmd ("kvm", class_obscure
, bsd_kvm_cmd
, _("\
379 Generic command for manipulating the kernel memory interface."),
380 &bsd_kvm_cmdlist
, "kvm ", 0, &cmdlist
);
382 #ifndef HAVE_STRUCT_THREAD_TD_PCB
383 add_cmd ("proc", class_obscure
, bsd_kvm_proc_cmd
,
384 _("Set current context from proc address"), &bsd_kvm_cmdlist
);
386 add_cmd ("pcb", class_obscure
, bsd_kvm_pcb_cmd
,
387 /* i18n: PCB == "Process Control Block". */
388 _("Set current context from pcb address"), &bsd_kvm_cmdlist
);
390 /* Some notes on the ptid usage on this target.
392 The pid field represents the kvm inferior instance. Currently,
393 we don't support multiple kvm inferiors, but we start at 1
394 anyway. The lwp field is set to != 0, in case the core wants to
395 refer to the whole kvm inferior with ptid(1,0,0).
397 If kvm is made to export running processes as gdb threads,
398 the following form can be used:
399 ptid (1, 1, 0) -> kvm inferior 1, in kernel
400 ptid (1, 1, 1) -> kvm inferior 1, process 1
401 ptid (1, 1, 2) -> kvm inferior 1, process 2
402 ptid (1, 1, n) -> kvm inferior 1, process n */
404 bsd_kvm_ptid
= ptid_build (1, 1, 0);
This page took 0.037784 seconds and 4 git commands to generate.