gdb/bsd-kvm.c

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