GDB (xrefs)

/tmp/gdb-8.1/gdb/bsd-kvm.c
Go to the documentation of this file.
1 /* BSD Kernel Data Access Library (libkvm) interface.
2
3 Copyright (C) 2004-2018 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 #define _KMEMUSER
21 #include "defs.h"
22 #include "cli/cli-cmds.h"
23 #include "command.h"
24 #include "frame.h"
25 #include "regcache.h"
26 #include "target.h"
27 #include "value.h"
28 #include "gdbcore.h" /* for get_exec_file */
29 #include "gdbthread.h"
30
31 #include <fcntl.h>
32 #include <kvm.h>
33 #ifdef HAVE_NLIST_H
34 #include <nlist.h>
35 #endif
36 #include <paths.h>
37 #include "readline/readline.h"
38 #include <sys/param.h>
39 #include <sys/proc.h>
40 #ifdef HAVE_SYS_USER_H
41 #include <sys/user.h>
42 #endif
43
44 #include "bsd-kvm.h"
45
46 /* Kernel memory device file. */
47 static const char *bsd_kvm_corefile;
48
49 /* Kernel memory interface descriptor. */
50 static kvm_t *core_kd;
51
52 /* Address of process control block. */
53 static struct pcb *bsd_kvm_paddr;
54
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);
58
59 /* Target ops for libkvm interface. */
60 static struct target_ops bsd_kvm_ops;
61
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;
66
67 static void
68 bsd_kvm_open (const char *arg, int from_tty)
69 {
70 char errbuf[_POSIX2_LINE_MAX];
71 char *execfile = NULL;
72 kvm_t *temp_kd;
73 char *filename = NULL;
74
75 target_preopen (from_tty);
76
77 if (arg)
78 {
79 char *temp;
80
81 filename = tilde_expand (arg);
82 if (filename[0] != '/')
83 {
84 temp = concat (current_directory, "/", filename, (char *)NULL);
85 xfree (filename);
86 filename = temp;
87 }
88 }
89
90 execfile = get_exec_file (0);
91 temp_kd = kvm_openfiles (execfile, filename, NULL,
92 write_files ? O_RDWR : O_RDONLY, errbuf);
93 if (temp_kd == NULL)
94 error (("%s"), errbuf);
95
96 bsd_kvm_corefile = filename;
97 unpush_target (&bsd_kvm_ops);
98 core_kd = temp_kd;
99 push_target (&bsd_kvm_ops);
100
101 add_thread_silent (bsd_kvm_ptid);
102 inferior_ptid = bsd_kvm_ptid;
103
104 target_fetch_registers (get_current_regcache (), -1);
105
106 reinit_frame_cache ();
107 print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
108 }
109
110 static void
111 bsd_kvm_close (struct target_ops *self)
112 {
113 if (core_kd)
114 {
115 if (kvm_close (core_kd) == -1)
116 warning (("%s"), kvm_geterr(core_kd));
117 core_kd = NULL;
118 }
119
120 inferior_ptid = null_ptid;
121 delete_thread_silent (bsd_kvm_ptid);
122 }
123
124 static LONGEST
125 bsd_kvm_xfer_memory (CORE_ADDR addr, ULONGEST len,
126 gdb_byte *readbuf, const gdb_byte *writebuf)
127 {
128 ssize_t nbytes = len;
129
130 if (readbuf)
131 nbytes = kvm_read (core_kd, addr, readbuf, nbytes);
132 if (writebuf && nbytes > 0)
133 nbytes = kvm_write (core_kd, addr, writebuf, nbytes);
134 return nbytes;
135 }
136
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)
142 {
143 switch (object)
144 {
145 case TARGET_OBJECT_MEMORY:
146 {
147 LONGEST ret = bsd_kvm_xfer_memory (offset, len, readbuf, writebuf);
148
149 if (ret < 0)
150 return TARGET_XFER_E_IO;
151 else if (ret == 0)
152 return TARGET_XFER_EOF;
153 else
154 {
155 *xfered_len = (ULONGEST) ret;
156 return TARGET_XFER_OK;
157 }
158 }
159
160 default:
161 return TARGET_XFER_E_IO;
162 }
163 }
164
165 static void
166 bsd_kvm_files_info (struct target_ops *ops)
167 {
168 if (bsd_kvm_corefile && strcmp (bsd_kvm_corefile, _PATH_MEM) != 0)
169 printf_filtered (_("\tUsing the kernel crash dump %s.\n"),
170 bsd_kvm_corefile);
171 else
172 printf_filtered (_("\tUsing the currently running kernel.\n"));
173 }
174
175 /* Fetch process control block at address PADDR. */
176
177 static int
178 bsd_kvm_fetch_pcb (struct regcache *regcache, struct pcb *paddr)
179 {
180 struct pcb pcb;
181
182 if (kvm_read (core_kd, (unsigned long) paddr, &pcb, sizeof pcb) == -1)
183 error (("%s"), kvm_geterr (core_kd));
184
185 gdb_assert (bsd_kvm_supply_pcb);
186 return bsd_kvm_supply_pcb (regcache, &pcb);
187 }
188
189 static void
190 bsd_kvm_fetch_registers (struct target_ops *ops,
191 struct regcache *regcache, int regnum)
192 {
193 struct nlist nl[2];
194
195 if (bsd_kvm_paddr)
196 {
197 bsd_kvm_fetch_pcb (regcache, bsd_kvm_paddr);
198 return;
199 }
200
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";
205
206 if (kvm_nlist (core_kd, nl) == -1)
207 error (("%s"), kvm_geterr (core_kd));
208
209 if (nl[0].n_value != 0)
210 {
211 /* Found dumppcb. If it contains a valid context, return
212 immediately. */
213 if (bsd_kvm_fetch_pcb (regcache, (struct pcb *) nl[0].n_value))
214 return;
215 }
216
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
219 "proc0paddr". */
220
221 memset (nl, 0, sizeof nl);
222 nl[0].n_name = "_proc0paddr";
223
224 if (kvm_nlist (core_kd, nl) == -1)
225 error (("%s"), kvm_geterr (core_kd));
226
227 if (nl[0].n_value != 0)
228 {
229 struct pcb *paddr;
230
231 /* Found proc0paddr. */
232 if (kvm_read (core_kd, nl[0].n_value, &paddr, sizeof paddr) == -1)
233 error (("%s"), kvm_geterr (core_kd));
234
235 bsd_kvm_fetch_pcb (regcache, paddr);
236 return;
237 }
238
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". */
244
245 memset (nl, 0, sizeof nl);
246 nl[0].n_name = "_thread0";
247
248 if (kvm_nlist (core_kd, nl) == -1)
249 error (("%s"), kvm_geterr (core_kd));
250
251 if (nl[0].n_value != 0)
252 {
253 struct pcb *paddr;
254
255 /* Found thread0. */
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));
259
260 bsd_kvm_fetch_pcb (regcache, paddr);
261 return;
262 }
263 #endif
264
265 /* i18n: PCB == "Process Control Block". */
266 error (_("Cannot find a valid PCB"));
267 }
268
269
270 /* Kernel memory interface commands. */
271 struct cmd_list_element *bsd_kvm_cmdlist;
272
273 static void
274 bsd_kvm_cmd (const char *arg, int fromtty)
275 {
276 /* ??? Should this become an alias for "target kvm"? */
277 }
278
279 #ifndef HAVE_STRUCT_THREAD_TD_PCB
280
281 static void
282 bsd_kvm_proc_cmd (const char *arg, int fromtty)
283 {
284 CORE_ADDR addr;
285
286 if (arg == NULL)
287 error_no_arg (_("proc address"));
288
289 if (core_kd == NULL)
290 error (_("No kernel memory image."));
291
292 addr = parse_and_eval_address (arg);
293 #ifdef HAVE_STRUCT_LWP
294 addr += offsetof (struct lwp, l_addr);
295 #else
296 addr += offsetof (struct proc, p_addr);
297 #endif
298
299 if (kvm_read (core_kd, addr, &bsd_kvm_paddr, sizeof bsd_kvm_paddr) == -1)
300 error (("%s"), kvm_geterr (core_kd));
301
302 target_fetch_registers (get_current_regcache (), -1);
303
304 reinit_frame_cache ();
305 print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
306 }
307
308 #endif
309
310 static void
311 bsd_kvm_pcb_cmd (const char *arg, int fromtty)
312 {
313 if (arg == NULL)
314 /* i18n: PCB == "Process Control Block". */
315 error_no_arg (_("pcb address"));
316
317 if (core_kd == NULL)
318 error (_("No kernel memory image."));
319
320 bsd_kvm_paddr = (struct pcb *)(u_long) parse_and_eval_address (arg);
321
322 target_fetch_registers (get_current_regcache (), -1);
323
324 reinit_frame_cache ();
325 print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
326 }
327
328 static int
329 bsd_kvm_thread_alive (struct target_ops *ops,
330 ptid_t ptid)
331 {
332 return 1;
333 }
334
335 static const char *
336 bsd_kvm_pid_to_str (struct target_ops *ops, ptid_t ptid)
337 {
338 static char buf[64];
339 xsnprintf (buf, sizeof buf, "<kvm>");
340 return buf;
341 }
342
343 static int
344 bsd_kvm_return_one (struct target_ops *ops)
345 {
346 return 1;
347 }
348
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. */
352
353 void
354 bsd_kvm_add_target (int (*supply_pcb)(struct regcache *, struct pcb *))
355 {
356 gdb_assert (bsd_kvm_supply_pcb == NULL);
357 bsd_kvm_supply_pcb = supply_pcb;
358
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;
375
376 add_target (&bsd_kvm_ops);
377
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);
381
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);
385 #endif
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);
389
390 /* Some notes on the ptid usage on this target.
391
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).
396
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 */
403
404 bsd_kvm_ptid = ptid_build (1, 1, 0);
405 }
error_no_arg
void error_no_arg(const char *why)
Definition: cli-cmds.c:185
add_target
void add_target(struct target_ops *t)
Definition: target.c:395
bsd_kvm_open
static void bsd_kvm_open(const char *arg, int from_tty)
Definition: bsd-kvm.c:68
bsd_kvm_supply_pcb
static int(* bsd_kvm_supply_pcb)(struct regcache *regcache, struct pcb *pcb)
Definition: bsd-kvm.c:57
core_kd
static kvm_t * core_kd
Definition: bsd-kvm.c:50
bsd_kvm_ptid
static ptid_t bsd_kvm_ptid
Definition: bsd-kvm.c:65
target_ops::to_longname
const char * to_longname
Definition: target.h:416
bsd_kvm_cmdlist
struct cmd_list_element * bsd_kvm_cmdlist
Definition: bsd-kvm.c:271
get_selected_frame
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1638
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
command.h
xfree
void xfree(void *)
cmd_list_element
Definition: cli-decode.h:46
bsd_kvm_cmd
static void bsd_kvm_cmd(const char *arg, int fromtty)
Definition: bsd-kvm.c:274
target_ops::to_has_memory
int(* to_has_memory)(struct target_ops *)
Definition: target.h:658
warning
void warning(const char *fmt,...)
Definition: errors.c:26
regcache::regcache
regcache(gdbarch *gdbarch)
Definition: regcache.h:235
target_ops::to_has_stack
int(* to_has_stack)(struct target_ops *)
Definition: target.h:659
push_target
void push_target(struct target_ops *t)
Definition: target.c:642
delete_thread_silent
void delete_thread_silent(ptid_t)
Definition: thread.c:482
get_exec_file
char * get_exec_file(int err)
Definition: corefile.c:167
unpush_target
int unpush_target(struct target_ops *t)
Definition: target.c:689
memset
void * memset(T *s, int c, size_t n)=delete
bsd_kvm_xfer_partial
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:138
target_ops::to_close
void(* to_close)(struct target_ops *)
Definition: target.h:431
target_ops::to_pid_to_str
const char *(* to_pid_to_str)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_pid_to_str)
Definition: target.h:630
cli-cmds.h
add_cmd
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:262
cmdlist
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:79
target_fetch_registers
void target_fetch_registers(struct regcache *regcache, int regno)
Definition: target.c:3437
_
#define _(String)
Definition: gdb_locale.h:35
defs.h
get_current_regcache
struct regcache * get_current_regcache(void)
Definition: regcache.c:446
printf_filtered
void printf_filtered(const char *format,...)
Definition: utils.c:2045
ptid_build
ptid_t ptid_build(int pid, long lwp, long tid)
Definition: ptid.c:31
target_ops::to_files_info
void(* to_files_info)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:464
add_prefix_cmd
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_const_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:367
OPS_MAGIC
#define OPS_MAGIC
Definition: target.h:1270
proc
Definition: gnu-nat.h:42
write_files
int write_files
Definition: exec.c:62
bsd_kvm_proc_cmd
static void bsd_kvm_proc_cmd(const char *arg, int fromtty)
Definition: bsd-kvm.c:282
target_ops
Definition: target.h:412
u_long
unsigned long u_long
Definition: ser-go32.c:130
TARGET_OBJECT_MEMORY
Definition: target.h:139
regcache.h
bsd-kvm.h
ptid_t
Definition: ptid.h:35
frame.h
bsd_kvm_xfer_memory
static LONGEST bsd_kvm_xfer_memory(CORE_ADDR addr, ULONGEST len, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: bsd-kvm.c:125
gdbthread.h
TARGET_XFER_OK
Definition: target.h:209
target_xfer_status
target_xfer_status
Definition: target.h:206
SRC_AND_LOC
Definition: frame.h:668
process_stratum
Definition: target.h:87
target_ops::to_doc
const char * to_doc
Definition: target.h:417
bsd_kvm_fetch_registers
static void bsd_kvm_fetch_registers(struct target_ops *ops, struct regcache *regcache, int regnum)
Definition: bsd-kvm.c:190
add_thread_silent
struct thread_info * add_thread_silent(ptid_t ptid)
Definition: thread.c:266
target_ops::to_xfer_partial
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:739
bsd_kvm_close
static void bsd_kvm_close(struct target_ops *self)
Definition: bsd-kvm.c:111
regnum
int regnum
Definition: aarch64-tdep.c:77
target_object
target_object
Definition: target.h:132
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
print_stack_frame
void print_stack_frame(struct frame_info *, int print_level, enum print_what print_what, int set_current_sal)
Definition: stack.c:165
current_directory
char * current_directory
Definition: top.c:133
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
null_ptid
ptid_t null_ptid
Definition: ptid.c:25
target_ops::to_fetch_registers
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:457
gdbcore.h
TARGET_XFER_EOF
Definition: target.h:212
xsnprintf
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
parse_and_eval_address
CORE_ADDR parse_and_eval_address(const char *exp)
Definition: eval.c:101
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
target_ops::to_stratum
enum strata to_stratum
Definition: target.h:656
bsd_kvm_pid_to_str
static const char * bsd_kvm_pid_to_str(struct target_ops *ops, ptid_t ptid)
Definition: bsd-kvm.c:336
bsd_kvm_corefile
static const char * bsd_kvm_corefile
Definition: bsd-kvm.c:47
target_ops::to_open
void(* to_open)(const char *, int)
Definition: target.h:426
offset
int offset
Definition: agent.c:65
selftests::ptid::lwp
static constexpr ptid_t lwp
Definition: ptid-selftests.c:42
target.h
bsd_kvm_return_one
static int bsd_kvm_return_one(struct target_ops *ops)
Definition: bsd-kvm.c:344
value.h
target_ops::to_shortname
const char * to_shortname
Definition: target.h:415
bsd_kvm_files_info
static void bsd_kvm_files_info(struct target_ops *ops)
Definition: bsd-kvm.c:166
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
target_ops::to_magic
int to_magic
Definition: target.h:1261
bsd_kvm_paddr
static struct pcb * bsd_kvm_paddr
Definition: bsd-kvm.c:53
regcache
Definition: regcache.h:232
bsd_kvm_add_target
void bsd_kvm_add_target(int(*supply_pcb)(struct regcache *, struct pcb *))
Definition: bsd-kvm.c:354
target_ops::to_thread_alive
int(* to_thread_alive)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(0)
Definition: target.h:626
target_preopen
void target_preopen(int from_tty)
Definition: target.c:2121
reinit_frame_cache
void reinit_frame_cache(void)
Definition: frame.c:1809
bsd_kvm_thread_alive
static int bsd_kvm_thread_alive(struct target_ops *ops, ptid_t ptid)
Definition: bsd-kvm.c:329
bsd_kvm_pcb_cmd
static void bsd_kvm_pcb_cmd(const char *arg, int fromtty)
Definition: bsd-kvm.c:311
target_ops::to_has_registers
int(* to_has_registers)(struct target_ops *)
Definition: target.h:660
class_obscure
Definition: command.h:43
error
void error(const char *fmt,...)
Definition: errors.c:38
TARGET_XFER_E_IO
Definition: target.h:220
LONGEST
long long LONGEST
Definition: common-types.h:52
bsd_kvm_ops
static struct target_ops bsd_kvm_ops
Definition: bsd-kvm.c:60
bsd_kvm_fetch_pcb
static int bsd_kvm_fetch_pcb(struct regcache *regcache, struct pcb *paddr)
Definition: bsd-kvm.c:178