1 /* BSD Kernel Data Access Library (libkvm) interface. 2 3 Copyright (C) 2004, 2005, 2007, 2008, 2009 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 "gdb_assert.h" 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 #include <sys/user.h> 41 42 #include "bsd-kvm.h" 43 44 /* Kernel memory device file. */ 45 static const char *bsd_kvm_corefile; 46 47 /* Kernel memory interface descriptor. */ 48 static kvm_t *core_kd; 49 50 /* Address of process control block. */ 51 static struct pcb *bsd_kvm_paddr; 52 53 /* Pointer to architecture-specific function that reconstructs the 54 register state from PCB and supplies it to REGCACHE. */ 55 static int (*bsd_kvm_supply_pcb)(struct regcache *regcache, struct pcb *pcb); 56 57 /* Target ops for libkvm interface. */ 58 static struct target_ops bsd_kvm_ops; 59 60 /* This is the ptid we use while we're connected to kvm. The kvm 61 target currently doesn't export any view of the running processes, 62 so this represents the kernel task. */ 63 static ptid_t bsd_kvm_ptid; 64 65 static void 66 bsd_kvm_open (char *filename, int from_tty) 67 { 68 char errbuf[_POSIX2_LINE_MAX]; 69 char *execfile = NULL; 70 kvm_t *temp_kd; 71 72 target_preopen (from_tty); 73 74 if (filename) 75 { 76 char *temp; 77 78 filename = tilde_expand (filename); 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; 94 unpush_target (&bsd_kvm_ops); 95 core_kd = temp_kd; 96 push_target (&bsd_kvm_ops); 97 98 add_thread_silent (bsd_kvm_ptid); 99 inferior_ptid = bsd_kvm_ptid; 100 101 target_fetch_registers (get_current_regcache (), -1); 102 103 reinit_frame_cache (); 104 print_stack_frame (get_selected_frame (NULL), -1, 1); 105 } 106 107 static void 108 bsd_kvm_close (int quitting) 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 117 inferior_ptid = null_ptid; 118 delete_thread_silent (bsd_kvm_ptid); 119 } 120 121 static LONGEST 122 bsd_kvm_xfer_memory (CORE_ADDR addr, ULONGEST len, 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 LONGEST 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, LONGEST len) 139 { 140 switch (object) 141 { 142 case TARGET_OBJECT_MEMORY: 143 return bsd_kvm_xfer_memory (offset, len, readbuf, writebuf); 144 145 default: 146 return -1; 147 } 148 } 149 150 static void 151 bsd_kvm_files_info (struct target_ops *ops) 152 { 153 if (bsd_kvm_corefile && strcmp (bsd_kvm_corefile, _PATH_MEM) != 0) 154 printf_filtered (_("\tUsing the kernel crash dump %s.\n"), 155 bsd_kvm_corefile); 156 else 157 printf_filtered (_("\tUsing the currently running kernel.\n")); 158 } 159 160 /* Fetch process control block at address PADDR. */ 161 162 static int 163 bsd_kvm_fetch_pcb (struct regcache *regcache, struct pcb *paddr) 164 { 165 struct pcb pcb; 166 167 if (kvm_read (core_kd, (unsigned long) paddr, &pcb, sizeof pcb) == -1) 168 error (("%s"), kvm_geterr (core_kd)); 169 170 gdb_assert (bsd_kvm_supply_pcb); 171 return bsd_kvm_supply_pcb (regcache, &pcb); 172 } 173 174 static void 175 bsd_kvm_fetch_registers (struct target_ops *ops, 176 struct regcache *regcache, int regnum) 177 { 178 struct nlist nl[2]; 179 180 if (bsd_kvm_paddr) 181 { 182 bsd_kvm_fetch_pcb (regcache, bsd_kvm_paddr); 183 return; 184 } 185 186 /* On dumping core, BSD kernels store the faulting context (PCB) 187 in the variable "dumppcb". */ 188 memset (nl, 0, sizeof nl); 189 nl[0].n_name = "_dumppcb"; 190 191 if (kvm_nlist (core_kd, nl) == -1) 192 error (("%s"), kvm_geterr (core_kd)); 193 194 if (nl[0].n_value != 0) 195 { 196 /* Found dumppcb. If it contains a valid context, return 197 immediately. */ 198 if (bsd_kvm_fetch_pcb (regcache, (struct pcb *) nl[0].n_value)) 199 return; 200 } 201 202 /* Traditional BSD kernels have a process proc0 that should always 203 be present. The address of proc0's PCB is stored in the variable 204 "proc0paddr". */ 205 206 memset (nl, 0, sizeof nl); 207 nl[0].n_name = "_proc0paddr"; 208 209 if (kvm_nlist (core_kd, nl) == -1) 210 error (("%s"), kvm_geterr (core_kd)); 211 212 if (nl[0].n_value != 0) 213 { 214 struct pcb *paddr; 215 216 /* Found proc0paddr. */ 217 if (kvm_read (core_kd, nl[0].n_value, &paddr, sizeof paddr) == -1) 218 error (("%s"), kvm_geterr (core_kd)); 219 220 bsd_kvm_fetch_pcb (regcache, paddr); 221 return; 222 } 223 224 #ifdef HAVE_STRUCT_THREAD_TD_PCB 225 /* In FreeBSD kernels for 5.0-RELEASE and later, the PCB no longer 226 lives in `struct proc' but in `struct thread'. The `struct 227 thread' for the initial thread for proc0 can be found in the 228 variable "thread0". */ 229 230 memset (nl, 0, sizeof nl); 231 nl[0].n_name = "_thread0"; 232 233 if (kvm_nlist (core_kd, nl) == -1) 234 error (("%s"), kvm_geterr (core_kd)); 235 236 if (nl[0].n_value != 0) 237 { 238 struct pcb *paddr; 239 240 /* Found thread0. */ 241 nl[0].n_value += offsetof (struct thread, td_pcb); 242 if (kvm_read (core_kd, nl[0].n_value, &paddr, sizeof paddr) == -1) 243 error (("%s"), kvm_geterr (core_kd)); 244 245 bsd_kvm_fetch_pcb (regcache, paddr); 246 return; 247 } 248 #endif 249 250 /* i18n: PCB == "Process Control Block" */ 251 error (_("Cannot find a valid PCB")); 252 } 253 254 255 /* Kernel memory interface commands. */ 256 struct cmd_list_element *bsd_kvm_cmdlist; 257 258 static void 259 bsd_kvm_cmd (char *arg, int fromtty) 260 { 261 /* ??? Should this become an alias for "target kvm"? */ 262 } 263 264 #ifndef HAVE_STRUCT_THREAD_TD_PCB 265 266 static void 267 bsd_kvm_proc_cmd (char *arg, int fromtty) 268 { 269 CORE_ADDR addr; 270 271 if (arg == NULL) 272 error_no_arg (_("proc address")); 273 274 if (core_kd == NULL) 275 error (_("No kernel memory image.")); 276 277 addr = parse_and_eval_address (arg); 278 #ifdef HAVE_STRUCT_LWP 279 addr += offsetof (struct lwp, l_addr); 280 #else 281 addr += offsetof (struct proc, p_addr); 282 #endif 283 284 if (kvm_read (core_kd, addr, &bsd_kvm_paddr, sizeof bsd_kvm_paddr) == -1) 285 error (("%s"), kvm_geterr (core_kd)); 286 287 target_fetch_registers (get_current_regcache (), -1); 288 289 reinit_frame_cache (); 290 print_stack_frame (get_selected_frame (NULL), -1, 1); 291 } 292 293 #endif 294 295 static void 296 bsd_kvm_pcb_cmd (char *arg, int fromtty) 297 { 298 if (arg == NULL) 299 /* i18n: PCB == "Process Control Block" */ 300 error_no_arg (_("pcb address")); 301 302 if (core_kd == NULL) 303 error (_("No kernel memory image.")); 304 305 bsd_kvm_paddr = (struct pcb *)(u_long) parse_and_eval_address (arg); 306 307 target_fetch_registers (get_current_regcache (), -1); 308 309 reinit_frame_cache (); 310 print_stack_frame (get_selected_frame (NULL), -1, 1); 311 } 312 313 static int 314 bsd_kvm_thread_alive (struct target_ops *ops, 315 ptid_t ptid) 316 { 317 return 1; 318 } 319 320 static char * 321 bsd_kvm_pid_to_str (struct target_ops *ops, ptid_t ptid) 322 { 323 static char buf[64]; 324 xsnprintf (buf, sizeof buf, "<kvm>"); 325 return buf; 326 } 327 328 static int 329 bsd_kvm_return_one (struct target_ops *ops) 330 { 331 return 1; 332 } 333 334 /* Add the libkvm interface to the list of all possible targets and 335 register CUPPLY_PCB as the architecture-specific process control 336 block interpreter. */ 337 338 void 339 bsd_kvm_add_target (int (*supply_pcb)(struct regcache *, struct pcb *)) 340 { 341 gdb_assert (bsd_kvm_supply_pcb == NULL); 342 bsd_kvm_supply_pcb = supply_pcb; 343 344 bsd_kvm_ops.to_shortname = "kvm"; 345 bsd_kvm_ops.to_longname = _("Kernel memory interface"); 346 bsd_kvm_ops.to_doc = _("Use a kernel virtual memory image as a target.\n\ 347 Optionally specify the filename of a core dump."); 348 bsd_kvm_ops.to_open = bsd_kvm_open; 349 bsd_kvm_ops.to_close = bsd_kvm_close; 350 bsd_kvm_ops.to_fetch_registers = bsd_kvm_fetch_registers; 351 bsd_kvm_ops.to_xfer_partial = bsd_kvm_xfer_partial; 352 bsd_kvm_ops.to_files_info = bsd_kvm_files_info; 353 bsd_kvm_ops.to_thread_alive = bsd_kvm_thread_alive; 354 bsd_kvm_ops.to_pid_to_str = bsd_kvm_pid_to_str; 355 bsd_kvm_ops.to_stratum = process_stratum; 356 bsd_kvm_ops.to_has_memory = bsd_kvm_return_one; 357 bsd_kvm_ops.to_has_stack = bsd_kvm_return_one; 358 bsd_kvm_ops.to_has_registers = bsd_kvm_return_one; 359 bsd_kvm_ops.to_magic = OPS_MAGIC; 360 361 add_target (&bsd_kvm_ops); 362 363 add_prefix_cmd ("kvm", class_obscure, bsd_kvm_cmd, _("\ 364 Generic command for manipulating the kernel memory interface."), 365 &bsd_kvm_cmdlist, "kvm ", 0, &cmdlist); 366 367 #ifndef HAVE_STRUCT_THREAD_TD_PCB 368 add_cmd ("proc", class_obscure, bsd_kvm_proc_cmd, 369 _("Set current context from proc address"), &bsd_kvm_cmdlist); 370 #endif 371 add_cmd ("pcb", class_obscure, bsd_kvm_pcb_cmd, 372 /* i18n: PCB == "Process Control Block" */ 373 _("Set current context from pcb address"), &bsd_kvm_cmdlist); 374 375 /* Some notes on the ptid usage on this target. 376 377 The pid field represents the kvm inferior instance. Currently, 378 we don't support multiple kvm inferiors, but we start at 1 379 anyway. The lwp field is set to != 0, in case the core wants to 380 refer to the whole kvm inferior with ptid(1,0,0). 381 382 If kvm is made to export running processes as gdb threads, 383 the following form can be used: 384 ptid (1, 1, 0) -> kvm inferior 1, in kernel 385 ptid (1, 1, 1) -> kvm inferior 1, process 1 386 ptid (1, 1, 2) -> kvm inferior 1, process 2 387 ptid (1, 1, n) -> kvm inferior 1, process n 388 */ 389 bsd_kvm_ptid = ptid_build (1, 1, 0); 390 } 391