gdb/bsd-kvm.c

   1 /* BSD Kernel Data Access Library (libkvm) interface.
   2
   3    Copyright 2004 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 2 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, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "cli/cli-cmds.h"
  24 #include "command.h"
  25 #include "frame.h"
  26 #include "regcache.h"
  27 #include "target.h"
  28 #include "value.h"
  29 #include "gdbcore.h"            /* for get_exec_file */
  30
  31 #include "gdb_assert.h"
  32 #include <fcntl.h>
  33 #include <kvm.h>
  34 #include <nlist.h>
  35 #include "readline/readline.h"
  36 #include <sys/param.h>
  37 #include <sys/proc.h>
  38 #include <sys/user.h>
  39
  40 #include "bsd-kvm.h"
  41
  42 /* Kernel memory interface descriptor.  */
  43 kvm_t *core_kd;
  44
  45 /* Address of process control block.  */
  46 struct pcb *bsd_kvm_paddr;
  47
  48 /* Pointer to architecture-specific function that reconstructs the
  49    register state from PCB and supplies it to REGCACHE.  */
  50 int (*bsd_kvm_supply_pcb)(struct regcache *regcache, struct pcb *pcb);
  51
  52 /* Target ops for libkvm interface.  */
  53 struct target_ops bsd_kvm_ops;
  54
  55 static void
  56 bsd_kvm_open (char *filename, int from_tty)
  57 {
  58   char errbuf[_POSIX2_LINE_MAX];
  59   char *execfile = NULL;
  60   kvm_t *temp_kd;
  61
  62   target_preopen (from_tty);
  63
  64   if (filename)
  65     {
  66       char *temp;
  67
  68       filename = tilde_expand (filename);
  69       if (filename[0] != '/')
  70         {
  71           temp = concat (current_directory, "/", filename, NULL);
  72           xfree (filename);
  73           filename = temp;
  74         }
  75     }
  76
  77   execfile = get_exec_file (0);
  78   temp_kd = kvm_openfiles (execfile, filename, NULL, O_RDONLY, errbuf);
  79   if (temp_kd == NULL)
  80     error ("%s", errbuf);
  81
  82   unpush_target (&bsd_kvm_ops);
  83   core_kd = temp_kd;
  84   push_target (&bsd_kvm_ops);
  85
  86   target_fetch_registers (-1);
  87
  88   flush_cached_frames ();
  89   select_frame (get_current_frame ());
  90   print_stack_frame (get_selected_frame (), -1, 1);
  91 }
  92
  93 static void
  94 bsd_kvm_close (int quitting)
  95 {
  96   if (core_kd)
  97     {
  98       if (kvm_close (core_kd) == -1)
  99         warning ("%s", kvm_geterr(core_kd));
 100       core_kd = NULL;
 101     }
 102 }
 103
 104 static int
 105 bsd_kvm_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
 106                     int write, struct mem_attrib *attrib,
 107                     struct target_ops *ops)
 108 {
 109   if (write)
 110     return kvm_write (core_kd, memaddr, myaddr, len);
 111   else
 112     return kvm_read (core_kd, memaddr, myaddr, len);
 113
 114   return -1;
 115 }
 116
 117 /* Fetch process control block at address PADDR.  */
 118
 119 static int
 120 bsd_kvm_fetch_pcb (struct pcb *paddr)
 121 {
 122   struct pcb pcb;
 123
 124   if (kvm_read (core_kd, (unsigned long) paddr, &pcb, sizeof pcb) == -1)
 125     error ("%s", kvm_geterr (core_kd));
 126
 127   gdb_assert (bsd_kvm_supply_pcb);
 128   return bsd_kvm_supply_pcb (current_regcache, &pcb);
 129 }
 130
 131 static void
 132 bsd_kvm_fetch_registers (int regnum)
 133 {
 134   struct nlist nl[2];
 135
 136   if (bsd_kvm_paddr)
 137     {
 138       bsd_kvm_fetch_pcb (bsd_kvm_paddr);
 139       return;
 140     }
 141
 142   /* On dumping core, BSD kernels store the faulting context (PCB)
 143      in the variable "dumppcb".  */
 144   memset (nl, 0, sizeof nl);
 145   nl[0].n_name = "_dumppcb";
 146
 147   if (kvm_nlist (core_kd, nl) == -1)
 148     error ("%s", kvm_geterr (core_kd));
 149
 150   if (nl[0].n_value != 0)
 151     {
 152       /* Found dumppcb. If it contains a valid context, return
 153          immediately.  */
 154       if (bsd_kvm_fetch_pcb ((struct pcb *) nl[0].n_value))
 155         return;
 156     }
 157
 158   /* Traditional BSD kernels have a process proc0 that should always
 159      be present.  The address of proc0's PCB is stored in the variable
 160      "proc0paddr".  */
 161
 162   memset (nl, 0, sizeof nl);
 163   nl[0].n_name = "_proc0paddr";
 164
 165   if (kvm_nlist (core_kd, nl) == -1)
 166     error ("%s", kvm_geterr (core_kd));
 167
 168   if (nl[0].n_value != 0)
 169     {
 170       struct pcb *paddr;
 171
 172       /* Found proc0paddr.  */
 173       if (kvm_read (core_kd, nl[0].n_value, &paddr, sizeof paddr) == -1)
 174         error ("%s", kvm_geterr (core_kd));
 175
 176       bsd_kvm_fetch_pcb (paddr);
 177       return;
 178     }
 179
 180 #ifdef HAVE_STRUCT_THREAD_TD_PCB
 181   /* In FreeBSD kernels for 5.0-RELEASE and later, the PCB no longer
 182      lives in `struct proc' but in `struct thread'.  The `struct
 183      thread' for the initial thread for proc0 can be found in the
 184      variable "thread0".  */
 185
 186   memset (nl, 0, sizeof nl);
 187   nl[0].n_name = "_thread0";
 188
 189   if (kvm_nlist (core_kd, nl) == -1)
 190     error ("%s", kvm_geterr (core_kd));
 191
 192   if (nl[0].n_value != 0)
 193     {
 194       struct pcb *paddr;
 195
 196       /* Found thread0.  */
 197       nl[0].n_value += offsetof (struct thread, td_pcb);
 198       if (kvm_read (core_kd, nl[0].n_value, &paddr, sizeof paddr) == -1)
 199         error ("%s", kvm_geterr (core_kd));
 200
 201       bsd_kvm_fetch_pcb (paddr);
 202       return;
 203     }
 204 #endif
 205
 206   error ("Cannot find a valid PCB");
 207 }
 208 \f
 209
 210 /* Kernel memory interface commands.  */
 211 struct cmd_list_element *bsd_kvm_cmdlist;
 212
 213 static void
 214 bsd_kvm_cmd (char *arg, int fromtty)
 215 {
 216   /* ??? Should this become an alias for "target kvm"?  */
 217 }
 218
 219 #ifndef HAVE_STRUCT_THREAD_TD_PCB
 220
 221 static void
 222 bsd_kvm_proc_cmd (char *arg, int fromtty)
 223 {
 224   CORE_ADDR addr;
 225
 226   if (arg == NULL)
 227     error_no_arg ("proc address");
 228
 229   if (core_kd == NULL)
 230     error ("No kernel memory image.");
 231
 232   addr = parse_and_eval_address (arg);
 233   addr += offsetof (struct proc, p_addr);
 234
 235   if (kvm_read (core_kd, addr, &bsd_kvm_paddr, sizeof bsd_kvm_paddr) == -1)
 236     error ("%s", kvm_geterr (core_kd));
 237
 238   target_fetch_registers (-1);
 239
 240   flush_cached_frames ();
 241   select_frame (get_current_frame ());
 242   print_stack_frame (get_selected_frame (), -1, 1);
 243 }
 244
 245 #endif
 246
 247 static void
 248 bsd_kvm_pcb_cmd (char *arg, int fromtty)
 249 {
 250   if (arg == NULL)
 251     error_no_arg ("pcb address");
 252
 253   if (core_kd == NULL)
 254     error ("No kernel memory image.");
 255
 256   bsd_kvm_paddr = (struct pcb *) parse_and_eval_address (arg);
 257
 258   target_fetch_registers (-1);
 259
 260   flush_cached_frames ();
 261   select_frame (get_current_frame ());
 262   print_stack_frame (get_selected_frame (), -1, 1);
 263 }
 264
 265 /* Add the libkvm interface to the list of all possible targets and
 266    register CUPPLY_PCB as the architecture-specific process control
 267    block interpreter.  */
 268
 269 void
 270 bsd_kvm_add_target (int (*supply_pcb)(struct regcache *, struct pcb *))
 271 {
 272   gdb_assert (bsd_kvm_supply_pcb == NULL);
 273   bsd_kvm_supply_pcb = supply_pcb;
 274
 275   bsd_kvm_ops.to_shortname = "kvm";
 276   bsd_kvm_ops.to_longname = "Kernel memory interface";
 277   bsd_kvm_ops.to_doc = "Use a kernel virtual memory image as a target.\n\
 278 Optionally specify the filename of a core dump.";
 279   bsd_kvm_ops.to_open = bsd_kvm_open;
 280   bsd_kvm_ops.to_close = bsd_kvm_close;
 281   bsd_kvm_ops.to_fetch_registers = bsd_kvm_fetch_registers;
 282   bsd_kvm_ops.to_xfer_memory = bsd_kvm_xfer_memory;
 283   bsd_kvm_ops.to_stratum = process_stratum;
 284   bsd_kvm_ops.to_has_memory = 1;
 285   bsd_kvm_ops.to_has_stack = 1;
 286   bsd_kvm_ops.to_has_registers = 1;
 287   bsd_kvm_ops.to_magic = OPS_MAGIC;
 288
 289   add_target (&bsd_kvm_ops);
 290
 291   add_prefix_cmd ("kvm", class_obscure, bsd_kvm_cmd, "\
 292 Generic command for manipulating the kernel memory interface.",
 293                   &bsd_kvm_cmdlist, "kvm ", 0, &cmdlist);
 294
 295 #ifndef HAVE_STRUCT_THREAD_TD_PCB
 296   add_cmd ("proc", class_obscure, bsd_kvm_proc_cmd,
 297            "Set current context from proc address", &bsd_kvm_cmdlist);
 298 #endif
 299   add_cmd ("pcb", class_obscure, bsd_kvm_pcb_cmd,
 300            "Set current context from pcb address", &bsd_kvm_cmdlist);
 301 }