/* BSD Kernel Data Access Library (libkvm) interface.
- Copyright (C) 2004-2018 Free Software Foundation, Inc.
+ Copyright (C) 2004-2022 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "cli/cli-cmds.h"
#include "command.h"
+#include "filenames.h"
#include "frame.h"
#include "regcache.h"
#include "target.h"
+#include "process-stratum-target.h"
#include "value.h"
-#include "gdbcore.h" /* for get_exec_file */
+#include "gdbcore.h"
+#include "inferior.h" /* for get_exec_file */
#include "gdbthread.h"
+#include "gdbsupport/pathstuff.h"
+#include "gdbsupport/gdb_tilde_expand.h"
#include <fcntl.h>
#include <kvm.h>
#include "bsd-kvm.h"
/* Kernel memory device file. */
-static const char *bsd_kvm_corefile;
+static std::string bsd_kvm_corefile;
/* Kernel memory interface descriptor. */
static kvm_t *core_kd;
/* The libkvm target. */
-class bsd_kvm_target final : public target_ops
+static const target_info bsd_kvm_target_info = {
+ "kvm",
+ N_("Kernel memory interface"),
+ N_("Use a kernel virtual memory image as a target.\n\
+Optionally specify the filename of a core dump.")
+};
+
+class bsd_kvm_target final : public process_stratum_target
{
public:
- bsd_kvm_target ()
- { this->to_stratum = process_stratum; }
-
- const char *shortname () override
- { return "kvm"; }
-
- const char *longname () override
- { return _("Kernel memory interface"); }
+ bsd_kvm_target () = default;
- const char *doc () override
- {
- return _("Use a kernel virtual memory image as a target.\n\
-Optionally specify the filename of a core dump.");
- }
+ const target_info &info () const override
+ { return bsd_kvm_target_info; }
- void open (const char *, int) override;
void close () override;
void fetch_registers (struct regcache *, int) override;
ULONGEST *xfered_len) override;
void files_info () override;
- int thread_alive (ptid_t ptid) override;
- const char *pid_to_str (ptid_t) override;
+ bool thread_alive (ptid_t ptid) override;
+ std::string pid_to_str (ptid_t) override;
- int has_memory () override { return 1; }
- int has_stack () override { return 1; }
- int has_registers () override { return 1; }
+ bool has_memory () override { return true; }
+ bool has_stack () override { return true; }
+ bool has_registers () override { return true; }
};
/* Target ops for libkvm interface. */
static bsd_kvm_target bsd_kvm_ops;
static void
-bsd_kvm_target::open (const char *arg, int from_tty)
+bsd_kvm_target_open (const char *arg, int from_tty)
{
char errbuf[_POSIX2_LINE_MAX];
- char *execfile = NULL;
+ const char *execfile = NULL;
kvm_t *temp_kd;
- char *filename = NULL;
+ std::string filename;
target_preopen (from_tty);
if (arg)
{
- char *temp;
-
- filename = tilde_expand (arg);
- if (filename[0] != '/')
- {
- temp = concat (current_directory, "/", filename, (char *)NULL);
- xfree (filename);
- filename = temp;
- }
+ filename = gdb_tilde_expand (arg);
+ if (!IS_ABSOLUTE_PATH (filename))
+ filename = gdb_abspath (filename.c_str ());
}
execfile = get_exec_file (0);
- temp_kd = kvm_openfiles (execfile, filename, NULL,
+ temp_kd = kvm_openfiles (execfile, filename.c_str (), NULL,
write_files ? O_RDWR : O_RDONLY, errbuf);
if (temp_kd == NULL)
error (("%s"), errbuf);
bsd_kvm_corefile = filename;
- unpush_target (&bsd_kvm_ops);
+ current_inferior ()->unpush_target (&bsd_kvm_ops);
core_kd = temp_kd;
- push_target (&bsd_kvm_ops);
+ current_inferior ()->push_target (&bsd_kvm_ops);
- add_thread_silent (bsd_kvm_ptid);
- inferior_ptid = bsd_kvm_ptid;
+ thread_info *thr = add_thread_silent (&bsd_kvm_ops, bsd_kvm_ptid);
+ switch_to_thread (thr);
target_fetch_registers (get_current_regcache (), -1);
core_kd = NULL;
}
- inferior_ptid = null_ptid;
- delete_thread_silent (bsd_kvm_ptid);
+ bsd_kvm_corefile.clear ();
+ switch_to_no_thread ();
+ exit_inferior_silent (current_inferior ());
}
static LONGEST
void
bsd_kvm_target::files_info ()
{
- if (bsd_kvm_corefile && strcmp (bsd_kvm_corefile, _PATH_MEM) != 0)
- printf_filtered (_("\tUsing the kernel crash dump %s.\n"),
- bsd_kvm_corefile);
+ if (bsd_kvm_corefile != _PATH_MEM)
+ gdb_printf (_("\tUsing the kernel crash dump %s.\n"),
+ bsd_kvm_corefile.c_str ());
else
- printf_filtered (_("\tUsing the currently running kernel.\n"));
+ gdb_printf (_("\tUsing the currently running kernel.\n"));
}
/* Fetch process control block at address PADDR. */
/* On dumping core, BSD kernels store the faulting context (PCB)
in the variable "dumppcb". */
memset (nl, 0, sizeof nl);
- nl[0].n_name = "_dumppcb";
+ nl[0].n_name = (char *) "_dumppcb";
if (kvm_nlist (core_kd, nl) == -1)
error (("%s"), kvm_geterr (core_kd));
"proc0paddr". */
memset (nl, 0, sizeof nl);
- nl[0].n_name = "_proc0paddr";
+ nl[0].n_name = (char *) "_proc0paddr";
if (kvm_nlist (core_kd, nl) == -1)
error (("%s"), kvm_geterr (core_kd));
variable "thread0". */
memset (nl, 0, sizeof nl);
- nl[0].n_name = "_thread0";
+ nl[0].n_name = (char *) "_thread0";
if (kvm_nlist (core_kd, nl) == -1)
error (("%s"), kvm_geterr (core_kd));
print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
}
-int
+bool
bsd_kvm_target::thread_alive (ptid_t ptid)
{
- return 1;
+ return true;
}
-const char *
+std::string
bsd_kvm_target::pid_to_str (ptid_t ptid)
{
- static char buf[64];
- xsnprintf (buf, sizeof buf, "<kvm>");
- return buf;
+ return "<kvm>";
}
/* Add the libkvm interface to the list of all possible targets and
gdb_assert (bsd_kvm_supply_pcb == NULL);
bsd_kvm_supply_pcb = supply_pcb;
- add_target (&bsd_kvm_ops);
+ add_target (bsd_kvm_target_info, bsd_kvm_target_open);
add_prefix_cmd ("kvm", class_obscure, bsd_kvm_cmd, _("\
Generic command for manipulating the kernel memory interface."),
- &bsd_kvm_cmdlist, "kvm ", 0, &cmdlist);
+ &bsd_kvm_cmdlist, 0, &cmdlist);
#ifndef HAVE_STRUCT_THREAD_TD_PCB
add_cmd ("proc", class_obscure, bsd_kvm_proc_cmd,
ptid (1, 1, 2) -> kvm inferior 1, process 2
ptid (1, 1, n) -> kvm inferior 1, process n */
- bsd_kvm_ptid = ptid_build (1, 1, 0);
+ bsd_kvm_ptid = ptid_t (1, 1, 0);
}
projects / binutils-gdb.git / blobdiff