Implement "record btrace pt" for Windows

Author: ssbssa

gdb/Makefile.in

@@ -208,6 +208,9 @@ LIBXXHASH = @LIBXXHASH@
 # Where is libipt?  This will be empty if libipt was not available.
 LIBIPT = @LIBIPT@
 
+# Where is libwinipt?  This will be empty if libwinipt was not available.
+LIBWINIPT = @LIBWINIPT@
+
 # How to find GMP and MPFR
 GMPLIBS = @GMPLIBS@
 GMPINC = @GMPINC@
@@ -661,7 +664,7 @@ CLIBS = $(SIM) $(READLINE) $(OPCODES) $(LIBCTF) $(BFD) $(ZLIB) $(ZSTD_LIBS) \
         $(LIBSUPPORT) $(INTL) $(LIBIBERTY) $(LIBDECNUMBER) \
 	$(XM_CLIBS) $(GDBTKLIBS)  $(LIBBACKTRACE_LIB) \
 	@LIBS@ @GUILE_LIBS@ @PYTHON_LIBS@ $(AMD_DBGAPI_LIBS) \
-	$(LIBEXPAT) $(LIBLZMA) $(LIBBABELTRACE) $(LIBIPT) \
+	$(LIBEXPAT) $(LIBLZMA) $(LIBBABELTRACE) $(LIBIPT) $(LIBWINIPT) \
 	$(WIN32LIBS) $(LIBGNU) $(LIBGNU_EXTRA_LIBS) $(LIBICONV) \
 	$(GMPLIBS) $(SRCHIGH_LIBS) $(LIBXXHASH) $(PTHREAD_LIBS) \
 	$(DEBUGINFOD_LIBS) $(LIBBABELTRACE_LIB)

gdb/config.in

@@ -268,6 +268,9 @@
 /* Define to 1 if you have the <libunwind-ia64.h> header file. */
 #undef HAVE_LIBUNWIND_IA64_H
 
+/* Define if you have the winipt library. */
+#undef HAVE_LIBWINIPT
+
 /* Define if you have the xxhash library. */
 #undef HAVE_LIBXXHASH
 

gdb/configure

@@ -76,12 +76,21 @@
 #include "gdbsupport/symbol.h"
 #include "ser-event.h"
 #include "inf-loop.h"
+#include "nat/x86-cpuid.h"
 
 #include "readline/readline.h"
 #ifdef TUI
 #include "tui/tui-win.h"
 #endif
 
+#ifdef HAVE_LIBWINIPT
+#undef C_ASSERT
+#define C_ASSERT(e)
+extern "C" {
+#include <libipt.h>
+}
+#endif
+
 using namespace windows_nat;
 
 /* Maintain a linked list of "so" information.  */
@@ -154,6 +163,8 @@ struct windows_per_inferior : public windows_process_info
   CORE_ADDR cygwin_load_start = 0;
   CORE_ADDR cygwin_load_end = 0;
 #endif /* __CYGWIN__ */
+
+  int pt_threads = 0;
 };
 
 /* The current process.  */
@@ -375,6 +386,17 @@ struct windows_nat_target final : public x86_nat_target<inf_child_target>
 
   bool info_proc (const char *, enum info_proc_what) override;
 
+#ifdef HAVE_LIBWINIPT
+  struct btrace_target_info *enable_btrace (thread_info *tp,
+					    const struct btrace_config *conf) override;
+  void disable_btrace (struct btrace_target_info *tinfo) override;
+  void teardown_btrace (struct btrace_target_info *tinfo) override;
+  enum btrace_error read_btrace (struct btrace_data *data,
+				 struct btrace_target_info *btinfo,
+				 enum btrace_read_type type) override;
+  const struct btrace_config *btrace_conf (const struct btrace_target_info *) override;
+#endif
+
 private:
 
   windows_thread_info *add_thread (ptid_t ptid, HANDLE h, void *tlb,
@@ -2595,6 +2617,304 @@ windows_nat_target::info_proc (const char *args, enum info_proc_what what)
   return true;
 }
 
