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 (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), 0, SRC_AND_LOC, 1);
 105 }
 106
 107 static void
 108 bsd_kvm_close (void)
 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, ULONGEST 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 \f
 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), 0, SRC_AND_LOC, 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), 0, SRC_AND_LOC, 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 }