Build both static and shared libraries

Use shims for any shared libraries we require at runtime (zlib, xz,
threaddb), so we can detect their presence and adjust behaviour at
runtime instead of build time. This allows us to link to libdwelf and
libprocman statically with minimal fuss.

Author: peadar

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.10)
 set(PSTACK_SOVERSION 2.17)
-set(PSTACK_VERSION 2.17.3)
+set(PSTACK_VERSION 2.17.4)
 project(pstack LANGUAGES C CXX VERSION "${PSTACK_VERSION}" )
 
 include (GNUInstallDirs)
@@ -18,12 +18,10 @@ set(PSTACK_BIN "pstack" CACHE STRING "Name of the 'pstack' binary")
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
 set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/" CACHE STRING "Rpath to install for binaries or the empty string")
-set(LIBTYPE "SHARED" CACHE STRING "Build libraries as STATIC or SHARED")
 option(TIDY "Run clang-tidy on the source" False)
 
-find_library(LTHREADDB NAMES thread_db PATHS (/usr/lib /usr/local/lib))
-find_package(LibLZMA)
-find_package(ZLIB)
+find_package(LibLZMA REQUIRED)
+find_package(ZLIB REQUIRED)
 
 if (PYTHON2)
    find_package(Python2 COMPONENTS Development)
@@ -60,18 +58,10 @@ add_definitions("-fno-omit-frame-pointer")
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 # Make sure to use the local libpstack headers rather than what's installed.
 include_directories(${CMAKE_SOURCE_DIR})
+include_directories(${ZLIB_INCLUDE_DIRS})
 
-if (LIBLZMA_FOUND)
-   set(lzmasrc lzma.cc)
-   add_definitions("-DWITH_LZMA")
-   include_directories(${LIBLZMA_INCLUDES})
-endif()
+include_directories(${LIBLZMA_INCLUDE_DIRS})
 
-if (ZLIB_FOUND)
-   set(inflatesrc inflate.cc)
-   add_definitions("-DWITH_ZLIB")
-   include_directories(${ZLIB_INCLUDES})
-endif()
 
 if (Python3_Development_FOUND OR Python2_Development_FOUND)
    set(pysrc python.cc)
@@ -95,7 +85,7 @@ endif()
 
 add_definitions("-g3")
 
