gdb/bsd-kvm.c

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