gdb/bsd-kvm.c

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