GDB (xrefs)
/tmp/gdb-7.10/gdb/bsd-kvm.c
Go to the documentation of this file.
1 /* BSD Kernel Data Access Library (libkvm) interface.
2 
3  Copyright (C) 2004-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
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.
11 
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.
16 
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/>. */
19 
20 #include "defs.h"
21 #include "cli/cli-cmds.h"
22 #include "command.h"
23 #include "frame.h"
24 #include "regcache.h"
25 #include "target.h"
26 #include "value.h"
27 #include "gdbcore.h" /* for get_exec_file */
28 #include "gdbthread.h"
29 
30 #include <fcntl.h>
31 #include <kvm.h>
32 #ifdef HAVE_NLIST_H
33 #include <nlist.h>
34 #endif
35 #include <paths.h>
36 #include "readline/readline.h"
37 #include <sys/param.h>
38 #include <sys/proc.h>
39 #include <sys/user.h>
40 
41 #include "bsd-kvm.h"
42 
43 /* Kernel memory device file. */
44 static const char *bsd_kvm_corefile;
45 
46 /* Kernel memory interface descriptor. */
47 static kvm_t *core_kd;
48 
49 /* Address of process control block. */
50 static struct pcb *bsd_kvm_paddr;
51 
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);
55 
56 /* Target ops for libkvm interface. */
57 static struct target_ops bsd_kvm_ops;
58 
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. */
63 
64 static void
65 bsd_kvm_open (const char *arg, int from_tty)
66 {
67  char errbuf[_POSIX2_LINE_MAX];
68  char *execfile = NULL;
69  kvm_t *temp_kd;
70  char *filename = NULL;
71 
72  target_preopen (from_tty);
73 
74  if (arg)
75  {
76  char *temp;
77 
78  filename = tilde_expand (arg);
79  if (filename[0] != '/')
80  {
81  temp = concat (current_directory, "/", filename, (char *)NULL);
82  xfree (filename);
83  filename = temp;
84  }
85  }
86 
87  execfile = get_exec_file (0);
88  temp_kd = kvm_openfiles (execfile, filename, NULL,
89  write_files ? O_RDWR : O_RDONLY, errbuf);
90  if (temp_kd == NULL)
91  error (("%s"), errbuf);
92 
93  bsd_kvm_corefile = filename;
95  core_kd = temp_kd;
97 
98  add_thread_silent (bsd_kvm_ptid);
100 
102 
105 }
106 
107 static void
108 bsd_kvm_close (struct target_ops *self)
109 {
110  if (core_kd)
111  {
112  if (kvm_close (core_kd) == -1)
113  warning (("%s"), kvm_geterr(core_kd));
114  core_kd = NULL;
115  }
116 
118  delete_thread_silent (bsd_kvm_ptid);
119 }
120 
121 static LONGEST
123  gdb_byte *readbuf, const gdb_byte *writebuf)
124 {
125  ssize_t nbytes = len;
126 
127  if (readbuf)
128  nbytes = kvm_read (core_kd, addr, readbuf, nbytes);
129  if (writebuf && nbytes > 0)
130  nbytes = kvm_write (core_kd, addr, writebuf, nbytes);
131  return nbytes;
132 }
133 
134 static enum target_xfer_status
136  const char *annex, gdb_byte *readbuf,
137  const gdb_byte *writebuf,
138  ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
139 {
140  switch (object)
141  {
143  {
144  LONGEST ret = bsd_kvm_xfer_memory (offset, len, readbuf, writebuf);
145 
146  if (ret < 0)
147  return TARGET_XFER_E_IO;
148  else if (ret == 0)
149  return TARGET_XFER_EOF;
150  else
151  {
152  *xfered_len = (ULONGEST) ret;
153  return TARGET_XFER_OK;
154  }
155  }
156 
157  default:
158  return TARGET_XFER_E_IO;
159  }
160 }
161 
162 static void
164 {
165  if (bsd_kvm_corefile && strcmp (bsd_kvm_corefile, _PATH_MEM) != 0)
166  printf_filtered (_("\tUsing the kernel crash dump %s.\n"),
167  bsd_kvm_corefile);
168  else
169  printf_filtered (_("\tUsing the currently running kernel.\n"));
170 }
171 
172 /* Fetch process control block at address PADDR. */
173 
174 static int
175 bsd_kvm_fetch_pcb (struct regcache *regcache, struct pcb *paddr)
176 {
177  struct pcb pcb;
178 
179  if (kvm_read (core_kd, (unsigned long) paddr, &pcb, sizeof pcb) == -1)
180  error (("%s"), kvm_geterr (core_kd));
181 
183  return bsd_kvm_supply_pcb (regcache, &pcb);
184 }
185 
186 static void
188  struct regcache *regcache, int regnum)
189 {
190  struct nlist nl[2];
191 
192  if (bsd_kvm_paddr)
193  {
194  bsd_kvm_fetch_pcb (regcache, bsd_kvm_paddr);
195  return;
196  }
197 
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";
202 
203  if (kvm_nlist (core_kd, nl) == -1)
204  error (("%s"), kvm_geterr (core_kd));
205 
206  if (nl[0].n_value != 0)
207  {
208  /* Found dumppcb. If it contains a valid context, return
209  immediately. */
210  if (bsd_kvm_fetch_pcb (regcache, (struct pcb *) nl[0].n_value))
211  return;
212  }
213 
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
216  "proc0paddr". */
217 
218  memset (nl, 0, sizeof nl);
219  nl[0].n_name = "_proc0paddr";
220 
221  if (kvm_nlist (core_kd, nl) == -1)
222  error (("%s"), kvm_geterr (core_kd));
223 
224  if (nl[0].n_value != 0)
225  {
226  struct pcb *paddr;
227 
228  /* Found proc0paddr. */
229  if (kvm_read (core_kd, nl[0].n_value, &paddr, sizeof paddr) == -1)
230  error (("%s"), kvm_geterr (core_kd));
231 
232  bsd_kvm_fetch_pcb (regcache, paddr);
233  return;
234  }
235 
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". */
241 
242  memset (nl, 0, sizeof nl);
243  nl[0].n_name = "_thread0";
244 
245  if (kvm_nlist (core_kd, nl) == -1)
246  error (("%s"), kvm_geterr (core_kd));
247 
248  if (nl[0].n_value != 0)
249  {
250  struct pcb *paddr;
251 
252  /* Found thread0. */
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));
256 
257  bsd_kvm_fetch_pcb (regcache, paddr);
258  return;
259  }
260 #endif
261 
262  /* i18n: PCB == "Process Control Block". */
263  error (_("Cannot find a valid PCB"));
264 }
265 
266 
267 /* Kernel memory interface commands. */
269 
270 static void
271 bsd_kvm_cmd (char *arg, int fromtty)
272 {
273  /* ??? Should this become an alias for "target kvm"? */
274 }
275 
276 #ifndef HAVE_STRUCT_THREAD_TD_PCB
277 
278 static void
279 bsd_kvm_proc_cmd (char *arg, int fromtty)
280 {
281  CORE_ADDR addr;
282 
283  if (arg == NULL)
284  error_no_arg (_("proc address"));
285 
286  if (core_kd == NULL)
287  error (_("No kernel memory image."));
288 
289  addr = parse_and_eval_address (arg);
290 #ifdef HAVE_STRUCT_LWP
291  addr += offsetof (struct lwp, l_addr);
292 #else
293  addr += offsetof (struct proc, p_addr);
294 #endif
295 
296  if (kvm_read (core_kd, addr, &bsd_kvm_paddr, sizeof bsd_kvm_paddr) == -1)
297  error (("%s"), kvm_geterr (core_kd));
298 
300 
303 }
304 
305 #endif
306 
307 static void
308 bsd_kvm_pcb_cmd (char *arg, int fromtty)
309 {
310  if (arg == NULL)
311  /* i18n: PCB == "Process Control Block". */
312  error_no_arg (_("pcb address"));
313 
314  if (core_kd == NULL)
315  error (_("No kernel memory image."));
316 
317  bsd_kvm_paddr = (struct pcb *)(u_long) parse_and_eval_address (arg);
318 
320 
323 }
324 
325 static int
327  ptid_t ptid)
328 {
329  return 1;
330 }
331 
332 static char *
334 {
335  static char buf[64];
336  xsnprintf (buf, sizeof buf, "<kvm>");
337  return buf;
338 }
339 
340 static int
342 {
343  return 1;
344 }
345 
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. */
349 
350 void
351 bsd_kvm_add_target (int (*supply_pcb)(struct regcache *, struct pcb *))
352 {
353  gdb_assert (bsd_kvm_supply_pcb == NULL);
354  bsd_kvm_supply_pcb = supply_pcb;
355 
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.");
372 
374 
376 Generic command for manipulating the kernel memory interface."),
377  &bsd_kvm_cmdlist, "kvm ", 0, &cmdlist);
378 
379 #ifndef HAVE_STRUCT_THREAD_TD_PCB
381  _("Set current context from proc address"), &bsd_kvm_cmdlist);
382 #endif
384  /* i18n: PCB == "Process Control Block". */
385  _("Set current context from pcb address"), &bsd_kvm_cmdlist);
386 
387  /* Some notes on the ptid usage on this target.
388 
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).
393 
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 */
400 
401  bsd_kvm_ptid = ptid_build (1, 1, 0);
402 }
void error_no_arg(const char *why)
Definition: cli-cmds.c:205
void add_target(struct target_ops *t)
Definition: target.c:395
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:338
static void bsd_kvm_proc_cmd(char *arg, int fromtty)
Definition: bsd-kvm.c:279
static void bsd_kvm_open(const char *arg, int from_tty)
Definition: bsd-kvm.c:65
static int(* bsd_kvm_supply_pcb)(struct regcache *regcache, struct pcb *pcb)
Definition: bsd-kvm.c:54
static kvm_t * core_kd
Definition: bsd-kvm.c:47
static ptid_t bsd_kvm_ptid
Definition: bsd-kvm.c:62
const char * to_longname
Definition: target.h:433
struct cmd_list_element * bsd_kvm_cmdlist
Definition: bsd-kvm.c:268
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1535
bfd_vma CORE_ADDR
Definition: common-types.h:41
void xfree(void *)
Definition: common-utils.c:97
int(* to_has_memory)(struct target_ops *)
Definition: target.h:652
void warning(const char *fmt,...)
Definition: errors.c:26
char *(* to_pid_to_str)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_pid_to_str)
Definition: target.h:631
static void bsd_kvm_cmd(char *arg, int fromtty)
Definition: bsd-kvm.c:271
int(* to_has_stack)(struct target_ops *)
Definition: target.h:653
void push_target(struct target_ops *t)
Definition: target.c:664
void delete_thread_silent(ptid_t)
Definition: thread.c:374
int unpush_target(struct target_ops *t)
Definition: target.c:711
static enum target_xfer_status bsd_kvm_xfer_partial(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition: bsd-kvm.c:135
void(* to_close)(struct target_ops *)
Definition: target.h:448
static void bsd_kvm_pcb_cmd(char *arg, int fromtty)
Definition: bsd-kvm.c:308
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:103
void target_fetch_registers(struct regcache *regcache, int regno)
Definition: target.c:3419
#define _(String)
Definition: gdb_locale.h:40
struct regcache * get_current_regcache(void)
Definition: regcache.c:541
void printf_filtered(const char *format,...)
Definition: utils.c:2388
Definition: ptid.h:35
ptid_t ptid_build(int pid, long lwp, long tid)
Definition: ptid.c:31
void(* to_files_info)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:479
#define OPS_MAGIC
Definition: target.h:1233
Definition: gnu-nat.h:42
int write_files
Definition: exec.c:67
unsigned long u_long
Definition: ser-go32.c:130
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
static LONGEST bsd_kvm_xfer_memory(CORE_ADDR addr, ULONGEST len, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: bsd-kvm.c:122
target_xfer_status
Definition: target.h:219
#define gdb_assert(expr)
Definition: gdb_assert.h:33
const char * to_doc
Definition: target.h:434
static void bsd_kvm_fetch_registers(struct target_ops *ops, struct regcache *regcache, int regnum)
Definition: bsd-kvm.c:187
struct thread_info * add_thread_silent(ptid_t ptid)
Definition: thread.c:240
enum target_xfer_status(* to_xfer_partial)(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
Definition: target.h:724
static void bsd_kvm_close(struct target_ops *self)
Definition: bsd-kvm.c:108
int regnum
Definition: aarch64-tdep.c:69
target_object
Definition: target.h:136
void print_stack_frame(struct frame_info *, int print_level, enum print_what print_what, int set_current_sal)
Definition: stack.c:151
char * current_directory
Definition: top.c:117
const char const char int
Definition: command.h:229
bfd_byte gdb_byte
Definition: common-types.h:38
ptid_t null_ptid
Definition: ptid.c:25
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:472
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
CORE_ADDR parse_and_eval_address(const char *exp)
Definition: eval.c:96
ptid_t inferior_ptid
Definition: infcmd.c:124
enum strata to_stratum
Definition: target.h:650
static const char * bsd_kvm_corefile
Definition: bsd-kvm.c:44
void(* to_open)(const char *, int)
Definition: target.h:443
int offset
Definition: agent.c:65
static int bsd_kvm_return_one(struct target_ops *ops)
Definition: bsd-kvm.c:341
const char * to_shortname
Definition: target.h:432
static void bsd_kvm_files_info(struct target_ops *ops)
Definition: bsd-kvm.c:163
char * get_exec_file(int err)
Definition: corefile.c:179
unsigned long long ULONGEST
Definition: common-types.h:53
int to_magic
Definition: target.h:1224
static struct pcb * bsd_kvm_paddr
Definition: bsd-kvm.c:50
void bsd_kvm_add_target(int(*supply_pcb)(struct regcache *, struct pcb *))
Definition: bsd-kvm.c:351
int(* to_thread_alive)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(0)
Definition: target.h:627
void target_preopen(int from_tty)
Definition: target.c:2171
void reinit_frame_cache(void)
Definition: frame.c:1687
static int bsd_kvm_thread_alive(struct target_ops *ops, ptid_t ptid)
Definition: bsd-kvm.c:326
int(* to_has_registers)(struct target_ops *)
Definition: target.h:654
static char * bsd_kvm_pid_to_str(struct target_ops *ops, ptid_t ptid)
Definition: bsd-kvm.c:333
void error(const char *fmt,...)
Definition: errors.c:38
long long LONGEST
Definition: common-types.h:52
static struct target_ops bsd_kvm_ops
Definition: bsd-kvm.c:57
static int bsd_kvm_fetch_pcb(struct regcache *regcache, struct pcb *paddr)
Definition: bsd-kvm.c:175
const ULONGEST const LONGEST len
Definition: target.h:309