fix(runtime): DT_RPATH 被整条链继承 —— 闭包检查拒掉了一个加载器能起来的产物

Author: speak-agent

CHANGELOG.md

@@ -47,6 +47,20 @@
 工具);单测 `test_xlings_address_set.cpp` 与 `xpkg_payload_at` 的范围/不可解析版本两组。
 规范:SPEC-001 §10、SPEC-004 §4.5。
 
+### 运行期闭包检查漏掉了 `DT_RPATH` 的继承,于是拒绝了一个能跑起来的产物
+
+`DT_RPATH` 被整条依赖链继承,`DT_RUNPATH` 不被继承。而闭包模型只查**发起请求的那个
+对象自己**的搜索路径列表 —— 于是一个厂商工具包的形状(库与库之间按裸 SONAME 互相
+依赖、都不带搜索路径,而它们所在的目录只写在**可执行文件**的 `DT_RPATH` 里)整批读成
+「找不到」。
+
+`examples/09-heterogeneous/cann` 上实测:mcpp 拒绝构建并点名**八个**库,而它刚刚链接
+出来的那个产物解析掉了其中七个,只在第八个上失败 —— 而那一个属于这台机器没有的驱动。
+**模型与加载器给的是相反的读数,而模型赢了报告、加载器赢了现实。**
+
+抑制的那一半同样是规则的一部分:带 `DT_RUNPATH` 的对象不使用任何 RPATH,自己的和
+继承的都不用。两条腿各有单测,而正向那条在修复被拿掉时当场变红。
+
 ### 四处新拒绝有了名字
 
 本轮之前新增的三处拒绝(设备源没到达 action、glob 命名了本包未声明的后端、`build.mcpp`

examples/09-heterogeneous/cann/app/README.md

@@ -27,9 +27,18 @@ Measured on an x86_64 machine with **no Ascend hardware and no Ascend driver**:
 | the kernel compiles | `bisheng -x asc --cce-aicore-arch=dav-c220` |
 | the object joins the ordinary link | mixed mode: an x86-64 object carrying the device binary |
 | the host half links | ACL, plus the six-library closure the rule names |
+| the runtime-closure check | names `libascend_hal.so` and nothing else (2026.9.6.6+) |
 | the artifact starts | **no** -- `libascend_hal.so` is missing |
 | `--no-accel` | builds and runs: `12 24 36 48`, `device: cpu` |
 
+The closure row is a measurement that once disagreed with the loader. Before
+2026.9.6.6 mcpp named **eight** libraries, and the artifact it had just linked
+resolved seven of them: the toolkit's shared libraries depend on each other by
+bare SONAME and carry no search path, while the directory holding them is named
+once, in the executable's `DT_RPATH`. The model searched only the requesting
+object's own list, and `DT_RPATH` is inherited down the whole chain. The engine
+now models that, so the refusal names exactly what the loader will fail on.
+
 `libascend_hal.so` belongs to the **driver**, not the toolkit, and is the role
 `libcuda.so.1` plays for CUDA: in ABI lockstep with the kernel module, not
 redistributable, and absent on a machine with no NPU. A device build of this

src/runtime/elf.cppm

@@ -395,7 +395,8 @@ std::optional<std::filesystem::path> resolve_needed(
     std::string_view soname,
     const ElfRuntimeFacts& requester,
     const mcpp::platform::runtime::RuntimeBinding& binding,
-    std::span<const std::filesystem::path> additionalSearchDirs) {
+    std::span<const std::filesystem::path> additionalSearchDirs,
+    std::span<const std::string> inheritedRpaths) {
     std::filesystem::path named(soname);
     std::error_code ec;
     if (named.has_parent_path()) {
@@ -409,6 +410,26 @@ std::optional<std::filesystem::path> resolve_needed(
     std::vector<std::filesystem::path> dirs;
     for (auto const& raw : requester.runpaths)
         append_unique_path(dirs, expand_origin(raw, requester.artifact));
+    // DT_RPATH IS INHERITED DOWN THE DEPENDENCY CHAIN; DT_RUNPATH IS NOT.
+    //
+    // The loader searches the DT_RPATH of every object on the chain that
+    // loaded this one, not just this object's own. Modelling only the
+    // requester's list reported a library as unfindable whenever a payload's
+    // shared libraries depend on each other and the RPATH naming their
+    // directory sits on the EXECUTABLE -- which is the ordinary shape for a
+    // vendor toolkit. Measured on examples/09-heterogeneous/cann: mcpp refused
+    // the build naming eight libraries, and the artifact it had just linked
+    // resolved seven of them and failed on the eighth, which belongs to a
+    // driver that machine does not have.
+    //
+    // The suppression is a property of the SEARCHING object: an object that
+    // carries DT_RUNPATH uses no RPATH at all, its own or inherited. `Both` is
+    // that case too, because glibc ignores DT_RPATH whenever DT_RUNPATH is
+    // present.
+    if (requester.searchPathTag != SearchPathTag::Runpath
+        && requester.searchPathTag != SearchPathTag::Both)
+        for (auto const& raw : inheritedRpaths)
+            append_unique_path(dirs, expand_origin(raw, requester.artifact));
     for (auto const& dir : additionalSearchDirs) append_unique_path(dirs, dir);
     for (auto const& dir : binding.libraryDirs) append_unique_path(dirs, dir);
     // NOTE: the SubOS farm is NOT read from the binding here.
@@ -910,8 +931,16 @@ RuntimeResolution resolve_runtime_closure(
     resolution.artifact = std::move(*root);
     resolution.artifactIsElf = true;
 
-    std::deque<ElfRuntimeFacts> queue;
-    queue.push_back(resolution.artifact);
+    // Each queued object carries the DT_RPATHs it inherited from the chain
+    // that loaded it. Kept beside the facts rather than inside them: it is a
+    // property of HOW this object was reached, and the same file reached twice
+    // is one loaded object with the first arrival's chain.
+    struct Pending {
+        ElfRuntimeFacts          facts;
+        std::vector<std::string> inheritedRpaths;
+    };
+    std::deque<Pending> queue;
+    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.
@@ -924,16 +953,27 @@ RuntimeResolution resolve_runtime_closure(
     }
     constexpr std::size_t kMaxClosureObjects = 512;
     while (!queue.empty() && resolution.objects.size() < kMaxClosureObjects) {
-        auto requester = std::move(queue.front());
+        auto pending = std::move(queue.front());
         queue.pop_front();
+        const auto& requester = pending.facts;
+        // What this object hands to the objects it loads: its own DT_RPATH
+        // when that is the tag it carries, on top of whatever it inherited.
+        // DT_RUNPATH never propagates, and a `Both` object's DT_RPATH is dead
+        // to the loader, so neither contributes.
+        std::vector<std::string> childRpaths = pending.inheritedRpaths;
+        if (requester.searchPathTag == SearchPathTag::Rpath)
+            for (auto const& raw : requester.runpaths)
+                if (std::ranges::find(childRpaths, raw) == childRpaths.end())
+                    childRpaths.push_back(raw);
         for (auto const& soname : requester.needed) {
             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);
+                    soname, requester, binding, additionalSearchDirs,
+                    pending.inheritedRpaths);
                 if (!path) {
                     resolution.unresolved.push_back(soname);
                     resolution.unresolvedSonames.push_back(soname);
@@ -968,7 +1008,7 @@ RuntimeResolution resolve_runtime_closure(
                 }
                 loadedBySoname.emplace(parsed->soname, *path);
             }
-            queue.push_back(*parsed);
+            queue.push_back({*parsed, childRpaths});
             resolution.objects.push_back(std::move(*parsed));
         }
     }

tests/unit/test_elf_runtime.cpp

@@ -55,6 +55,13 @@ 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";
+    // Emit the search path as DT_RPATH and nothing else. The default image
+    // carries both tags, which is the common shape and the one glibc reads as
+    // DT_RUNPATH -- so a test about DT_RPATH's reach cannot use it.
+    bool rpathOnly = false;
+    // No search path at all: the object that has to reach its dependencies
+    // through someone else's DT_RPATH.
+    bool noSearchPath = false;
 };
 
 // One deliberately tiny ELF64-LE image. It has no executable code; the test
@@ -108,7 +115,8 @@ std::filesystem::path write_elf_fixture(
     auto versionOwner = needed.empty()
         ? append_string(b, kDynstr, cursor, "libc.so.6")
         : needed.front();
-    auto rpath = append_string(b, kDynstr, cursor, "/legacy/ignored");
+    auto rpath = append_string(b, kDynstr, cursor,
+                               spec.rpathOnly ? spec.runpath : "/legacy/ignored");
     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");
@@ -123,8 +131,10 @@ std::filesystem::path write_elf_fixture(
     dyn(5, kVaddr + kDynstr);            // DT_STRTAB
     dyn(10, dynstrSize);                 // DT_STRSZ
     for (auto offset : needed) dyn(1, offset); // DT_NEEDED
-    dyn(15, rpath);                      // DT_RPATH (ignored when RUNPATH exists)
-    dyn(29, runpath);                    // DT_RUNPATH
+    if (!spec.noSearchPath) {
+        dyn(15, rpath);                  // DT_RPATH (ignored when RUNPATH exists)
+        if (!spec.rpathOnly) dyn(29, runpath);   // DT_RUNPATH
+    }
     dyn(0x6ffffffe, kVaddr + kVerneed);  // DT_VERNEED
     dyn(0x6fffffff, 1);                  // DT_VERNEEDNUM
     dyn(0x6ffffffc, kVaddr + kVerdef);   // DT_VERDEF
@@ -283,6 +293,80 @@ TEST(ElfRuntime, ReusesAnAlreadyLoadedSonameAcrossDependencyRunpaths) {
               std::filesystem::weakly_canonical(glibc44 / "libc.so.6"));
 }
 
+// DT_RPATH REACHES THE WHOLE CHAIN; DT_RUNPATH REACHES ONE OBJECT.
+//
+// A vendor toolkit's shared libraries depend on each other by bare SONAME and
+// carry no search path of their own; the directory holding them is named once,
+// in the EXECUTABLE's DT_RPATH. The model searched only the requesting
+// object's own list, so every such library read as unfindable.
+//
+// Measured on examples/09-heterogeneous/cann before this: mcpp refused the
+// build naming eight libraries, and the artifact it had just linked resolved
+// seven of them -- failing only on the one that belongs to a driver the
+// machine does not have.
+TEST(ElfRuntime, ADependencyInheritsTheExecutablesRpath) {
+    if constexpr (!mcpp::platform::is_linux)
+        GTEST_SKIP() << "ELF/glibc runtime physics only apply on Linux";
+    Tmp t;
+    auto payload = t.path / "store";
+    auto glibc = payload / "2.44" / "lib64";
+    auto toolkit = t.path / "toolkit" / "lib64";
+    std::filesystem::create_directories(glibc);
+    std::filesystem::create_directories(toolkit);
+
+    write_elf_fixture(glibc / "libc.so.6", { .needed = {}, .runpath = glibc.string() });
+    // The leaf, reachable only through the executable's DT_RPATH.
+    write_elf_fixture(toolkit / "libdeep.so", { .needed = {}, .noSearchPath = true });
+    // The middle object: names its dependency and says nothing about where it
+    // lives, which is what a vendor library does.
+    write_elf_fixture(toolkit / "libtop.so",
+                      { .needed = {"libdeep.so"}, .noSearchPath = true });
+    auto app = write_elf_fixture(t.path / "app", {
+        .needed = {"libtop.so", "libc.so.6"},
+        .runpath = toolkit.string() + ":" + glibc.string(),
+        .rpathOnly = true,
+    });
+
+    auto resolution = elf::resolve_runtime_closure(app, binding_for(payload));
+    EXPECT_TRUE(resolution.unresolvedSonames.empty())
+        << "unresolved: " << (resolution.unresolvedSonames.empty()
+                              ? std::string{} : resolution.unresolvedSonames.front());
+}
+
+// …and the suppression, which is the half that makes the rule a rule. An
+// object carrying DT_RUNPATH uses no RPATH at all -- its own or inherited --
+// so a test with only the leg above would also pass on an implementation that
+// inherited unconditionally.
+TEST(ElfRuntime, ADependencyWithItsOwnRunpathDoesNotInheritOne) {
+    if constexpr (!mcpp::platform::is_linux)
+        GTEST_SKIP() << "ELF/glibc runtime physics only apply on Linux";
+    Tmp t;
+    auto payload = t.path / "store";
+    auto glibc = payload / "2.44" / "lib64";
+    auto toolkit = t.path / "toolkit" / "lib64";
+    auto elsewhere = t.path / "elsewhere";
+    std::filesystem::create_directories(glibc);
+    std::filesystem::create_directories(toolkit);
+    std::filesystem::create_directories(elsewhere);
+
+    write_elf_fixture(glibc / "libc.so.6", { .needed = {}, .runpath = glibc.string() });
+    write_elf_fixture(toolkit / "libdeep.so", { .needed = {}, .noSearchPath = true });
+    // Same graph as above, except this middle object carries DT_RUNPATH. It
+    // names a directory that does not hold `libdeep.so`, and glibc will not
+    // fall back to the executable's DT_RPATH for it.
+    write_elf_fixture(toolkit / "libtop.so",
+                      { .needed = {"libdeep.so"}, .runpath = elsewhere.string() });
+    auto app = write_elf_fixture(t.path / "app", {
+        .needed = {"libtop.so", "libc.so.6"},
+        .runpath = toolkit.string() + ":" + glibc.string(),
+        .rpathOnly = true,
+    });
+
+    auto resolution = elf::resolve_runtime_closure(app, binding_for(payload));
+    ASSERT_EQ(resolution.unresolvedSonames.size(), 1u);
+    EXPECT_EQ(resolution.unresolvedSonames.front(), "libdeep.so");
+}
+
 TEST(RuntimePhysics, RuleBRejectsInterpreterAndLibcFromDifferentPayloads) {
     if constexpr (!mcpp::platform::is_linux)
         GTEST_SKIP() << "ELF/glibc runtime physics only apply on Linux";