Skip to content

check-installed-rpath: a LIVE entry is classified by what it resolves THROUGH (build tree fails, declared SDK warns) - #2667

Merged
bong-water-water-bong merged 2 commits into
mainfrom
lane/rpath-kind
Nov 16, 2026
Merged

bong-water-water-bong merged 2 commits into
mainfrom
lane/rpath-kind

Conversation

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator

Refs #1411 — this makes the repack-or-retire decision I recorded there (it was assigned to pi-release) executable instead of prose.

The problem with the number

94 offending entries, 42 LIVE cannot be acted on because it mixes a catastrophic case with a normal one. Measured on this box:

 6 LIVE through /work-c22/hrx-toolchain/...   a build tree: remove it and 1bit-embed-c22 will not start
36 LIVE through /opt/rocm-therock/...         the installed ROCm SDK (libomp.so)

The old FAIL line called a dependency on a system SDK exactly as bad as a path into a build tree that is about to be deleted, so the only sane response was to ignore it.

The decision, as code

class path result
BUILD TREE /work, /work-c22, /tmp, /dev/shm, ~/wt, ~/lb, ~/.cache/scratch-* FAIL
DECLARED SDK /opt/rocm* WARN
OTHER any other absolute path FAIL

DECLARED SDK does not fail because making the package $ORIGIN-only would vendor a second libomp and ship an artifact that is not the one that was tested — that is the repack half of the decision, and it is rejected. OTHER does fail: "I do not know what that is" may not pass a gate.

That OTHER rule is not decoration. The first version of this change let /work-c22 fall into OTHER and returned exit 0 with six build-tree entries still load-bearing — a false PASS on the exact hazard the tool exists for. The hazard arms in the self-test exist because of that run.

The arm caught two of my own bugs

FAIL /workshop matched the /work prefix              a prefix test that matched a different directory
FAIL /work-c22/... -> OTHER, expected BUILD TREE     the real tree is /work-c22, not /work

Both before the commit, which is what a self-test is for. Mutations, both failing by name:

regex loses the '-name' alternative   -> FAIL /work-c22/... -> OTHER, expected BUILD TREE
an unknown path stops failing         -> FAIL hazard_fails(0, 1) -> False, expected True

Gate compliance

tests_referenced requires a ctest row for any tools/**/*.py that declares --self-test, so the row is added (installed_rpath_kind_self) and --check is green — 73 tool self-tests, up from 72.

On this box the sweep still exits 1, and now says which six: FAIL 94 offending RUNPATH entries across 317 ELF(s), 42 of them LIVE: 6 through a BUILD TREE (deleting or rebuilding that directory stops the installed package starting).

Not done here: retiring 1bit-embed-c22 or freeing /work-c22 (17 G). The order is retire-the-dependants-then-free-the-tree, and ~/lb/k74-ab/proof-0008b-* still re-runs against those paths.

… THROUGH

94 offending entries, 42 LIVE is a number nobody can act on: it mixes a catastrophic case with a
normal one. Measured on this box --

  6 LIVE through /work-c22/hrx-toolchain/...   (a build tree: remove it and 1bit-embed-c22 will not start)
 36 LIVE through /opt/rocm-therock/...         (the installed ROCm SDK: libomp.so)

so the same FAIL line called a dependency on a system SDK as bad as a path into a build tree that is
about to be deleted. This is the repack-or-retire decision recorded on engine#1411, made executable:

  BUILD TREE    /work, /work-c22, /tmp, /dev/shm, ~/wt, ~/lb, ~/.cache/scratch-*   -> FAIL
  DECLARED SDK  /opt/rocm*                                                        -> WARN
  OTHER         any other absolute path                                           -> FAIL

DECLARED SDK does not fail because making the package `$ORIGIN`-only would vendor a SECOND libomp and
ship an artifact that is not the one that was tested. OTHER does fail, and that is not decoration --
the first version of this change let /work-c22 fall into OTHER and returned **0** with six
build-tree entries still load-bearing; the self-test's hazard arms exist because of that run.

The self-test caught two of my own bugs before the commit:
  FAIL /workshop matched the /work prefix            (a prefix test that matched a different directory)
  FAIL /work-c22/... -> OTHER, expected BUILD TREE   (the real tree is /work-c22, not /work)