+#ifdef HAVE_LIBWINIPT
+struct handle_deleter
+{
+  void operator() (HANDLE h) const
+    {
+      if (h != INVALID_HANDLE_VALUE)
+	CloseHandle (h);
+    }
+  using pointer = HANDLE;
+};
+
+using handle_up = std::unique_ptr<HANDLE, handle_deleter>;
+
+struct sc_handle_deleter
+{
+  void operator() (SC_HANDLE sch) const
+    {
+      CloseServiceHandle (sch);
+    }
+  using pointer = SC_HANDLE;
+};
+
+using sc_handle_up = std::unique_ptr<SC_HANDLE, sc_handle_deleter>;
+
+static void windows_enable_ipt_service ()
+{
+  sc_handle_up scManager
+    (OpenSCManager (nullptr, nullptr, SC_MANAGER_CONNECT));
+  if (!scManager)
+    {
+      unsigned err = (unsigned) GetLastError ();
+      error (_("Can't open SCM handle (error %u: %s)."),
+	     err, strwinerror (err));
+    }
+
+  sc_handle_up scService
+    (OpenServiceW (scManager.get (), L"Ipt", SERVICE_START));
+  if (!scService)
+    {
+      unsigned err = (unsigned) GetLastError ();
+      error (_("Can't open IPT service (error %u: %s)."),
+	     err, strwinerror (err));
+    }
+
+  if (!StartService (scService.get (), 0, nullptr))
+    {
+      unsigned err = (unsigned) GetLastError ();
+      if (err != ERROR_SERVICE_ALREADY_RUNNING)
+	error (_("Can't start IPT service (error %u: %s)."),
+	       err, strwinerror (err));
+    }
+}
+
+static struct btrace_target_info *
+windows_enable_btrace (ptid_t ptid, const struct btrace_config *conf)
+{
+  if (conf->format != BTRACE_FORMAT_PT)
+    error (_("Unknown branch trace format."));
+
+  DWORD size = conf->pt.size;
+  if (size < 4 * 1024)
+    size = 4 * 1024;
+  else if (size > 128 * 1024 * 1024)
+    size = 128 * 1024 * 1024;
+
+  if (windows_process.pt_threads == 0)
+    {
+      windows_enable_ipt_service ();
+
+      DWORD bufferVersion;
+      if (!GetIptBufferVersion (&bufferVersion))
+	error (_("Can't get IPT buffer version."));
+      if (bufferVersion != IPT_BUFFER_MAJOR_VERSION_CURRENT)
+	error (_("IPT buffer version mismatch."));
+
+      WORD traceVersion;
+      if (!GetIptTraceVersion (&traceVersion))
+	error (_("Can't get IPT trace version."));
+      if (traceVersion != IPT_TRACE_VERSION_CURRENT)
+	error (_("IPT trace version mismatch."));
+
+      int pid = ptid.pid ();
+      handle_up hProcess (OpenProcess (PROCESS_VM_READ, FALSE, pid));
+      if (!hProcess)
+	{
+	  unsigned err = (unsigned) GetLastError ();
+	  error (_("Can't open process handle (error %u: %s)."),
+		 err, strwinerror (err));
+	}
+
+      DWORD index;
+      BitScanReverse(&index, size);
+
+      IPT_OPTIONS options;
+      options.AsULonglong = 0;
+      options.OptionVersion = 1;
+      options.TopaPagesPow2 = index - 12;
+      options.TimingSettings = IptNoTimingPackets;
+      options.ModeSettings = IptCtlUserModeOnly;
+
+      if (!StartProcessIptTracing (hProcess.get (), options))
+	error (_("Can't start trace."));
+    }
+
+  windows_process.pt_threads++;
+
+  std::unique_ptr<btrace_target_info> tinfo
+    { gdb::make_unique<btrace_target_info> (ptid) };
+
+  tinfo->conf.format = BTRACE_FORMAT_PT;
+  tinfo->conf.pt.size = size;
+
+  return tinfo.release ();
+}
+
+static bool
+windows_disable_btrace (struct btrace_target_info *tinfo)
+{
+  if (tinfo->conf.format != BTRACE_FORMAT_PT)
+    return false;
+
+  if (--windows_process.pt_threads > 0)
+    return true;
+
+  int pid = tinfo->ptid.pid ();
+  handle_up hProcess (OpenProcess (PROCESS_VM_READ, FALSE, pid));
+  if (!hProcess)
+    return false;
+
+  if (!StopProcessIptTracing (hProcess.get ()))
+    return false;
+
+  return true;
+}
+
+/* Identify the cpu we're running on.  */
+static struct btrace_cpu
+btrace_this_cpu (void)
+{
+  struct btrace_cpu cpu;
+  unsigned int eax, ebx, ecx, edx;
+  int ok;
+
+  memset (&cpu, 0, sizeof (cpu));
+
+  ok = x86_cpuid (0, &eax, &ebx, &ecx, &edx);
+  if (ok != 0)
+    {
+      if (ebx == signature_INTEL_ebx && ecx == signature_INTEL_ecx
+	  && edx == signature_INTEL_edx)
+	{
+	  unsigned int cpuid, ignore;
+
+	  ok = x86_cpuid (1, &cpuid, &ignore, &ignore, &ignore);
+	  if (ok != 0)
+	    {
+	      cpu.vendor = CV_INTEL;
+
+	      cpu.family = (cpuid >> 8) & 0xf;
+	      if (cpu.family == 0xf)
+		cpu.family += (cpuid >> 20) & 0xff;
+
+	      cpu.model = (cpuid >> 4) & 0xf;
+	      if ((cpu.family == 0x6) || ((cpu.family & 0xf) == 0xf))
+		cpu.model += (cpuid >> 12) & 0xf0;
+	    }
+	}
+      else if (ebx == signature_AMD_ebx && ecx == signature_AMD_ecx
+	       && edx == signature_AMD_edx)
+	cpu.vendor = CV_AMD;
+    }
+
+  return cpu;
+}
+
+static enum btrace_error
+windows_read_btrace (struct btrace_data *data,
+    struct btrace_target_info *btinfo,
+    enum btrace_read_type type)
+{
+  if (btinfo->conf.format != BTRACE_FORMAT_PT)
+    return BTRACE_ERR_NOT_SUPPORTED;
+
+  data->format = BTRACE_FORMAT_PT;
+  data->variant.pt.data = nullptr;
+  data->variant.pt.size = 0;
+  data->variant.pt.config.cpu = btrace_this_cpu ();
+
+  if (type == BTRACE_READ_NEW)
+    type = BTRACE_READ_ALL;
+
+  if (type != BTRACE_READ_ALL)
+    return BTRACE_ERR_NOT_SUPPORTED;
+
+  int pid = btinfo->ptid.pid ();
+  handle_up hProcess (OpenProcess (PROCESS_VM_READ, FALSE, pid));
+  if (!hProcess)
+    return BTRACE_ERR_UNKNOWN;
+
+  DWORD traceSize;
+  if (!GetProcessIptTraceSize (hProcess.get (), &traceSize))
+    return BTRACE_ERR_UNKNOWN;
+
+  gdb::unique_xmalloc_ptr<unsigned char> buf
+    ((unsigned char *) xmalloc (traceSize));
+
+  if (!GetProcessIptTrace (hProcess.get (), buf.get (), traceSize))
+    return BTRACE_ERR_UNKNOWN;
+
+  IPT_TRACE_DATA *pt_data = (IPT_TRACE_DATA *) buf.get ();
+  unsigned char *buf_end = buf.get () + traceSize;
+  size_t trace_offset = offsetof (IPT_TRACE_HEADER, Trace);
+
+  DWORD threadId = btinfo->ptid.lwp ();
+  IPT_TRACE_HEADER *pt_thread = (IPT_TRACE_HEADER *) pt_data->TraceData;
+  while ((unsigned char *) pt_thread + trace_offset < buf_end
+	 && pt_thread->Trace + pt_thread->TraceSize <= buf_end)
+    {
+      if (pt_thread->ThreadId == threadId)
+	{
+	  uint32_t trace_size = pt_thread->TraceSize;
+	  BYTE *trace_data = pt_thread->Trace;
+	  gdb::unique_xmalloc_ptr<gdb_byte> bytes
+	    ((gdb_byte *) xmalloc (trace_size));
+	  uint32_t start = pt_thread->RingBufferOffset;
+	  if (start > 0)
+	    memcpy (bytes.get () + (trace_size - start), trace_data, start);
+	  memcpy (bytes.get (), trace_data + start, trace_size - start);
+
+	  data->variant.pt.data = bytes.release ();
+	  data->variant.pt.size = trace_size;
+	  return BTRACE_ERR_NONE;
+	}
+
+      pt_thread
+	= (IPT_TRACE_HEADER *) (pt_thread->Trace + pt_thread->TraceSize);
+    }
+
+  return BTRACE_ERR_UNKNOWN;
+}
+
+static const struct btrace_config *
+windows_btrace_conf (const struct btrace_target_info *btinfo)
+{
+  return &btinfo->conf;
+}
+
+struct btrace_target_info *
+windows_nat_target::enable_btrace (thread_info *tp,
+				   const struct btrace_config *conf)
+{
+  struct btrace_target_info *tinfo = nullptr;
+  ptid_t ptid = tp->ptid;
+  try
+    {
+      tinfo = windows_enable_btrace (ptid, conf);
+    }
+  catch (const gdb_exception_error &exception)
+    {
+      error (_("Could not enable branch tracing for %s: %s"),
+	     target_pid_to_str (ptid).c_str (), exception.what ());
+    }
+
+  return tinfo;
+}
+
+void
+windows_nat_target::disable_btrace (struct btrace_target_info *tinfo)
+{
+  bool ret = windows_disable_btrace (tinfo);
+  delete tinfo;
+
+  if (!ret)
+    error (_("Could not disable branch tracing."));
+}
+
+void
+windows_nat_target::teardown_btrace (struct btrace_target_info *tinfo)
+{
+  windows_disable_btrace (tinfo);
+  delete tinfo;
+}
+
+enum btrace_error
+windows_nat_target::read_btrace (struct btrace_data *data,
+				 struct btrace_target_info *btinfo,
+				 enum btrace_read_type type)
+{
+  return windows_read_btrace (data, btinfo, type);
+}
+
+const struct btrace_config *
+windows_nat_target::btrace_conf (const struct btrace_target_info *btinfo)
+{
+  return windows_btrace_conf (btinfo);
+}
+#endif
+
 /* Try to set or remove a user privilege to the current process.  Return -1
    if that fails, the previous setting of that privilege otherwise.
 

gdb/windows-nat.c

@@ -143,6 +143,9 @@
 /* Define if you have the ipt library. */
 #undef HAVE_LIBIPT
 
