1 /* BSD Kernel Data Access Library (libkvm) interface.
3 Copyright (C) 2004-2017 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"
36 #include "readline/readline.h"
37 #include <sys/param.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 (const char *arg
, int from_tty
)
67 char errbuf
[_POSIX2_LINE_MAX
];
68 char *execfile
= NULL
;
70 char *filename
= NULL
;
72 target_preopen (from_tty
);
78 filename
= tilde_expand (arg
);
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
), 0, SRC_AND_LOC
, 1);
108 bsd_kvm_close (struct target_ops
*self
)
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
);
134 static enum target_xfer_status
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
, ULONGEST len
, ULONGEST
*xfered_len
)
142 case TARGET_OBJECT_MEMORY
:
144 LONGEST ret
= bsd_kvm_xfer_memory (offset
, len
, readbuf
, writebuf
);
147 return TARGET_XFER_E_IO
;
149 return TARGET_XFER_EOF
;
152 *xfered_len
= (ULONGEST
) ret
;
153 return TARGET_XFER_OK
;
158 return TARGET_XFER_E_IO
;
163 bsd_kvm_files_info (struct target_ops
*ops
)
165 if (bsd_kvm_corefile
&& strcmp (bsd_kvm_corefile
, _PATH_MEM
) != 0)
166 printf_filtered (_("\tUsing the kernel crash dump %s.\n"),
169 printf_filtered (_("\tUsing the currently running kernel.\n"));
172 /* Fetch process control block at address PADDR. */
175 bsd_kvm_fetch_pcb (struct regcache
*regcache
, struct pcb
*paddr
)
179 if (kvm_read (core_kd
, (unsigned long) paddr
, &pcb
, sizeof pcb
) == -1)
180 error (("%s"), kvm_geterr (core_kd
));
182 gdb_assert (bsd_kvm_supply_pcb
);
183 return bsd_kvm_supply_pcb (regcache
, &pcb
);
187 bsd_kvm_fetch_registers (struct target_ops
*ops
,
188 struct regcache
*regcache
, int regnum
)
194 bsd_kvm_fetch_pcb (regcache
, bsd_kvm_paddr
);
198 /* On dumping core, BSD kernels store the faulting context (PCB)
199 in the variable "dumppcb". */
200 memset (nl
, 0, sizeof nl
);
201 nl
[0].n_name
= "_dumppcb";
203 if (kvm_nlist (core_kd
, nl
) == -1)
204 error (("%s"), kvm_geterr (core_kd
));
206 if (nl
[0].n_value
!= 0)
208 /* Found dumppcb. If it contains a valid context, return
210 if (bsd_kvm_fetch_pcb (regcache
, (struct pcb
*) nl
[0].n_value
))
214 /* Traditional BSD kernels have a process proc0 that should always
215 be present. The address of proc0's PCB is stored in the variable
218 memset (nl
, 0, sizeof nl
);
219 nl
[0].n_name
= "_proc0paddr";
221 if (kvm_nlist (core_kd
, nl
) == -1)
222 error (("%s"), kvm_geterr (core_kd
));
224 if (nl
[0].n_value
!= 0)
228 /* Found proc0paddr. */
229 if (kvm_read (core_kd
, nl
[0].n_value
, &paddr
, sizeof paddr
) == -1)
230 error (("%s"), kvm_geterr (core_kd
));
232 bsd_kvm_fetch_pcb (regcache
, paddr
);
236 #ifdef HAVE_STRUCT_THREAD_TD_PCB
237 /* In FreeBSD kernels for 5.0-RELEASE and later, the PCB no longer
238 lives in `struct proc' but in `struct thread'. The `struct
239 thread' for the initial thread for proc0 can be found in the
240 variable "thread0". */
242 memset (nl
, 0, sizeof nl
);
243 nl
[0].n_name
= "_thread0";
245 if (kvm_nlist (core_kd
, nl
) == -1)
246 error (("%s"), kvm_geterr (core_kd
));
248 if (nl
[0].n_value
!= 0)
253 nl
[0].n_value
+= offsetof (struct thread
, td_pcb
);
254 if (kvm_read (core_kd
, nl
[0].n_value
, &paddr
, sizeof paddr
) == -1)
255 error (("%s"), kvm_geterr (core_kd
));
257 bsd_kvm_fetch_pcb (regcache
, paddr
);
262 /* i18n: PCB == "Process Control Block". */
263 error (_("Cannot find a valid PCB"));
267 /* Kernel memory interface commands. */
268 struct cmd_list_element
*bsd_kvm_cmdlist
;
271 bsd_kvm_cmd (char *arg
, int fromtty
)
273 /* ??? Should this become an alias for "target kvm"? */
276 #ifndef HAVE_STRUCT_THREAD_TD_PCB
279 bsd_kvm_proc_cmd (char *arg
, int fromtty
)
284 error_no_arg (_("proc address"));
287 error (_("No kernel memory image."));
289 addr
= parse_and_eval_address (arg
);
290 #ifdef HAVE_STRUCT_LWP
291 addr
+= offsetof (struct lwp
, l_addr
);
293 addr
+= offsetof (struct proc
, p_addr
);
296 if (kvm_read (core_kd
, addr
, &bsd_kvm_paddr
, sizeof bsd_kvm_paddr
) == -1)
297 error (("%s"), kvm_geterr (core_kd
));
299 target_fetch_registers (get_current_regcache (), -1);
301 reinit_frame_cache ();
302 print_stack_frame (get_selected_frame (NULL
), 0, SRC_AND_LOC
, 1);
308 bsd_kvm_pcb_cmd (char *arg
, int fromtty
)
311 /* i18n: PCB == "Process Control Block". */
312 error_no_arg (_("pcb address"));
315 error (_("No kernel memory image."));
317 bsd_kvm_paddr
= (struct pcb
*)(u_long
) parse_and_eval_address (arg
);
319 target_fetch_registers (get_current_regcache (), -1);
321 reinit_frame_cache ();
322 print_stack_frame (get_selected_frame (NULL
), 0, SRC_AND_LOC
, 1);
326 bsd_kvm_thread_alive (struct target_ops
*ops
,
333 bsd_kvm_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
336 xsnprintf (buf
, sizeof buf
, "<kvm>");
341 bsd_kvm_return_one (struct target_ops
*ops
)
346 /* Add the libkvm interface to the list of all possible targets and
347 register CUPPLY_PCB as the architecture-specific process control
348 block interpreter. */
351 bsd_kvm_add_target (int (*supply_pcb
)(struct regcache
*, struct pcb
*))
353 gdb_assert (bsd_kvm_supply_pcb
== NULL
);
354 bsd_kvm_supply_pcb
= supply_pcb
;
356 bsd_kvm_ops
.to_shortname
= "kvm";
357 bsd_kvm_ops
.to_longname
= _("Kernel memory interface");
358 bsd_kvm_ops
.to_doc
= _("Use a kernel virtual memory image as a target.\n\
359 Optionally specify the filename of a core dump.");
360 bsd_kvm_ops
.to_open
= bsd_kvm_open
;
361 bsd_kvm_ops
.to_close
= bsd_kvm_close
;
362 bsd_kvm_ops
.to_fetch_registers
= bsd_kvm_fetch_registers
;
363 bsd_kvm_ops
.to_xfer_partial
= bsd_kvm_xfer_partial
;
364 bsd_kvm_ops
.to_files_info
= bsd_kvm_files_info
;
365 bsd_kvm_ops
.to_thread_alive
= bsd_kvm_thread_alive
;
366 bsd_kvm_ops
.to_pid_to_str
= bsd_kvm_pid_to_str
;
367 bsd_kvm_ops
.to_stratum
= process_stratum
;
368 bsd_kvm_ops
.to_has_memory
= bsd_kvm_return_one
;
369 bsd_kvm_ops
.to_has_stack
= bsd_kvm_return_one
;
370 bsd_kvm_ops
.to_has_registers
= bsd_kvm_return_one
;
371 bsd_kvm_ops
.to_magic
= OPS_MAGIC
;
373 add_target (&bsd_kvm_ops
);
375 add_prefix_cmd ("kvm", class_obscure
, bsd_kvm_cmd
, _("\
376 Generic command for manipulating the kernel memory interface."),
377 &bsd_kvm_cmdlist
, "kvm ", 0, &cmdlist
);
379 #ifndef HAVE_STRUCT_THREAD_TD_PCB
380 add_cmd ("proc", class_obscure
, bsd_kvm_proc_cmd
,
381 _("Set current context from proc address"), &bsd_kvm_cmdlist
);
383 add_cmd ("pcb", class_obscure
, bsd_kvm_pcb_cmd
,
384 /* i18n: PCB == "Process Control Block". */
385 _("Set current context from pcb address"), &bsd_kvm_cmdlist
);
387 /* Some notes on the ptid usage on this target.
389 The pid field represents the kvm inferior instance. Currently,
390 we don't support multiple kvm inferiors, but we start at 1
391 anyway. The lwp field is set to != 0, in case the core wants to
392 refer to the whole kvm inferior with ptid(1,0,0).
394 If kvm is made to export running processes as gdb threads,
395 the following form can be used:
396 ptid (1, 1, 0) -> kvm inferior 1, in kernel
397 ptid (1, 1, 1) -> kvm inferior 1, process 1
398 ptid (1, 1, 2) -> kvm inferior 1, process 2
399 ptid (1, 1, n) -> kvm inferior 1, process n */
401 bsd_kvm_ptid
= ptid_build (1, 1, 0);
This page took 0.037899 seconds and 4 git commands to generate.