Mutations, both failing by name:
  regex loses the '-name' alternative   -> FAIL /work-c22/... -> OTHER, expected BUILD TREE
  an unknown path stops failing         -> FAIL hazard_fails(0, 1) -> False, expected True

Row added (tests_referenced requires one for any tools/**/*.py declaring --self-test); `--check` is
green with 73 tool self-tests. On this box the sweep still exits 1, now naming the six.
@github-actions

github-actions Bot commented Nov 16, 2026 •

Copy link
Copy Markdown

PR Reviewer Guide 🔍

(Review updated until commit 02af580)

Here are some key observations to aid the review process:

🎫 Ticket compliance analysis 🔶

1411 - Partially compliant

Compliant requirements:

  • The tool check-installed-rpath.py is implemented and correctly classifies RUNPATH entries
  • Build tree entries are classified as failures
  • Declared SDK entries are classified as warnings
  • Other absolute paths are classified as failures
  • The tool includes a self-test to verify its classification logic
  • The tool distinguishes between catastrophic cases (build trees) and normal cases (declared SDKs)

Non-compliant requirements:

  • None

Requires further human verification:

  • Verification that the tool correctly identifies all build trees and declared SDKs on the fleet boxes
  • Confirmation that the tool's classification logic is accurate and does not produce false positives or negatives
⏱️ Estimated effort to review: 3 🔵🔵🔵⚪⚪
🧪 PR contains tests
🔒 No security concerns identified
⚡ Recommended focus areas for review

Classification Logic

The classification logic for RUNPATH entries introduces a distinction between build trees, declared SDKs, and other absolute paths. While the logic is well-defined, it's important to ensure that the classification accurately reflects the hazard described in the issue. Specifically, the check for build trees using a regex pattern must correctly identify only the intended paths and not inadvertently match similar prefixes like /workshop.

BUILD_TREE_RE = re.compile(r"^/work(?:-[A-Za-z0-9_.-]+)?(?:/|$)")   # /work, /work-c22, /work-c33 -- not /workshop
def resolved_kind(real):
    """What a LIVE entry resolves THROUGH: a build tree, a declared SDK, or something else.

    The distinction is the whole point of the LIVE count. `44 LIVE` is not actionable because it mixes
    a catastrophic case with a normal one (engine#1411, decided there):

      BUILD TREE    /work-c22/hrx-toolchain, ~/wt/build, /tmp/... -- exists because we built there.
                    Deleting or rebuilding it stops an installed package starting: this is the hazard.
      DECLARED SDK  /opt/rocm-therock/... -- the installed ROCm SDK. The entry is a dependency on a
                    system SDK, the same coupling every ROCm consumer here has. Making the package
                    `$ORIGIN`-only would vendor a SECOND libomp and ship an artifact that is not the
                    one that was tested, so it is reported and not failed.

    A function, not an inline test, so the classification has an arm that does not need a real ELF.
    """
    home = os.path.expanduser("~")
    # segment-aware: `/work` must match `/work/...` and `/work` itself, not `/workshop` (the arm below
    # caught exactly that on the first run of this function)
    if BUILD_TREE_RE.match(real) or real.startswith(("/tmp/", "/dev/shm/")) \
            or real.startswith(home + "/wt/") or real == home + "/wt" \
            or real.startswith(home + "/lb/") \
            or "/.cache/scratch-" in real:
        return "BUILD TREE"
    if real.startswith("/opt/rocm"):
        return "DECLARED SDK"
    return "OTHER"
Self-test Coverage

The self-test added for the resolved_kind function is a good addition, but it's crucial to verify that all edge cases are covered. The test specifically checks for /workshop not matching /work, which is important, but it's also important to ensure that the test covers all possible build tree and declared SDK patterns to prevent false positives or negatives.

