fix(runtime): model ELF SONAME reuse

Author: speak-agent

src/platform/elf_runtime.cppm

@@ -17,6 +17,7 @@ struct ElfRuntimeFacts {
     std::filesystem::path artifact;
     std::uint16_t elfType = 0;
     std::string interp;
+    std::string soname;
     std::vector<std::string> runpaths;
     std::vector<std::string> needed;
     std::vector<std::string> requiredGlibcVersions;
@@ -74,6 +75,7 @@ constexpr std::uint64_t kDtNeeded = 1;
 constexpr std::uint64_t kDtStrtab = 5;
 constexpr std::uint64_t kDtStrsz = 10;
 constexpr std::uint64_t kDtRpath = 15;
+constexpr std::uint64_t kDtSoname = 14;
 constexpr std::uint64_t kDtRunpath = 29;
 constexpr std::uint64_t kDtVerdef = 0x6ffffffc;
 constexpr std::uint64_t kDtVerdefnum = 0x6ffffffd;
@@ -382,6 +384,11 @@ inspect_elf_runtime(const std::filesystem::path& artifact) {
             if (!name || name->empty()) return std::unexpected(std::format(
                 "artifact '{}' has an invalid DT_NEEDED", artifact.string()));
             out.needed.push_back(std::move(*name));
+        } else if (tag == detail::kDtSoname) {
+            auto name = dynstr(value);
+            if (!name || name->empty()) return std::unexpected(std::format(
+                "artifact '{}' has an invalid DT_SONAME", artifact.string()));
+            out.soname = std::move(*name);
         } else if (tag == detail::kDtRpath || tag == detail::kDtRunpath) {
             auto path = dynstr(value);
             if (!path) return std::unexpected(std::format(
@@ -469,7 +476,9 @@ inspect_elf_runtime(const std::filesystem::path& artifact) {
     // Search order is loader physics, not presentation: sorting RUNPATH would
     // be capable of selecting a different libc than the process itself.
     detail::stable_unique(out.runpaths);
-    detail::sort_unique(out.needed);
+    // DT_NEEDED order is loader semantics. Reordering it can change which
+    // payload wins when two dependency search paths contain the same SONAME.
+    detail::stable_unique(out.needed);
     detail::sort_unique(out.requiredGlibcVersions);
     detail::sort_unique(out.definedGlibcVersions);
     return out;
@@ -492,16 +501,31 @@ RuntimeResolution resolve_runtime_closure(
     queue.push_back(resolution.artifact);
     std::set<std::filesystem::path> visited;
     visited.insert(detail::comparable_path(artifact));
+    // The ELF loader maintains one process-global loaded-object namespace.
+    // Once a SONAME has been mapped, a later requester reuses that object;
+    // its own RUNPATH does not load a second file with the same SONAME.
+    std::map<std::string, std::filesystem::path> loadedBySoname;
+    if (!resolution.artifact.interp.empty()) {
+        auto interp = detail::comparable_path(resolution.artifact.interp);
+        loadedBySoname.emplace(interp.filename().string(), std::move(interp));
+    }
     constexpr std::size_t kMaxClosureObjects = 512;
     while (!queue.empty() && resolution.objects.size() < kMaxClosureObjects) {
         auto requester = std::move(queue.front());
         queue.pop_front();
         for (auto const& soname : requester.needed) {
-            auto path = detail::resolve_needed(
-                soname, requester, binding, additionalSearchDirs);
-            if (!path) {
-                resolution.unresolved.push_back(soname);
-                continue;
+            std::optional<std::filesystem::path> path;
+            if (auto loaded = loadedBySoname.find(soname);
+                loaded != loadedBySoname.end()) {
+                path = loaded->second;
+            } else {
+                path = detail::resolve_needed(
+                    soname, requester, binding, additionalSearchDirs);
+                if (!path) {
+                    resolution.unresolved.push_back(soname);
+                    continue;
+                }
+                loadedBySoname.emplace(soname, *path);
             }
             if (soname == "libc.so.6") {
                 if (resolution.artifact.resolvedLibc.empty())
@@ -518,6 +542,18 @@ RuntimeResolution resolve_runtime_closure(
                     "{} ({})", soname, parsed.error()));
                 continue;
             }
+            if (!parsed->soname.empty()) {
+                if (auto loaded = loadedBySoname.find(parsed->soname);
+                    loaded != loadedBySoname.end()
+                    && !detail::same_path(loaded->second, *path)) {
+                    // The file reached through this request aliases a SONAME
+                    // that is already mapped. Model the loader's reuse and do
+                    // not add a second closure object.
+                    loadedBySoname[soname] = loaded->second;
+                    continue;
+                }
+                loadedBySoname.emplace(parsed->soname, *path);
+            }
             queue.push_back(*parsed);
             resolution.objects.push_back(std::move(*parsed));
         }

tests/unit/test_elf_runtime.cpp

@@ -50,10 +50,18 @@ std::uint32_t append_string(std::vector<unsigned char>& b,
     return offset;
 }
 
+struct ElfFixtureSpec {
+    std::string interp = "/store/glibc/2.44/lib64/ld-linux-x86-64.so.2";
+    std::vector<std::string> needed = {"libc.so.6"};
+    std::string runpath = "/host/z:/host/a";
+};
+
 // One deliberately tiny ELF64-LE image. It has no executable code; the test
 // exercises the same program/dynamic/version tables real stripped binaries
 // retain, without depending on readelf, the host compiler or the host libc.
-std::filesystem::path write_elf_fixture(const std::filesystem::path& path) {
+std::filesystem::path write_elf_fixture(
+    const std::filesystem::path& path,
+    const ElfFixtureSpec& spec = {}) {
     constexpr std::uint64_t kVaddr = 0x400000;
     constexpr std::size_t kInterp = 0x200;
     constexpr std::size_t kDynamic = 0x300;
@@ -84,18 +92,23 @@ std::filesystem::path write_elf_fixture(const std::filesystem::path& path) {
         put64(b, p + 0x28, filesz);
     };
 
-    constexpr std::string_view interp = "/store/glibc/2.44/lib64/ld-linux-x86-64.so.2";
+    const std::string_view interp = spec.interp;
     std::copy(interp.begin(), interp.end(), b.begin() + kInterp);
     b[kInterp + interp.size()] = 0;
     ph(0, 1, 0, b.size());                       // PT_LOAD
     ph(1, 3, kInterp, interp.size() + 1);        // PT_INTERP
-    ph(2, 2, kDynamic, 11 * 16);                 // PT_DYNAMIC
+    ph(2, 2, kDynamic, 24 * 16);                 // PT_DYNAMIC
 
     std::size_t cursor = kDynstr;
     b[cursor++] = 0;
-    auto libc = append_string(b, kDynstr, cursor, "libc.so.6");
+    std::vector<std::uint32_t> needed;
+    for (auto const& name : spec.needed)
+        needed.push_back(append_string(b, kDynstr, cursor, name));
+    auto versionOwner = needed.empty()
+        ? append_string(b, kDynstr, cursor, "libc.so.6")
+        : needed.front();
     auto rpath = append_string(b, kDynstr, cursor, "/legacy/ignored");
-    auto runpath = append_string(b, kDynstr, cursor, "/host/z:/host/a");
+    auto runpath = append_string(b, kDynstr, cursor, spec.runpath);
     auto needVersion = append_string(b, kDynstr, cursor, "GLIBC_2.40");
     auto defVersion = append_string(b, kDynstr, cursor, "GLIBC_2.44");
     auto dynstrSize = cursor - kDynstr;
@@ -108,7 +121,7 @@ std::filesystem::path write_elf_fixture(const std::filesystem::path& path) {
     };
     dyn(5, kVaddr + kDynstr);            // DT_STRTAB
     dyn(10, dynstrSize);                 // DT_STRSZ
-    dyn(1, libc);                        // DT_NEEDED
+    for (auto offset : needed) dyn(1, offset); // DT_NEEDED
     dyn(15, rpath);                      // DT_RPATH (ignored when RUNPATH exists)
     dyn(29, runpath);                    // DT_RUNPATH
     dyn(0x6ffffffe, kVaddr + kVerneed);  // DT_VERNEED
@@ -120,7 +133,7 @@ std::filesystem::path write_elf_fixture(const std::filesystem::path& path) {
     // Elf64_Verneed + one Elf64_Vernaux.
     put16(b, kVerneed, 1);
     put16(b, kVerneed + 2, 1);
-    put32(b, kVerneed + 4, libc);
+    put32(b, kVerneed + 4, versionOwner);
     put32(b, kVerneed + 8, 16);
     put32(b, kVerneed + 12, 0);
     put32(b, kVerneed + 16, 0);
@@ -228,6 +241,43 @@ TEST(ElfRuntime, RejectsUnsupportedOrTruncatedElfWithoutGuessing) {
     EXPECT_FALSE(truncated.has_value());
 }
 
+TEST(ElfRuntime, ReusesAnAlreadyLoadedSonameAcrossDependencyRunpaths) {
+    if constexpr (!mcpp::platform::is_linux)
+        GTEST_SKIP() << "ELF/glibc runtime physics only apply on Linux";
+    Tmp t;
+    auto payload = t.path / "store";
+    auto glibc39 = payload / "2.39" / "lib64";
+    auto glibc44 = payload / "2.44" / "lib64";
+    auto shimDir = t.path / "shim";
+    std::filesystem::create_directories(glibc39);
+    std::filesystem::create_directories(glibc44);
+    std::filesystem::create_directories(shimDir);
+
+    write_elf_fixture(glibc39 / "libc.so.6", {
+        .needed = {"libc.so.6"},
+        .runpath = glibc39.string(),
+    });
+    write_elf_fixture(glibc44 / "libc.so.6", {
+        .needed = {"libc.so.6"},
+        .runpath = glibc44.string(),
+    });
+    write_elf_fixture(shimDir / "libshim.so", {
+        .needed = {"libc.so.6"},
+        .runpath = glibc39.string(),
+    });
+    auto app = write_elf_fixture(t.path / "app", {
+        .needed = {"libc.so.6", "libshim.so"},
+        .runpath = shimDir.string(),
+    });
+
+    auto resolution = elf::resolve_runtime_closure(app, binding_for(payload));
+    ASSERT_TRUE(resolution.unresolved.empty());
+    ASSERT_EQ(resolution.resolvedLibcs.size(), 1u)
+        << "a later dependency must reuse the process-global libc SONAME";
+    EXPECT_EQ(resolution.resolvedLibcs.front(),
+              std::filesystem::weakly_canonical(glibc44 / "libc.so.6"));
+}
+
 TEST(RuntimePhysics, RuleBRejectsInterpreterAndLibcFromDifferentPayloads) {
     if constexpr (!mcpp::platform::is_linux)
         GTEST_SKIP() << "ELF/glibc runtime physics only apply on Linux";