+/* Define if you have the winipt library. */
+#undef HAVE_LIBWINIPT
+
 /* Define if you have the xxhash library. */
 #undef HAVE_LIBXXHASH
 

gdbserver/config.in

@@ -254,6 +254,7 @@ GMSGFMT = @GMSGFMT@
 GREP = @GREP@
 HAVE_CXX11 = @HAVE_CXX11@
 HAVE_LIBIPT = @HAVE_LIBIPT@
+HAVE_LIBWINIPT = @HAVE_LIBWINIPT@
 HAVE_LIBXXHASH = @HAVE_LIBXXHASH@
 INCINTL = @INCINTL@
 INSTALL = @INSTALL@
@@ -269,9 +270,11 @@ LIBINTL_DEP = @LIBINTL_DEP@
 LIBIPT = @LIBIPT@
 LIBOBJS = @LIBOBJS@
 LIBS = @LIBS@
+LIBWINIPT = @LIBWINIPT@
 LIBXXHASH = @LIBXXHASH@
 LTLIBIPT = @LTLIBIPT@
 LTLIBOBJS = @LTLIBOBJS@
+LTLIBWINIPT = @LTLIBWINIPT@
 LTLIBXXHASH = @LTLIBXXHASH@
 MAINT = @MAINT@
 MAKEINFO = @MAKEINFO@

gdbserver/configure

@@ -193,6 +193,11 @@ AC_DEFUN([GDB_AC_COMMON], [
       AC_CHECK_MEMBERS([struct pt_insn.enabled, struct pt_insn.resynced], [], [],
 		       [#include <intel-pt.h>])
       LIBS=$save_LIBS
+
+      AC_LIB_HAVE_LINKFLAGS([winipt], [], [
+#include <windows.h>
+#include <libipt.h>
+      ], [GetIptBufferVersion (0);])
     fi
   fi
 

gdbsupport/Makefile.in

@@ -124,6 +124,9 @@
 /* Define if you have the ipt library. */
 #undef HAVE_LIBIPT
 
+/* Define if you have the winipt library. */
+#undef HAVE_LIBWINIPT
+
 /* Define if you have the xxhash library. */
 #undef HAVE_LIBXXHASH