Add an "openImage", and rename "getImage" to "findImage"

This makes it clear that "findImage" is not just opening a path, but
gives the facility to do that anyway.

Author: peadar

canal.cc

@@ -303,7 +303,7 @@ mainExcept(int argc, char *argv[])
     .parse(argc, argv);
 
     if (argc - optind >= 2) {
-        exec = context.getImage(argv[optind]);
+        exec = context.openImage(argv[optind]);
         optind++;
     }
 

context.cc

@@ -30,9 +30,9 @@ Context::Context()
 }
 
 std::shared_ptr<Dwarf::Info>
-Context::getDwarf(const std::filesystem::path &filename)
+Context::findDwarf(const std::filesystem::path &filename)
 {
-    return getDwarf(getImage(filename));
+    return findDwarf(findImage(filename));
 }
 
 debuginfod_client *
@@ -66,13 +66,13 @@ Context::debuginfod()
 
 
 std::shared_ptr<Dwarf::Info>
-Context::getDwarf(const Elf::BuildID &bid)
+Context::findDwarf(const Elf::BuildID &bid)
 {
-    return getDwarf(getImage(bid));
+    return findDwarf(findImage(bid));
 }
 
 Dwarf::Info::sptr
-Context::getDwarf(Elf::Object::sptr object)
+Context::findDwarf(Elf::Object::sptr object)
 {
     auto it = dwarfCache.find(object);
     counters.dwarfLookups++;
@@ -154,6 +154,11 @@ Context::getImageIfLoaded(const Container &ctr, const typename Container::key_ty
     return {};
 }
 
+std::shared_ptr<Elf::Object>
+Context::openImage(const std::filesystem::path &path, int fd, bool isDebug) {
+    return std::make_shared<Elf::Object>(*this, std::make_shared<MmapReader>(*this, path, fd) , isDebug);
+}
+
 /*
  * Find an image from a name, caching in container, and using "paths" as potential prefixes for name
  */
@@ -178,7 +183,7 @@ Context::getImageInPath(const std::vector<std::filesystem::path> &paths, NameMap
             }
         }
         try {
-            res = std::make_shared<Elf::Object>(*this, std::make_shared<MmapReader>(*this, path) , isDebug);
+            res = openImage( path, -1, isDebug );
             break;
         }
         catch (const std::exception &ex) {
@@ -199,7 +204,7 @@ Context::getImageInPath(const std::vector<std::filesystem::path> &paths, NameMap
  * get an image from a filename
  */
 std::shared_ptr<Elf::Object>
-Context::getImage(const std::filesystem::path &name) {
+Context::findImage(const std::filesystem::path &name) {
     if (options.noLocalFiles)
         return nullptr;
     return getImageInPath(exePrefixes, imageByName, name, false, false);
@@ -208,7 +213,7 @@ Context::getImage(const std::filesystem::path &name) {
 /*
  * get an image, given its build ID. It may be a debug image, or an
  * "executable". We first defer to the filesystem, using the string versions of
- * "getImage", and a broken-down form of the build id, with the first octet of
+ * "findImage", and a broken-down form of the build id, with the first octet of
  * the build-id being a directlry name, and the remainder being the filename,
  * with a possible suffix. This allows us to find things of the form
  * /usr/lib/debug/build-id/NN/NNNNNNNNNNNNNNNNNNNN.debug for example.  The
@@ -218,42 +223,42 @@ Context::getImage(const std::filesystem::path &name) {
 
 std::shared_ptr<Elf::Object> Context::getImageImpl( const Elf::BuildID &bid, bool isDebug) {
 
-    IdMap &container = isDebug ? debugImageByID : imageByID;
-    NameMap &nameContainer = isDebug ? debugImageByName : imageByName;
-    std::vector<std::filesystem::path> &paths = isDebug ? debugBuildIdPrefixes : exeBuildIdPrefixes;
-
+    Elf::Object::sptr res;
     if (!bid || options.noBuildIds)
         return nullptr;
+    IdMap &container = isDebug ? debugImageByID : imageByID;
+
     std::optional<Elf::Object::sptr> cached = getImageIfLoaded( container, bid, isDebug );
     if (cached)
         return *cached;
 
-    std::stringstream bucket;
-    bucket << AsHex( bid[ 0 ] );
-    std::stringstream rest;
-    rest << AsHex(std::views::all(bid) | std::views::drop(1));
-    if ( isDebug )
-        rest << ".debug";
+    if (!options.noLocalFiles) {
+        NameMap &nameContainer = isDebug ? debugImageByName : imageByName;
+        std::vector<std::filesystem::path> &paths = isDebug ? debugBuildIdPrefixes : exeBuildIdPrefixes;
 
-    std::filesystem::path bidpath = std::filesystem::path( bucket.str() ) / std::filesystem::path( rest.str() );
+        std::stringstream bucket;
+        bucket << AsHex( bid[ 0 ] );
+        std::stringstream rest;
+        rest << AsHex(std::views::all(bid) | std::views::drop(1));
+        if ( isDebug )
+            rest << ".debug";
 
-    Elf::Object::sptr res = getImageInPath(paths, nameContainer, bidpath, isDebug, true);
+        std::filesystem::path bidpath = std::filesystem::path( bucket.str() ) / std::filesystem::path( rest.str() );
+        res = getImageInPath(paths, nameContainer, bidpath, isDebug, true);
+    }
 #ifdef DEBUGINFOD
     if (!res && debuginfod()) {
-        char *path;
+        char *path = nullptr;
         int progress = 0;
         debuginfod_set_user_data(debuginfod(), &progress);
         int fd = (isDebug ? debuginfod_find_debuginfo : debuginfod_find_executable)
             (debuginfod(), bid.data(), int( bid.size() ), &path);
         if (progress > 0) {
+            // If we reported progress at least once, move to the next line
             std::cerr << "\n";
         }
         if (fd >= 0) {
-            // Wrap the fd in a reader, and then a cache reader...
-            std::shared_ptr<Reader> reader = std::make_shared<FileReader>(*this, path, fd );
-            reader = std::make_shared<CacheReader>(reader);
-            // and then wrap the lot in an ELF object.
-            res = std::make_shared<Elf::Object>( *this, reader, true );
+            res = openImage( path, fd, true );
             free(path);
             if (verbose)
                 *debug << "fetched " << *res->io << " for " << bid << " with debuginfod\n";
@@ -267,7 +272,7 @@ std::shared_ptr<Elf::Object> Context::getImageImpl( const Elf::BuildID &bid, boo
 }
 
 std::shared_ptr<Elf::Object>
-Context::getDebugImage(const std::filesystem::path &name) {
+Context::findDebugImage(const std::filesystem::path &name) {
     return getImageInPath(debugPrefixes, debugImageByName, name, true, false);
 }
 
@@ -279,8 +284,8 @@ int debuginfod_find_executable (debuginfod_client *, const unsigned char *, int,
 }
 #endif
 
-std::shared_ptr<Elf::Object> Context::getDebugImage(const Elf::BuildID &bid) { return getImageImpl(bid, true); }
-std::shared_ptr<Elf::Object> Context::getImage(const Elf::BuildID &bid) { return getImageImpl(bid, false); }
+std::shared_ptr<Elf::Object> Context::findDebugImage(const Elf::BuildID &bid) { return getImageImpl(bid, true); }
+std::shared_ptr<Elf::Object> Context::findImage(const Elf::BuildID &bid) { return getImageImpl(bid, false); }
 
 std::shared_ptr<const Reader>
 Context::loadFile(const std::filesystem::path &path) {

dwarf_info.cc

@@ -262,7 +262,7 @@ Info::sptr
 Info::getAltDwarf() const
 {
     if (!altImageLoaded) {
-        altDwarf = elf->context.getDwarf(getAltImageName());
+        altDwarf = elf->context.findDwarf(getAltImageName());
         altImageLoaded = true;
     }
     if (altDwarf == nullptr)

elf.cc

@@ -606,7 +606,7 @@ Object::getDebug() const
 
     // Use the build ID to find debug data.
     auto bid = getBuildID();
-    debugObject = context.getDebugImage(bid);
+    debugObject = context.findDebugImage(bid);
 
     // If that doesn't work, maybe the gnu_debuglink is valid?
     if (!debugObject) {
@@ -615,7 +615,7 @@ Object::getDebug() const
         if (hdr) {
             auto link = hdr.io()->readString(0);
             auto dir = std::filesystem::path(stringify(*io)).parent_path();
-            debugObject = context.getDebugImage(dir / link);
+            debugObject = context.findDebugImage(dir / link);
         }
     }
 

hdmp.cc

@@ -32,7 +32,7 @@ void printStack(std::ostream &os, std::shared_ptr<Procman::Process> &proc, const
             os << "\t" << name << "+" << uintptr_t(frames[i]) - elfReloc - sym.st_value;
          }
 
-         auto dwarf = proc->context.getDwarf(elf);
+         auto dwarf = proc->context.findDwarf(elf);
          if (dwarf) {
             auto sep = "in";
             for (auto &&[file, line] : dwarf->sourceFromAddr(frameip - elfReloc)) {
@@ -113,7 +113,7 @@ main(int argc, char *argv[])
    for (int c; (c = getopt(argc, argv, "e:fab")) != -1; ) {
       switch (c) {
          case 'e':
-            exec = context.getImage(optarg);
+            exec = context.openImage(optarg);
             break;
          case 'f':
             options.insert(heap_recentfree);

libpstack/context.h

@@ -73,18 +73,22 @@ class Context {
    int openfile(const std::filesystem::path &filename, int mode = O_RDONLY, int umask = 0777);
    int openFileDirect(const std::filesystem::path &name_, int mode, int mask);
 
-   std::shared_ptr<Elf::Object> getImage(const std::filesystem::path &name);
-   std::shared_ptr<Elf::Object> getImage(const Elf::BuildID &);
+   // Unlike getImage, this will not search paths - name must be a local file path.
+   std::shared_ptr<Elf::Object> openImage(const std::filesystem::path &name, int fd = -1, bool isDebug = false);
+
+   // Get an image, searching as required.
+   std::shared_ptr<Elf::Object> findImage(const std::filesystem::path &name);
+   std::shared_ptr<Elf::Object> findImage(const Elf::BuildID &);
 
    // Debug images are specifically those with the text/data stripped, and just
    // the Dwarf/symbol table left.
-   std::shared_ptr<Elf::Object> getDebugImage(const std::filesystem::path &name);
-   std::shared_ptr<Elf::Object> getDebugImage(const Elf::BuildID &);
+   std::shared_ptr<Elf::Object> findDebugImage(const std::filesystem::path &name);
+   std::shared_ptr<Elf::Object> findDebugImage(const Elf::BuildID &);
 
-   std::shared_ptr<Dwarf::Info> getDwarf(const std::filesystem::path &);
-   std::shared_ptr<Dwarf::Info> getDwarf(const Elf::BuildID &);
+   std::shared_ptr<Dwarf::Info> findDwarf(const std::filesystem::path &);
+   std::shared_ptr<Dwarf::Info> findDwarf(const Elf::BuildID &);
 
-   std::shared_ptr<Dwarf::Info> getDwarf(std::shared_ptr<Elf::Object>);
+   std::shared_ptr<Dwarf::Info> findDwarf(std::shared_ptr<Elf::Object>);
    void flush(std::shared_ptr<Elf::Object> o);
    std::filesystem::path procname(pid_t pid, const std::filesystem::path &base);
 

libpstack/proc.h

@@ -228,9 +228,9 @@ struct MappedObject {
     }
     Elf::Object::sptr object(Context &ctx) {
         if (objptr_ == nullptr)
-            objptr_ = ctx.getImage(bid_);
+            objptr_ = ctx.findImage(bid_);
         if (objptr_ == nullptr)
-            objptr_ = ctx.getImage(name_);
+            objptr_ = ctx.findImage(name_);
         return objptr_;
     }
     MappedObject(std::string_view name, Elf::BuildID bid, Elf::Object::sptr objptr = {}) :

libpstack/reader.h

@@ -161,7 +161,7 @@ class MemReader : public Reader {
 
 class MmapReader final : public MemReader {
 public:
-    MmapReader(Context &, const std::string &name_);
+    MmapReader(Context &, const std::string &name_, int fd = - 1);
     ~MmapReader() override;
     MmapReader(const MmapReader &) = delete;
     MmapReader(MmapReader &&) = delete;

live.cc

@@ -24,7 +24,7 @@ LiveReader::LiveReader(Context &c, pid_t pid, const std::string &base) : FileRea
 
 Elf::Object::sptr
 LiveProcess::executableImage() {
-   return context.getImage(context.procname(getPID(), "exe"));
+   return context.findImage(context.procname(getPID(), "exe"));
 }
 
 LiveProcess::LiveProcess(Context &context, Elf::Object::sptr &ex, pid_t pid_, bool alreadyStopped)

process.cc

@@ -202,7 +202,7 @@ Process::load()
 Dwarf::Info::sptr
 Process::getDwarf(Elf::Object::sptr elf) const
 {
-    return context.getDwarf(elf);
+    return context.findDwarf(elf);
 }
 
 
@@ -350,14 +350,14 @@ Process::processAUXV(const Reader &auxio)
                 io->read(noteVa + sizeof n + 4, n.n_descsz, (char *)data.data());
                 if (context.verbose)
                     *context.debug << "build ID From AT_PHDR: " << Elf::BuildID(data) << "\n";
-                execImage = context.getImage(Elf::BuildID{data});
+                execImage = context.findImage(Elf::BuildID{data});
                 break;
             }
         }
     }
 
     if (!execImage && exeName != "")
-       execImage = context.getImage(exeName);
+       execImage = context.findImage(exeName);
     if (!execImage)
        execImage = executableImage(); // default to whatever the process can give us (eg, mmap /proc/<>/exe)
 }