-add_library(dwelf ${LIBTYPE}
+add_library(dwelf_objects OBJECT
          dwarf_die.cc
          dwarf_frame.cc
          dwarf_info.cc
@@ -109,35 +99,43 @@ add_library(dwelf ${LIBTYPE}
          elf.cc
          flags.cc
          reader.cc
-         ${inflatesrc}
-         ${lzmasrc}
+         inflate.cc
+         lzma.cc
          )
 
-add_library(procman ${LIBTYPE} dead.cc self.cc live.cc process.cc proc_service.cc
-    dwarfproc.cc procdump.cc ${stubsrc} ${pysrc})
+add_library(procman_objects OBJECT dead.cc self.cc live.cc process.cc proc_service.cc
+    dwarfproc.cc procdump.cc threaddb.cc ${pysrc})
+
+add_library(dwelf SHARED $<TARGET_OBJECTS:dwelf_objects>)
+add_library(dwelf_static STATIC $<TARGET_OBJECTS:dwelf_objects>)
+set_target_properties(dwelf_static PROPERTIES OUTPUT_NAME dwelf_s)
+
+add_library(procman SHARED $<TARGET_OBJECTS:procman_objects>)
+add_library(procman_static STATIC $<TARGET_OBJECTS:procman_objects>)
+set_target_properties(procman_static PROPERTIES OUTPUT_NAME procman_s)
+
+option(LINK_STATIC "Link binaries against static libraries" OFF)
+if (LINK_STATIC)
+   set(PSTACK_LINK_LIBS procman_static dwelf_static)
+else()
+   set(PSTACK_LINK_LIBS dwelf procman)
+endif()
 
 add_executable(canal canal.cc)
 
 add_executable(${PSTACK_BIN} pstack.cc)
 
-target_link_libraries(procman ${LTHREADDB} dwelf dl)
-target_link_libraries(${PSTACK_BIN} dwelf procman)
-target_link_libraries(canal dwelf procman)
+target_link_libraries(procman dwelf dl)
+target_link_libraries(procman_static dwelf_static dl)
+target_link_libraries(${PSTACK_BIN} ${PSTACK_LINK_LIBS})
+target_link_libraries(canal ${PSTACK_LINK_LIBS})
+target_link_options(${PSTACK_BIN} PRIVATE -Wl,--export-dynamic)
+target_link_options(canal PRIVATE -Wl,--export-dynamic)
 
-set_target_properties(dwelf PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION "${PSTACK_SOVERSION}" )
-set_target_properties(procman PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION "${PSTACK_SOVERSION}" )
+set_target_properties(dwelf PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION "${PSTACK_SOVERSION}")
+set_target_properties(procman PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION "${PSTACK_SOVERSION}")
 
-if (ZLIB_FOUND)
-   target_link_libraries(dwelf ${ZLIB_LIBRARIES})
-else()
-   message(WARNING "no ZLIB support found")
-endif()
 
-if (LIBLZMA_FOUND)
-   target_link_libraries(dwelf ${LIBLZMA_LIBRARIES})
-else()
-   message(WARNING "no LZMA support found")
-endif()
 
 if ((NOT (Python3_Development_FOUND)) AND PYTHON3)
    message(WARNING "no python3 support found")
@@ -151,13 +149,13 @@ endif()
 add_library(hdbg SHARED heap.c)
 add_executable(hdmp hdmp.cc)
 add_executable(stackusers stackusers.cc)
-target_link_libraries(hdmp dwelf procman)
+target_link_libraries(hdmp ${PSTACK_LINK_LIBS})
 target_link_libraries(hdbg dl)
-target_link_libraries(stackusers dwelf procman)
+target_link_libraries(stackusers ${PSTACK_LINK_LIBS})
 
 install(TARGETS ${PSTACK_BIN} canal)
 install(TARGETS hdmp)
-install(TARGETS dwelf procman hdbg)
+install(TARGETS dwelf procman dwelf_static procman_static hdbg)
 install(FILES ${CMAKE_SOURCE_DIR}/pstack.1 DESTINATION share/man/man1 RENAME ${PSTACK_BIN}.1 )
 install(DIRECTORY libpstack DESTINATION include)
 install(CODE "execute_process (COMMAND setcap cap_sys_ptrace+ep ${DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/${PSTACK_BIN} RESULT_VARIABLE ret)

elf.cc

@@ -1,12 +1,8 @@
 #include "libpstack/elf.h"
 #include "libpstack/stringify.h"
 #include "libpstack/ioflag.h"
-#ifdef WITH_ZLIB
 #include "libpstack/inflatereader.h"
-#endif
-#ifdef WITH_LZMA
 #include "libpstack/lzmareader.h"
-#endif
 
 #include <algorithm>
 #include <filesystem>
@@ -400,20 +396,20 @@ Object::getInterpreter() const
 
 Elf::Object::sptr Object::debugData() const {
     if (debugData_ == nullptr) {
-#ifdef WITH_LZMA
-        auto &gnu_debugdata = getSection(".gnu_debugdata", SHT_NULL );
-        if (gnu_debugdata) {
-           auto reader = make_shared<const LzmaReader>(gnu_debugdata.io());
-           debugData_ = make_shared<Object>(context, reader, true);
-        }
-#else
-        static bool warned = false;
-        if (!warned && context.debug != nullptr) {
-            *context.debug << "warning: no compiled support for LZMA - "
-                "can't decode debug data in " << *io << "\n";
-            warned = true;
+        if (lzmaAvailable()) {
+            auto &gnu_debugdata = getSection(".gnu_debugdata", SHT_NULL );
+            if (gnu_debugdata) {
+               auto reader = make_shared<const LzmaReader>(gnu_debugdata.io());
+               debugData_ = make_shared<Object>(context, reader, true);
+            }
+        } else {
+            static bool warned = false;
+            if (!warned && context.debug != nullptr) {
+                *context.debug << "warning: lzma not available at runtime - "
+                    "can't decode debug data in " << *io << "\n";
+                warned = true;
+            }
         }
-#endif
     }
     return debugData_;
 }
@@ -696,50 +692,46 @@ Reader::csptr Section::io() const {
 
     // deal with two possible zlib-compressed sections. The sane,
     // "SHF_COMPRESSED" version, and the hacky ".zdebug_" versions.
-#ifndef WITH_ZLIB
     bool wantedZlib = false;
-#endif
 
     auto rawIo = elf->io->view(name, shdr.sh_offset, shdr.sh_size);
     if ((shdr.sh_flags & SHF_COMPRESSED) != 0) {
-#ifdef WITH_ZLIB
-        auto chdr = rawIo->readObj<Chdr>(0);
-        io_ = make_shared<InflateReader>(
-              chdr.ch_size,
-              *rawIo->view("ZLIB compressed content after chdr", sizeof chdr, shdr.sh_size - sizeof chdr));
-#else
-        wantedZlib = true;
-#endif
+        if (zlibAvailable()) {
+            auto chdr = rawIo->readObj<Chdr>(0);
+            io_ = make_shared<InflateReader>(
+                  chdr.ch_size,
+                  *rawIo->view("ZLIB compressed content after chdr", sizeof chdr, shdr.sh_size - sizeof chdr));
+        } else {
+            wantedZlib = true;
+        }
     } else if (name.rfind(".zdebug_", 0) == 0) {
         unsigned char sig[12];
         rawIo->readObj(0, sig, sizeof sig);
         if (std::memcmp((const char *)sig, "ZLIB", 4) == 0) {
-#ifdef WITH_ZLIB
-            uint64_t sz = 0;
-            for (size_t i = 4; i < 12; ++i) {
-                sz <<= 8;
-                sz |= sig[i];
+            if (zlibAvailable()) {
+                uint64_t sz = 0;
+                for (size_t i = 4; i < 12; ++i) {
+                    sz <<= 8;
+                    sz |= sig[i];
+                }
+                io_ = make_shared<InflateReader>(
+                      sz,
+                      *rawIo->view("ZLIB compressed content after magic signature", sizeof sig, sz));
+            } else {
+                wantedZlib = true;
             }
-            io_ = make_shared<InflateReader>(
-                  sz,
-                  *rawIo->view("ZLIB compressed content after magic signature", sizeof sig, sz));
-#else
-            wantedZlib = true;
-#endif
         }
     } else {
         io_ = rawIo;
     }
-#ifndef WITH_ZLIB
     if (wantedZlib) {
         static bool warned = false;
         if (!warned && elf->context.debug) {
             warned = true;
-            *(elf->context.debug) <<"warning: no support configured for compressed debug info in section "
+            *(elf->context.debug) << "warning: zlib not available at runtime, cannot decompress section "
                 << name << " of " << *elf->io << std::endl;
         }
     }
-#endif
     if (io_ == nullptr)
         io_ = make_shared<NullReader>();
     return io_;

inflate.cc

@@ -1,46 +1,81 @@
 #include "libpstack/inflatereader.h"
 #include "libpstack/stringify.h"
 
+#include <dlfcn.h>
 #include <zlib.h>
+
+namespace {
+
+struct Zlib {
+    int  (*inflateInit2_)(z_streamp, int, const char *, int);
+    int  (*inflate)(z_streamp, int);
+    int  (*inflateEnd)(z_streamp);
+};
+
+const Zlib *loadZlib() {
+    static Zlib zlib;
+    static const Zlib *result = [] () -> const Zlib * {
+        void *handle = dlopen("libz.so.1", RTLD_LAZY | RTLD_GLOBAL);
+        if (!handle)
+            return nullptr;
+        zlib.inflateInit2_ = reinterpret_cast<decltype(zlib.inflateInit2_)>(dlsym(handle, "inflateInit2_"));
+        zlib.inflate       = reinterpret_cast<decltype(zlib.inflate)>      (dlsym(handle, "inflate"));
+        zlib.inflateEnd    = reinterpret_cast<decltype(zlib.inflateEnd)>   (dlsym(handle, "inflateEnd"));
+        if (!zlib.inflateInit2_ || !zlib.inflate || !zlib.inflateEnd) {
+            dlclose(handle);
+            return nullptr;
+        }
+        return &zlib;
+    }();
+    return result;
+}
+
+} // namespace
+
 namespace pstack {
 
+bool zlibAvailable() {
+    return loadZlib() != nullptr;
+}
+
 InflateReader::InflateReader(size_t inflatedSize, const Reader &upstream)
     : AbstractMemReader(std::string("inflated content from ") + stringify(upstream))
     , data_(inflatedSize)
 {
-    char xferbuf[32768];
+    auto *zlib = loadZlib();
+    if (!zlib)
+        throw (Exception() << "zlib not available at runtime");
 
+    char xferbuf[32768];
     z_stream stream{};
 
     int window = 15;
-    if (inflateInit2(&stream, window) != Z_OK)
+    if (zlib->inflateInit2_(&stream, window, ZLIB_VERSION, (int)sizeof stream) != Z_OK)
         throw (Exception() << "inflateInit2 failed");
 
     stream.avail_out = inflatedSize;
-    using bytep = Bytef *;
-    stream.next_out = bytep(data());
+    stream.next_out  = reinterpret_cast<Bytef *>(data_.data());
     bool eof = false;
     size_t inputOffset = 0;
     for (bool done = false; !done; ) {
         if (stream.avail_in == 0 && !eof) {
-            // keep the input buffer full
             stream.avail_in = upstream.read(inputOffset, sizeof xferbuf, xferbuf);
             inputOffset += stream.avail_in;
-            stream.next_in = bytep(xferbuf);
+            stream.next_in = reinterpret_cast<Bytef *>(xferbuf);
             if (stream.avail_in == 0)
                 eof = true;
         }
-        switch (inflate(&stream, eof ? Z_FINISH : Z_SYNC_FLUSH)) {
+        switch (zlib->inflate(&stream, eof ? Z_FINISH : Z_SYNC_FLUSH)) {
             case Z_STREAM_END:
                 done = true;
-                // fallthrough
+                [[fallthrough]];
             case Z_OK:
                 break;
             default:
                 throw (Exception() << "inflate failed");
         }
     }
-    inflateEnd(&stream);
+    zlib->inflateEnd(&stream);
 }
 
-}
+} // namespace pstack

libpstack/inflatereader.h

@@ -3,6 +3,9 @@
 #include "libpstack/reader.h"
 
 namespace pstack {
+
+bool zlibAvailable();
+
 // A Reader that zlib inflates the underlying downstream reader.
 // Currently requires knowing the resulting output size.
 class InflateReader : public AbstractMemReader {

libpstack/lzmareader.h

@@ -7,6 +7,9 @@
 #include "libpstack/reader.h"
 
 namespace pstack {
+
+bool lzmaAvailable();
+
 /*
  * Provides an LZMA-decoded view of downstream. LZMA API allows random-access
  * to the data, and we cache each decompressed block as we decode it.

libpstack/proc.h

@@ -12,9 +12,7 @@
 #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/threaddb.h"
 
 #include "libpstack/dwarf.h"
 #include "libpstack/arch.h"
@@ -334,7 +332,7 @@ threadListCb(const td_thrhandle_t *thr, void *v)
 template <typename T> void
 Process::listThreads(const T &callback)
 {
-    td_ta_thr_iter(agent,
+    loadThreadDb()->ta_thr_iter(agent,
             threadListCb<T>,
             (void *)&callback, TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY, TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
 }