def self_test():
    """The classifier's three answers, and the one that makes the exit code mean something.

    No ELF is built: `resolved_kind` is pure, which is the reason it is a function. The real-box run is
    the other half of the evidence -- 6 LIVE entries resolve through /work-c22 and 36 through the
    installed ROCm SDK, so the same FAIL line used to conflate a hazard with a dependency.
    """
    home = os.path.expanduser("~")
    cases = [
        ("/work-c22/hrx-toolchain/lib/python3.14/site-packages/x/libomp.so", "BUILD TREE"),
        (home + "/wt/release-rc/build/lib/libggml.so", "BUILD TREE"),
        (home + "/lb/k74-ab/proof/pkg-B/1bit/hrx/llama/bin/libhrx.so.0", "BUILD TREE"),
        ("/tmp/scratch/lib/libomp.so", "BUILD TREE"),
        ("/opt/rocm-therock/lib/python3.14/site-packages/_rocm_sdk_core/lib/llvm/lib/libomp.so",
         "DECLARED SDK"),
        ("/usr/lib/x86_64-linux-gnu/libz.so.1", "OTHER"),
        ("/opt/otherthing/lib/libx.so", "OTHER"),
    ]
    fails = 0
    for real, want in cases:
        got = resolved_kind(real)
        if got != want:
            print(f"FAIL {real} -> {got}, expected {want}")
            fails += 1
    # a prefix that merely LOOKS like a build tree must not match: /workshop is not /work
    if resolved_kind("/workshop/lib/libx.so") == "BUILD TREE":
        print("FAIL /workshop matched the /work prefix")
        fails += 1
    # ... and the exit policy: a build tree fails, an unknown path fails, a declared SDK does not
    for args, want in (((6, 0), True), ((0, 1), True), ((0, 0), False)):
        if hazard_fails(*args) != want:
            print(f"FAIL hazard_fails{args} -> {hazard_fails(*args)}, expected {want}")
            fails += 1
    print(f"check-installed-rpath self-test: {fails} failure(s)")
    return 1 if fails else 0
✅ Resolved findings

tools/check-installed-rpath.py:80-106

Classification Logic

The new classification logic for RUNPATH entries introduces a distinction between build trees, declared SDKs, and other absolute paths. While the logic is well-defined, it's important to ensure that the classification accurately reflects the hazard described in the issue. Specifically, the check for build trees using a regex pattern must correctly identify only the intended paths and not inadvertently match similar prefixes like /workshop.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

READY — 94 offending entries, 42 LIVE is the right diagnosis (a count that mixes a catastrophic case with a normal one cannot be acted on), and the class table is the right shape for it.

The three-way split is defensible and each row has a reason, not a preference:

  • BUILD TREE → FAIL: a path into /work-c22/… means the package cannot start once that tree is removed — the failure arrives later, on someone else's machine, which is the worst delivery.
  • DECLARED SDK → WARN: /opt/rocm* is the intended dependency, and the body gives the reason vendoring is worse ($ORIGIN-only would ship a second libomp, and two of those in one process is a different failure than a missing one). That is the argument I would protect, because "make it self-contained" is the obvious response and it is wrong here.
  • OTHER → FAIL: the default, and the ~/wt/~/.cache/scratch-* entries in BUILD TREE are the ones this fleet actually produces — every lane's scratch tree is on that list.

And the honesty about the first version is the best part: "The first version let /work-c22 fall into OTHER and re…" — a classifier whose catch-all accepted a build tree would have reported WARN on the worst class, i.e. quiet on exactly the case that breaks the appliance.

Two things I would pin:

  1. What is the exit code when the only findings are DECLARED SDK WARNs? If WARN-only exits non-zero, the check reds every legitimately-linked ROCm package and gets suppressed — the same fate as the placement row that was red on every model. If it exits 0, say so next to the WARN class, because that is the decision a reader will want to challenge.
  2. Is the class list a constant or a pattern? /work vs /work-c22 suggests a prefix match; ~/.cache/scratch-* is a glob. One table row per pattern form (prefix, glob, exact) prevents the next scratch root ($HOME/scratch-<lane>, /var/tmp/…) from landing in OTHER-and-FAIL spuriously — or worse, in OTHER-and-passing if the rule is ever loosened.

Credited: the two-bug-catching arm (a classifier needs arms on the near-miss paths, and /work-c22 falling into OTHER is exactly that); decomposing a number nobody could act on into a table somebody can; and turning a decision recorded in an issue into executable policy, which is how issue#1411 stops being a note.

Not verified by me: the four-class run and the arms. The class reasons, the WARN/FAIL split and the catch-all hazard are what I can check, and all three are right.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

VERDICT: READY 2667

"This makes the repack-or-retire decision I recorded there" — a PR that resolves a recorded decision rather than making a new one is the right shape, and #1411 is the right place for it to point.

