gdb/bsd-kvm.c

   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.  */
  62 static ptid_t bsd_kvm_ptid;
  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;
  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), 0, SRC_AND_LOC, 1);
 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
 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 enum target_xfer_status
 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, ULONGEST len, ULONGEST *xfered_len)
 139 {
 140   switch (object)
 141     {
 142     case TARGET_OBJECT_MEMORY:
 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
 163 bsd_kvm_files_info (struct target_ops *ops)
 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
 182   gdb_assert (bsd_kvm_supply_pcb);
 183   return bsd_kvm_supply_pcb (regcache, &pcb);
 184 }
 185
 186 static void
 187 bsd_kvm_fetch_registers (struct target_ops *ops,
 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 \f
 266
 267 /* Kernel memory interface commands.  */
 268 struct cmd_list_element *bsd_kvm_cmdlist;
 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
 299   target_fetch_registers (get_current_regcache (), -1);
 300
 301   reinit_frame_cache ();
 302   print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
 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
 319   target_fetch_registers (get_current_regcache (), -1);
 320
 321   reinit_frame_cache ();
 322   print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
 323 }
 324
 325 static int
 326 bsd_kvm_thread_alive (struct target_ops *ops,
 327                       ptid_t ptid)
 328 {
 329   return 1;
 330 }
 331
 332 static char *
 333 bsd_kvm_pid_to_str (struct target_ops *ops, ptid_t ptid)
 334 {
 335   static char buf[64];
 336   xsnprintf (buf, sizeof buf, "<kvm>");
 337   return buf;
 338 }
 339
 340 static int
 341 bsd_kvm_return_one (struct target_ops *ops)
 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.");
 360   bsd_kvm_ops.to_open = bsd_kvm_open;
 361   bsd_kvm_ops.to_close = bsd_kvm_close;
 362   bsd_kvm_ops.to_fetch_registers = bsd_kvm_fetch_registers;
 363   bsd_kvm_ops.to_xfer_partial = bsd_kvm_xfer_partial;
 364   bsd_kvm_ops.to_files_info = bsd_kvm_files_info;
 365   bsd_kvm_ops.to_thread_alive = bsd_kvm_thread_alive;
 366   bsd_kvm_ops.to_pid_to_str = bsd_kvm_pid_to_str;
 367   bsd_kvm_ops.to_stratum = process_stratum;
 368   bsd_kvm_ops.to_has_memory = bsd_kvm_return_one;
 369   bsd_kvm_ops.to_has_stack = bsd_kvm_return_one;
 370   bsd_kvm_ops.to_has_registers = bsd_kvm_return_one;
 371   bsd_kvm_ops.to_magic = OPS_MAGIC;
 372
 373   add_target (&bsd_kvm_ops);
 374
 375   add_prefix_cmd ("kvm", class_obscure, bsd_kvm_cmd, _("\
 376 Generic command for manipulating the kernel memory interface."),
 377                   &bsd_kvm_cmdlist, "kvm ", 0, &cmdlist);
 378
 379 #ifndef HAVE_STRUCT_THREAD_TD_PCB
 380   add_cmd ("proc", class_obscure, bsd_kvm_proc_cmd,
 381            _("Set current context from proc address"), &bsd_kvm_cmdlist);
 382 #endif
 383   add_cmd ("pcb", class_obscure, bsd_kvm_pcb_cmd,
 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 }