gdb/bsd-kvm.c

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