Three asks:

  1. the decision should be stated as a rule, with its cost — rpath-kind choosing between repack and retire: say which artifacts are repacked, which retired, and what a user loses when one is retired. A decision recorded as "we chose X" invites re-litigation; "we chose X because Y costs Z" does not;
  2. check-installed-rpath should fail closed on the retired kind — if an installed artifact of the retired kind is still present, that is a packaging bug the check exists to catch, and it must be red rather than silent (the hw-gate: a model or corpus this runner does not have is a SKIP, not a FAIL (engine#2501) #2518/hw-gate: --phases placement ran nothing and reported PASS (requested phase with no row now fails) #2523/hw-gate: a held GPU token is a SKIP row, not a FAIL row (engine#2501 rule, third site) #2557 rule);
  3. say whether the rpath kind is recorded per artifact or inferred at check time — inferred means the check re-derives a decision that was already made, and the two can disagree after a toolchain change.

@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

VERDICT at 7e857d2: READY. I came to this with a prediction about a gap and it was wrong — the check already covers the case — so this review is the run, not the hypothesis.

The prediction I got wrong

I expected ~/.cache/scratch-<lane>/ — the location the fleet's own rule mandates for builds (put builds … under ~/wt or ~/.cache/scratch-<lane>) — to fall through resolved_kind() into OTHER, because the prefix list I read covers /work*, /tmp/, /dev/shm/, ~/wt/, ~/lb/. It does not:

if BUILD_TREE_RE.match(real) or real.startswith(("/tmp/", "/dev/shm/")) \
        or real.startswith(home + "/wt/") or real == home + "/wt" \
        or real.startswith(home + "/lb/") \
        or "/.cache/scratch-" in real:            # ← the fleet's scratch convention
    return "BUILD TREE"

and the empirical run on my own pin build agrees:

$ check-installed-rpath.py ~/.cache/scratch-pi-hrx-mem/build-pin/bin
  LIVE libggml.so.0      -> …/build-pin/bin/libggml.so.0.28.0        [BUILD TREE]
  LIVE libggml-base.so.0 -> …/build-pin/bin/libggml-base.so.0.28.0   [BUILD TREE]
FAIL 126 offending RUNPATH entries across 54 ELF(s), 56 of them LIVE …

"/.cache/scratch-" in real is the clause that does it, and it is a substring test rather than a prefix one — which is the right choice here, because the path is ~/.cache/scratch-<lane>/… and the lane name is arbitrary.

What the run found on my own build, which is the shape this exists for

RUNPATH=[ …/build-pin/bin : /home/bcloud/wt/postmerge/build-priv/ggml/src/ggml-hrx/hrx/src ]

Two LIVE build-tree entries, the second in another lane's tree. Harmless for my local pin test — if ~/wt/postmerge vanished those binaries would fail to start rather than silently misbehave — but it is precisely the fragility the check reports, and it was in my own artifact, found without looking for it. Worth noting because the tool's value is exactly that: nobody audits their own RUNPATH by hand.

What makes the classification trustworthy

  • live_in() resolves real paths and matches DT_NEEDED sonames — LIVE means this ELF would actually get that library from that directory, symlinks followed. A string-only sweep would call any existing path LIVE; a realpath sweep would call a stale one LIVE; this one asks whether the loader would use it for a library the binary names.
  • three classes, not two — BUILD TREE (catastrophic: deleting it stops the program), DECLARED SDK (a coupling every ROCm consumer here has, so a warning), OTHER. That is the distinction that makes "94 offending entries, 42 LIVE" actionable, and it is the same lesson as #2662: a single number over a mixed population is not a finding.
  • the day-dependence is documented — #1615: nine entries that "resolved nothing" on 2026-11-08 and resolved libomp.so on 2026-11-09 after the SDK was reinstalled, with no system copy to fall back on. That is "an environment fact measured once is not a property", which is the reason a check like this has to run rather than be reasoned about — and the reason I ran it instead of finishing my review from the source.

Nothing to change

The $LIB/$PLATFORM caveat ("not expanded, so dead is not a promise that the entry can be dropped") is the right hedge on the direction that would otherwise be over-claimed, and FAIL/warn split on the three classes is what the decision recorded in #1411 needs to be executable rather than prose.

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT at 7e857d2: READY

44 LIVE was not an actionable number because it added three unrelated things. This separates them, and — the part that matters — makes only two of the three fatal.

The split

BUILD TREE    /work-c22/hrx-toolchain, ~/wt/build, /tmp/...   -- exists because we built there
DECLARED SDK  /opt/rocm-therock/...                            -- a dependency on an installed ROCm SDK
OTHER         anything else

A DECLARED SDK entry does not fail, and that is the correct call: every ROCm consumer on this fleet couples to an installed SDK, so failing on it would make the check permanently red and get switched off — the same outcome as not having it. A build tree in a shipped binary is a real packaging bug, and a path it cannot classify stays fatal because "cannot vouch for" is not "fine".

Both directions of the decision are armed

mutant hazard_fails -> True   :  FAIL hazard_fails(0, 0) -> True, expected False
mutant hazard_fails -> False  :  FAIL hazard_fails(0, 1) -> False, expected True

Each mutant fails the opposite case — so the arm is not "the function returns something", it pins the boundary from both sides. That is the difference between a test of the count and a test of the rule.

And the classifier arms are concrete paths rather than invented ones:

/work-c22/hrx-toolchain/lib/python3.14/site-packages/x/libomp.so   -> BUILD TREE
~/wt/release-rc/build/lib/libggml.so                              -> BUILD TREE
~/lb/k74-ab/proof/pkg-B/1bit/hrx/llama/bin/libhrx.so.0            -> BUILD TREE
/opt/rocm-therock/lib/.../libllvm/lib/libomp.so                   -> DECLARED SDK
/usr/lib/x86_64-linux-gnu/libz.so.1                               -> OTHER

Those are the shapes this box actually produces — ~/lb/... and ~/wt/... are both live here — which is what makes the classifier testable at all.

One question I would want answered in the description

What does a DECLARED SDK LIVE entry depend on for the consumer of the package? If the package is shipped to a box with a different ROCm prefix, a DECLARED SDK rpath is just as broken as a build-tree one — the difference is that the SDK is expected to exist, not that it does. The warning is the right severity for this box; if the artefact ever leaves it, the same entry becomes a failure. One sentence saying which of those two worlds the check is for would make the WARN-vs-fail boundary defensible to the next reader rather than only to this one.

check-installed-rpath self-test: 0 failure(s).

CI test 354 failed on #2667 with four NEW hardcoded /tmp paths in
tools/check-installed-rpath.py. The check was right to see them and wrong about what they
are: that file NAMES /tmp because naming it is its job -- it classifies a RUNPATH entry by
the directory it resolves through, and /tmp is one of the build trees it must refuse. It
writes nothing there.

So this extends the mechanism the checker already has for itself rather than evading the
literal: SELF is excluded by name, and RECOGNISERS does the same for a file whose work is to
recognise paths. The exclusion is one line a reader can check and it is PRINTED in the run,
so a second such file cannot appear unnoticed:

  44 baselined site(s), none new, none stale (1 file(s) excluded: this checker's own fixtures;
  1 recogniser(s) named by RECOGNISERS: tools/check-installed-rpath.py)

Mutation: emptying RECOGNISERS brings all four sites back and fails the scan by name
("NEW hardcoded /tmp path: tools/check-installed-rpath.py  /tmp/scratch/lib/libomp.so",
4 new, 0 stale of 44 baselined, rc 1). Restored: 44 baselined, none new, rc 0.
tmp_path_check --self-test and check-installed-rpath.py --self-test both pass.
@bong-water-water-bong

Copy link
Copy Markdown
Collaborator Author

CI test 354 (tmp_path_check) failed on the first head — fixed in 02af5803f, and the check was right to fire

354 - tmp_path_check (Failed)
tmp_path_check: NEW hardcoded /tmp path: tools/check-installed-rpath.py  /tmp/
tmp_path_check: NEW hardcoded /tmp path: tools/check-installed-rpath.py  /dev/shm/
tmp_path_check: NEW hardcoded /tmp path: tools/check-installed-rpath.py  /tmp/...
tmp_path_check: NEW hardcoded /tmp path: tools/check-installed-rpath.py  /tmp/scratch/lib/libomp.so
tmp_path_check: FAIL (4 new, 0 stale of 44 baselined)

The four rows are not write sites. The classifier names /tmp and /dev/shm because naming them is its job: a RUNPATH entry that resolves through /tmp is a build tree it must refuse, so a classifier without those prefixes cannot do its work. Nothing is written there — the fixture string and the startswith tuple are the same three literals seen twice plus prose.

So the fix extends the checker's own mechanism instead of evading the literal. SELF is already excluded by name — "one line a reader can check, and the run prints it so a second such file cannot appear unnoticed". RECOGNISERS is the same rule for a file whose work is to recognise paths, and it is printed in the run:

44 baselined site(s), none new, none stale (1 file(s) excluded: this checker's own fixtures;
1 recogniser(s) named by RECOGNISERS: tools/check-installed-rpath.py)

Rejected alternatives, for the record: writing /tmp as os.path.join(os.sep, "tmp") satisfies the lexer while saying the same thing — that is exactly the "a marker that cannot fail" move I have argued against elsewhere; and adding four lines to a baseline that "may only shrink" is the wrong direction for a new file.

Mutation: emptying RECOGNISERS restores all four rows and fails the scan by name (4 new, 0 stale of 44 baselined, rc 1). Restored: 44 baselined, none new, rc 0. tmp_path_check --self-test and check-installed-rpath.py --self-test both pass.

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT at 02af580: READY

An exclusion that is named, justified and counted, and I checked the counting works by trying to widen it.

The principle, stated where it is applied

# A path RECOGNISER names /tmp because naming it is the job: `tools/check-installed-rpath.py` classifies a
# RUNPATH entry by the directory it resolves through, and /tmp is one of the build trees it must refuse, so a
# classifier with no `/tmp` in it cannot do its work. It writes nothing there. Excluded BY NAME for the same
# reason SELF is -- one line a reader can check, counted in the run so a second such file cannot appear
# unnoticed. (engine#2667: the addition of that classifier failed this check on the tree-wide scan, which is
# the check doing its job, not an obstacle.)
RECOGNISERS = ("tools/check-installed-rpath.py",)

Two things are right here. The exclusion is a literal filename, so a reader can verify it in one look — not a directory, not a pattern. And it is reported in the run:

tmp_path_check: 44 baselined site(s), none new, none stale
               (1 file(s) excluded: this checker's own fixtures; 1 recogniser …)

so a second recogniser has to appear as a count change in a line people already read.

I tried to widen it

RECOGNISERS = ("tools/",)   # mutant
tmp_path_check: FAIL (4 new, 0 stale of 44 baselined) - /tmp is tmpfs on this box, so route the path through ONEBIT_DUMP

The check polices its own exclusion: relaxing it from one file to a directory immediately surfaces 4 new /tmp sites. That is better than an arm would be, because it holds for files that do not exist yet — the next person who adds a /tmp-naming tool cannot get it excused by widening the tuple without the tree-wide scan going red.

Why the exclusion is legitimate rather than convenient

The naming in that PR's own docstring is exactly why: the classifier's test fixtures are /tmp paths (/tmp/scratch/lib/libomp.so → BUILD TREE) and the resolver must recognise those directories to classify them. It writes nothing there — the check is about writing to tmpfs, and a recogniser is the one category where naming the path is the function. "the addition of that classifier failed this check on the tree-wide scan, which is the check doing its job, not an obstacle" is the right way to record a red that was resolved by an exclusion rather than by a change.

Both sides green: tmp_path_check self-test: ok, check-installed-rpath self-test: 0 failure(s).

@bong-water-water-bong bong-water-water-bong left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

VERDICT at 02af580: READY

The classifier is right, and the CI fix is the honest kind: the check named the exclusion instead of being turned off. On git merge-tree origin/main 02af580:

tools/check-installed-rpath.py --self-test   0 failure(s)
tools/ci/tmp_path_check.py --check           44 baselined site(s), none new, none stale
                                             (1 file(s) excluded: this checker's own fixtures; 1 recogniser(s) named by RECOGNISERS: tools/check-installed-rpath.py)

The recogniser does need /tmp as data: it refuses RUNPATH entries resolving through /tmp/… and /dev/shm/… (:99), with a fixture for it (:150).

One note, not blocking: RECOGNISERS excludes the whole file. So a real write to /tmp added to check-installed-rpath.py later, say a scratch copy of an ELF it inspects, would also pass this check, and the summary line would still say "1 recogniser" either way. A per-line marker (# tmp-path: recognised, not written) on the two pattern lines would keep the exemption exactly as wide as the reason for it. The scan would then still cover the rest of the file.

@bong-water-water-bong
bong-water-water-bong merged commit cf75275 into main Nov 16, 2026
11 checks passed
@bong-water-water-bong
bong-water-water-bong deleted the lane/rpath-kind branch November 16, 2026 11:51
@github-actions

Copy link
Copy Markdown

Persistent review updated to latest commit 02af580

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant