Reduce support for thread_db to the barest minimum

The only practical use at this point is to give pthread thread ids for
the threads, so just do that, and make everything else rely on LWPs
everywhere. We can also now get our full CoreRegisters when unwinding
the stack.

Change the register get interfaces to throw exceptions when the fail -
it's too easy to silently ignore at the moment.

Author: peadar

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.10)
-set(PSTACK_SOVERSION 2.15)
-set(PSTACK_VERSION 2.15)
+set(PSTACK_SOVERSION 2.16)
+set(PSTACK_VERSION 2.16)
 project(pstack LANGUAGES C CXX VERSION "${PSTACK_VERSION}" )
 
 include (GNUInstallDirs)

libpstack/proc.h

@@ -3,10 +3,6 @@
 #include <elf.h>
 #include <signal.h>
 #include <memory.h>
-extern "C" {
-    // Some thread_db headers are not safe to include unwrapped in extern "C"
-#include <thread_db.h>
-}
 
 #include <map>
 #include <set>
@@ -16,8 +12,10 @@ extern "C" {
 #include <string_view>
 #include <sys/stat.h> // for ino_t
 #include <ucontext.h> // for gregset_t
+extern "C" { // sigh.
+#include <thread_db.h>
+}
 
-#include "libpstack/ps_callback.h"
 #include "libpstack/dwarf.h"
 #include "libpstack/arch.h"
 
@@ -172,13 +170,16 @@ struct PrintableFrame {
 
 };
 
-struct ThreadStack {
-    td_thrinfo_t info {};
+struct Lwp {
+    lwpid_t id;
     std::optional<std::string> name;
+    std::optional<td_thrinfo_t> threadInfo;
     std::vector<StackFrame> stack;
     void unwind(Process &, const CoreRegisters &regs);
 };
 
+using Stacks = std::map<lwpid_t, Lwp>;
+
 struct DevNode {
     int major = -1;
     int minor = -1;
@@ -270,8 +271,20 @@ class Process : public ps_prochandle {
 
     virtual size_t getRegs(lwpid_t pid, int code, size_t size, void *data) = 0;
 
-    template <typename T, int code> size_t getRegset(lwpid_t pid, T &reg) {
-        return getRegs(pid, code, sizeof (T), reinterpret_cast<void *>( &reg ) );
+    template <typename T, int code> void getRegset(lwpid_t pid, T &reg) {
+        size_t rc = getRegs(pid, code, sizeof (T), reinterpret_cast<void *>( &reg ) );
+        if (rc == 0) {
+           // Failed
+           throw (Exception()
+                 << "failed to get register set " << code << " for " << pid
+                 << ": " << strerror(errno));
+        }
+        if (rc < sizeof (T)) {
+           // worked, but size doesn't match.
+           throw (Exception()
+                 << "invalid register set size, got " << rc
+                 << ", expected " << sizeof(T));
+        }
     }
     CoreRegisters getCoreRegs(lwpid_t lwp);
 
@@ -287,7 +300,7 @@ class Process : public ps_prochandle {
     virtual void resumeProcess() = 0;
     virtual void resume(pid_t lwpid) = 0;
     virtual Elf::Object::sptr executableImage() { return nullptr; }
-    std::ostream &dumpStackText(std::ostream &, const ThreadStack &);
+    std::ostream &dumpStackText(std::ostream &, const Lwp &);
     std::ostream &dumpFrameText(std::ostream &, const StackFrame &, int);
     template <typename T> void listThreads(const T &invokeable);
     virtual void listLWPs(const std::function<void(lwpid_t)> &) {};
@@ -301,7 +314,7 @@ class Process : public ps_prochandle {
     std::tuple<Elf::Object::sptr, Elf::Addr, Elf::Sym>
         resolveSymbolDetail(const char *name, bool includeDebug,
                 std::function<bool(std::string_view)> match = [](std::string_view) { return true; });
-    virtual std::list<ThreadStack> getStacks();
+    virtual Stacks getStacks();
     void load();
     [[nodiscard]] virtual pid_t getPID() const = 0;
     [[nodiscard]] virtual AddressSpace addressSpace() const = 0;
@@ -471,7 +484,7 @@ std::ostream &operator << (std::ostream &os, WaitStatus ws);
 }
 
 std::ostream &operator << (std::ostream &os, const JSON<pstack::Procman::StackFrame, pstack::Procman::Process *> &jt);
-std::ostream &operator << (std::ostream &os, const JSON<pstack::Procman::ThreadStack, pstack::Procman::Process *> &jt);
+std::ostream &operator << (std::ostream &os, const JSON<pstack::Procman::Lwp, pstack::Procman::Process *> &jt);
 
 }
 

libpstack/ps_callback.h

@@ -1,5 +1,4 @@
 #include "libpstack/proc.h"
-#include "libpstack/ps_callback.h"
 #include "libpstack/stringify.h"
 
 #include <sys/ptrace.h>
@@ -31,7 +30,6 @@ LiveProcess::LiveProcess(Context &context, Elf::Object::sptr &ex, pid_t pid_, bo
     : Process( context, ex, std::make_shared<CacheReader>(std::make_shared<LiveReader>(context, pid_, "mem")))
     , pid(pid_)
 {
-    (void)ps_getpid(this);
     if (alreadyStopped)
        stoppedLWPs[pid].stopCount = 1;
 }

live.cc

@@ -1,6 +1,7 @@
 #include "libpstack/proc.h"
-#include "libpstack/ps_callback.h"
 
+#include <thread_db.h>
+#include <proc_service.h>
 #include <cstdarg>
 
 using pstack::Procman::Process;
@@ -9,9 +10,9 @@ using namespace pstack;
 extern "C" {
 
 ps_err_e
-ps_pcontinue(const struct ps_prochandle *ph)
+ps_pcontinue(struct ps_prochandle *ph)
 {
-    auto p = const_cast<Process *>(static_cast<const Process *>(ph));
+    auto p = static_cast<Process *>(ph);
     try {
         p->resumeProcess();
         return PS_OK;
@@ -22,9 +23,9 @@ ps_pcontinue(const struct ps_prochandle *ph)
 }
 
 ps_err_e
-ps_lcontinue(const struct ps_prochandle *ph, lwpid_t pid)
+ps_lcontinue(struct ps_prochandle *ph, lwpid_t pid)
 {
-    auto p = const_cast<Process *>(static_cast<const Process *>(ph));
+    auto p = static_cast<Process *>(ph);
     try {
         p->resume(pid);
         return PS_OK;
@@ -87,9 +88,9 @@ ps_pread(struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t len)
 }
 
 ps_err_e
-ps_pstop(const struct ps_prochandle *ph)
+ps_pstop(struct ps_prochandle *ph)
 {
-    auto *p = const_cast<Process *>(static_cast<const Process *>(ph));
+    auto *p = static_cast<Process *>(ph);
     try {
         p->stopProcess();
         return PS_OK;
@@ -174,8 +175,15 @@ ps_err_e ps_lgetfpregs(struct ps_prochandle * /* unused */, lwpid_t /* unused */
 
 ps_err_e ps_lgetregs(struct ps_prochandle *ph, lwpid_t pid, prgregset_t gregset)
 {
-    auto p = static_cast<Process *>(ph);
-    return p->getRegset<user_regs_struct, NT_PRSTATUS>(pid, *reinterpret_cast<user_regs_struct *>(gregset)) ? PS_OK : PS_ERR;
+   auto p = static_cast<Process *>(ph);
+   auto gregs = reinterpret_cast<user_regs_struct *>(gregset);
+   try {
+      p->getRegset<user_regs_struct, NT_PRSTATUS>(pid, *gregs);
+      return PS_OK;
+   }
+   catch (const Exception &ex) {
+      return PS_ERR;
+   }
 }
 
 ps_err_e ps_lsetfpregs(struct ps_prochandle * /* unused */, lwpid_t /* unused */,
@@ -192,9 +200,9 @@ ps_err_e ps_lsetregs(struct ps_prochandle * /* unused */, lwpid_t /* unused */,
     return (PS_ERR);
 }
 
-ps_err_e ps_lstop(const struct ps_prochandle *ph, lwpid_t lwpid)
+ps_err_e ps_lstop(struct ps_prochandle *ph, lwpid_t lwpid)
 {
-    Process *p = const_cast<Process *>(static_cast<const Process *>(ph));
+    auto p = static_cast<Process *>(ph);
     try {
         p->stop(lwpid);
         return PS_OK;