gdb/bsd-kvm.c - gdb

Global variables defined

Functions defined

Source code

  1. /* BSD Kernel Data Access Library (libkvm) interface.

  3.    Copyright (C) 2004-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  20. #include "defs.h"
  21. #include "cli/cli-cmds.h"
  22. #include "command.h"
  23. #include "frame.h"
  24. #include "regcache.h"
  25. #include "target.h"
  26. #include "value.h"
  27. #include "gdbcore.h"                /* for get_exec_file */
  28. #include "gdbthread.h"

  30. #include <fcntl.h>
  31. #include <kvm.h>
  32. #ifdef HAVE_NLIST_H
  33. #include <nlist.h>
  34. #endif
  35. #include <paths.h>
  36. #include "readline/readline.h"
  37. #include <sys/param.h>
  38. #include <sys/proc.h>
  39. #include <sys/user.h>

  41. #include "bsd-kvm.h"

  43. /* Kernel memory device file.  */
  44. ‌static const char *bsd_kvm_corefile;

  46. /* Kernel memory interface descriptor.  */
  47. ‌static kvm_t *core_kd;

  49. /* Address of process control block.  */
  50. ‌static struct pcb *bsd_kvm_paddr;

  52. /* Pointer to architecture-specific function that reconstructs the
  53.    register state from PCB and supplies it to REGCACHE.  */
  54. ‌static int (*bsd_kvm_supply_pcb)(struct regcache *regcache, struct pcb *pcb);

  56. /* Target ops for libkvm interface.  */
  57. ‌static struct target_ops bsd_kvm_ops;

  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;

  64. static void
  65. ‌bsd_kvm_open (const char *arg, int from_tty)
  66. {
  67.   char errbuf[_POSIX2_LINE_MAX];
  68.   char *execfile = NULL;
  69.   kvm_t *temp_kd;
  70.   char *filename = NULL;

  72.   target_preopen (from_tty);

  74.   if (arg)
  75.     {
  76.       char *temp;

  78.       filename = tilde_expand (arg);
  79.       if (filename[0] != '/')
  80.         {
  81.           temp = concat (current_directory, "/", filename, (char *)NULL);
  82.           xfree (filename);
  83.           filename = temp;
  84.         }
  85.     }

  87.   execfile = get_exec_file (0);
  88.   temp_kd = kvm_openfiles (execfile, filename, NULL,
  89.                            write_files ? O_RDWR : O_RDONLY, errbuf);
  90.   if (temp_kd == NULL)
  91.     error (("%s"), errbuf);

  93.   bsd_kvm_corefile = filename;
  94.   unpush_target (&bsd_kvm_ops);
  95.   core_kd = temp_kd;
  96.   push_target (&bsd_kvm_ops);

  98.   add_thread_silent (bsd_kvm_ptid);
  99.   inferior_ptid = bsd_kvm_ptid;

  101.   target_fetch_registers (get_current_regcache (), -1);

  103.   reinit_frame_cache ();
  104.   print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
  105. }

  107. static void
  108. ‌bsd_kvm_close (struct target_ops *self)
  109. {
  110.   if (core_kd)
  111.     {
  112.       if (kvm_close (core_kd) == -1)
  113.         warning (("%s"), kvm_geterr(core_kd));
  114.       core_kd = NULL;
  115.     }

  117.   inferior_ptid = null_ptid;
  118.   delete_thread_silent (bsd_kvm_ptid);
  119. }

  121. static LONGEST
  122. ‌bsd_kvm_xfer_memory (CORE_ADDR addr, ULONGEST len,
  123.                      gdb_byte *readbuf, const gdb_byte *writebuf)
  124. {
  125.   ssize_t nbytes = len;

  127.   if (readbuf)
  128.     nbytes = kvm_read (core_kd, addr, readbuf, nbytes);
  129.   if (writebuf && nbytes > 0)
  130.     nbytes = kvm_write (core_kd, addr, writebuf, nbytes);
  131.   return nbytes;
  132. }

  134. static enum target_xfer_status
  135. ‌bsd_kvm_xfer_partial (struct target_ops *ops, enum target_object object,
  136.                       const char *annex, gdb_byte *readbuf,
  137.                       const gdb_byte *writebuf,
  138.                       ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
  139. {
  140.   switch (object)
  141.     {
  142.     case TARGET_OBJECT_MEMORY:
  143.       {
  144.         LONGEST ret = bsd_kvm_xfer_memory (offset, len, readbuf, writebuf);

  146.         if (ret < 0)
  147.           return TARGET_XFER_E_IO;
  148.         else if (ret == 0)
  149.           return TARGET_XFER_EOF;
  150.         else
  151.           {
  152.             *xfered_len = (ULONGEST) ret;
  153.             return TARGET_XFER_OK;
  154.           }
  155.       }

  157.     default:
  158.       return TARGET_XFER_E_IO;
  159.     }
  160. }

  162. static void
  163. ‌bsd_kvm_files_info (struct target_ops *ops)
  164. {
  165.   if (bsd_kvm_corefile && strcmp (bsd_kvm_corefile, _PATH_MEM) != 0)
  166.     printf_filtered (_("\tUsing the kernel crash dump %s.\n"),
  167.                      bsd_kvm_corefile);
  168.   else
  169.     printf_filtered (_("\tUsing the currently running kernel.\n"));
  170. }

  172. /* Fetch process control block at address PADDR.  */

  174. static int
  175. ‌bsd_kvm_fetch_pcb (struct regcache *regcache, struct pcb *paddr)
  176. {
  177.   struct pcb pcb;

  179.   if (kvm_read (core_kd, (unsigned long) paddr, &pcb, sizeof pcb) == -1)
  180.     error (("%s"), kvm_geterr (core_kd));

  182.   gdb_assert (bsd_kvm_supply_pcb);
  183.   return bsd_kvm_supply_pcb (regcache, &pcb);
  184. }

  186. static void
  187. ‌bsd_kvm_fetch_registers (struct target_ops *ops,
  188.                          struct regcache *regcache, int regnum)
  189. {
  190.   struct nlist nl[2];

  192.   if (bsd_kvm_paddr)
  193.     {
  194.       bsd_kvm_fetch_pcb (regcache, bsd_kvm_paddr);
  195.       return;
  196.     }

  198.   /* On dumping core, BSD kernels store the faulting context (PCB)
  199.      in the variable "dumppcb".  */
  200.   memset (nl, 0, sizeof nl);
  201.   nl[0].n_name = "_dumppcb";

  203.   if (kvm_nlist (core_kd, nl) == -1)
  204.     error (("%s"), kvm_geterr (core_kd));

  206.   if (nl[0].n_value != 0)
  207.     {
  208.       /* Found dumppcb.  If it contains a valid context, return
  209.          immediately.  */
  210.       if (bsd_kvm_fetch_pcb (regcache, (struct pcb *) nl[0].n_value))
  211.         return;
  212.     }

  214.   /* Traditional BSD kernels have a process proc0 that should always
  215.      be present.  The address of proc0's PCB is stored in the variable
  216.      "proc0paddr".  */

  218.   memset (nl, 0, sizeof nl);
  219.   nl[0].n_name = "_proc0paddr";

  221.   if (kvm_nlist (core_kd, nl) == -1)
  222.     error (("%s"), kvm_geterr (core_kd));

  224.   if (nl[0].n_value != 0)
  225.     {
  226.       struct pcb *paddr;

  228.       /* Found proc0paddr.  */
  229.       if (kvm_read (core_kd, nl[0].n_value, &paddr, sizeof paddr) == -1)
  230.         error (("%s"), kvm_geterr (core_kd));

  232.       bsd_kvm_fetch_pcb (regcache, paddr);
  233.       return;
  234.     }

  236. #ifdef HAVE_STRUCT_THREAD_TD_PCB
  237.   /* In FreeBSD kernels for 5.0-RELEASE and later, the PCB no longer
  238.      lives in `struct proc' but in `struct thread'.  The `struct
  239.      thread' for the initial thread for proc0 can be found in the
  240.      variable "thread0".  */

  242.   memset (nl, 0, sizeof nl);
  243.   nl[0].n_name = "_thread0";

  245.   if (kvm_nlist (core_kd, nl) == -1)
  246.     error (("%s"), kvm_geterr (core_kd));

  248.   if (nl[0].n_value != 0)
  249.     {
  250.       struct pcb *paddr;

  252.       /* Found thread0.  */
  253.       nl[0].n_value += offsetof (struct thread, td_pcb);
  254.       if (kvm_read (core_kd, nl[0].n_value, &paddr, sizeof paddr) == -1)
  255.         error (("%s"), kvm_geterr (core_kd));

  257.       bsd_kvm_fetch_pcb (regcache, paddr);
  258.       return;
  259.     }
  260. #endif

  262.   /* i18n: PCB == "Process Control Block".  */
  263.   error (_("Cannot find a valid PCB"));
  264. }


  267. /* Kernel memory interface commands.  */
  268. ‌struct cmd_list_element *bsd_kvm_cmdlist;

  270. static void
  271. ‌bsd_kvm_cmd (char *arg, int fromtty)
  272. {
  273.   /* ??? Should this become an alias for "target kvm"?  */
  274. }

  276. #ifndef HAVE_STRUCT_THREAD_TD_PCB

  278. static void
  279. ‌bsd_kvm_proc_cmd (char *arg, int fromtty)
  280. {
  281.   CORE_ADDR addr;

  283.   if (arg == NULL)
  284.     error_no_arg (_("proc address"));

  286.   if (core_kd == NULL)
  287.     error (_("No kernel memory image."));

  289.   addr = parse_and_eval_address (arg);
  290. #ifdef HAVE_STRUCT_LWP
  291.   addr += offsetof (struct lwp, l_addr);
  292. #else
  293.   addr += offsetof (struct proc, p_addr);
  294. #endif

  296.   if (kvm_read (core_kd, addr, &bsd_kvm_paddr, sizeof bsd_kvm_paddr) == -1)
  297.     error (("%s"), kvm_geterr (core_kd));

  299.   target_fetch_registers (get_current_regcache (), -1);

  301.   reinit_frame_cache ();
  302.   print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
  303. }

  305. #endif

  307. static void
  308. ‌bsd_kvm_pcb_cmd (char *arg, int fromtty)
  309. {
  310.   if (arg == NULL)
  311.     /* i18n: PCB == "Process Control Block".  */
  312.     error_no_arg (_("pcb address"));

  314.   if (core_kd == NULL)
  315.     error (_("No kernel memory image."));

  317.   bsd_kvm_paddr = (struct pcb *)(u_long) parse_and_eval_address (arg);

  319.   target_fetch_registers (get_current_regcache (), -1);

  321.   reinit_frame_cache ();
  322.   print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
  323. }

  325. static int
  326. ‌bsd_kvm_thread_alive (struct target_ops *ops,
  327.                       ptid_t ptid)
  328. {
  329.   return 1;
  330. }

  332. static char *
  333. ‌bsd_kvm_pid_to_str (struct target_ops *ops, ptid_t ptid)
  334. {
  335.   static char buf[64];
  336.   xsnprintf (buf, sizeof buf, "<kvm>");
  337.   return buf;
  338. }

  340. static int
  341. ‌bsd_kvm_return_one (struct target_ops *ops)
  342. {
  343.   return 1;
  344. }

  346. /* Add the libkvm interface to the list of all possible targets and
  347.    register CUPPLY_PCB as the architecture-specific process control
  348.    block interpreter.  */

  350. void
  351. ‌bsd_kvm_add_target (int (*supply_pcb)(struct regcache *, struct pcb *))
  352. {
  353.   gdb_assert (bsd_kvm_supply_pcb == NULL);
  354.   bsd_kvm_supply_pcb = supply_pcb;

  356.   bsd_kvm_ops.to_shortname = "kvm";
  357.   bsd_kvm_ops.to_longname = _("Kernel memory interface");
  358.   bsd_kvm_ops.to_doc = _("Use a kernel virtual memory image as a target.\n\
  359. Optionally specify the filename of a core dump.");
  360.   bsd_kvm_ops.to_open = bsd_kvm_open;
  361.   bsd_kvm_ops.to_close = bsd_kvm_close;
  362.   bsd_kvm_ops.to_fetch_registers = bsd_kvm_fetch_registers;
  363.   bsd_kvm_ops.to_xfer_partial = bsd_kvm_xfer_partial;
  364.   bsd_kvm_ops.to_files_info = bsd_kvm_files_info;
  365.   bsd_kvm_ops.to_thread_alive = bsd_kvm_thread_alive;
  366.   bsd_kvm_ops.to_pid_to_str = bsd_kvm_pid_to_str;
  367.   bsd_kvm_ops.to_stratum = process_stratum;
  368.   bsd_kvm_ops.to_has_memory = bsd_kvm_return_one;
  369.   bsd_kvm_ops.to_has_stack = bsd_kvm_return_one;
  370.   bsd_kvm_ops.to_has_registers = bsd_kvm_return_one;
  371.   bsd_kvm_ops.to_magic = OPS_MAGIC;

  373.   add_target (&bsd_kvm_ops);

  375.   add_prefix_cmd ("kvm", class_obscure, bsd_kvm_cmd, _("\
  376. Generic command for manipulating the kernel memory interface."),
  377.                   &bsd_kvm_cmdlist, "kvm ", 0, &cmdlist);

  379. #ifndef HAVE_STRUCT_THREAD_TD_PCB
  380.   add_cmd ("proc", class_obscure, bsd_kvm_proc_cmd,
  381.            _("Set current context from proc address"), &bsd_kvm_cmdlist);
  382. #endif
  383.   add_cmd ("pcb", class_obscure, bsd_kvm_pcb_cmd,
  384.            /* i18n: PCB == "Process Control Block".  */
  385.            _("Set current context from pcb address"), &bsd_kvm_cmdlist);

  387.   /* Some notes on the ptid usage on this target.

  389.      The pid field represents the kvm inferior instance.  Currently,
  390.      we don't support multiple kvm inferiors, but we start at 1
  391.      anyway.  The lwp field is set to != 0, in case the core wants to
  392.      refer to the whole kvm inferior with ptid(1,0,0).

  394.      If kvm is made to export running processes as gdb threads,
  395.      the following form can be used:
  396.      ptid (1, 1, 0) -> kvm inferior 1, in kernel
  397.      ptid (1, 1, 1) -> kvm inferior 1, process 1
  398.      ptid (1, 1, 2) -> kvm inferior 1, process 2
  399.      ptid (1, 1, n) -> kvm inferior 1, process n  */

  401.   bsd_kvm_ptid = ptid_build (1, 1, 0);
  402. }