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