gdb/bsd-kvm.c

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