diff --git a/.github/workflows/grant-source-package-controls.yml b/.github/workflows/grant-source-package-controls.yml new file mode 100644 index 0000000..589a747 --- /dev/null +++ b/.github/workflows/grant-source-package-controls.yml @@ -0,0 +1,328 @@ +name: Grant source package controls + +on: + pull_request: + workflow_dispatch: + +permissions: {} + +jobs: + source-controls: + runs-on: ${{ matrix.os }} + timeout-minutes: 12 + strategy: + fail-fast: false + matrix: + os: [ubuntu-24.04, macos-26] + steps: + - name: Check out exact SDK review source + uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 + with: + persist-credentials: false + + - name: Verify publication bytes and run portable source cohorts + timeout-minutes: 10 + run: | + PYTHONDONTWRITEBYTECODE=1 python3 - <<'PYTHON' + import hashlib + import importlib.util + import json + import os + import pathlib + import platform + import subprocess + import stat + import sys + + root = pathlib.Path("tools/grant_compile_acceptance").resolve() + output = pathlib.Path(os.environ["RUNNER_TEMP"]) / "grant-source-package-controls" + output.mkdir() + result = {"source_controls_passed": False, "actual_compiler_container_native_ssh_jobs": 0, + "accepted_target_cells": 0, "required_target_cells": 144, + "observed_platform": sys.platform, "python_version": platform.python_version(), + "run_id": os.environ.get("GITHUB_RUN_ID"), "run_attempt": os.environ.get("GITHUB_RUN_ATTEMPT"), + "source_commit": os.environ.get("GITHUB_SHA"), "full_native_provider_accepted": False} + digest = lambda path: hashlib.sha256(path.read_bytes()).hexdigest() + try: + pins = root / "PUBLICATION_PINS.v101.json" + if digest(pins) != "b4510c07cfc5078e12ed24a0f1aaa50a80b861b420c9716d94dfae2beeb71164": + raise RuntimeError("Exact publication source manifest required") + manifest = json.loads(pins.read_text()) + for row in manifest["files"]: + path = root / row["path"] + if path.parent != root or path.is_symlink() or not path.is_file() or stat.S_IMODE(path.stat().st_mode) != row["mode"] or path.stat().st_size != row["bytes"] or digest(path) != row["sha256"]: + raise RuntimeError("Publication input differs: " + row["path"]) + python = pathlib.Path(sys.executable).resolve() + matches = [row for row in manifest["source_python_profiles"][sys.platform] + if platform.python_version() == row["version"] and digest(python) == row["sha256"]] + if len(matches) != 1: + raise RuntimeError("Observed source-test Python needs exact profile review") + profile = matches[0] + result["python_sha256"] = digest(python) + source = root / "verify_publication_v101.py" + if digest(source) != "728f7df0eb6b36c127bc9ea81e8356834cb2272acfd6ae357f8ec27cfe219695": + raise RuntimeError("Exact v101 verifier source required before import") + spec = importlib.util.spec_from_file_location("reviewed_grant_publication", source) + verifier = importlib.util.module_from_spec(spec) + spec.loader.exec_module(verifier) + archive = root / "grant-linux-first-build-publication-v101.tar.gz" + verification = verifier.verify(archive, manifest["outer_archive_sha256"], manifest["contents_sha256"], output / "verified package with spaces") + (output / "VERIFICATION_RECEIPT.json").write_text(json.dumps(verification, indent=2) + "\n") + damaged = output / "changed-archive.tar.gz" + changed = bytearray(archive.read_bytes()); changed[-1] ^= 1; damaged.write_bytes(changed) + try: + verifier.verify(damaged, manifest["outer_archive_sha256"], manifest["contents_sha256"], output / "changed artifact refusal") + except ValueError as error: + if "digest required" not in str(error): + raise + result["changed_archive_refused"] = True + else: + raise RuntimeError("Changed publication archive was accepted") + payload = output / "verified package with spaces" / verifier.PREFIX + args = [str(python), "-I", "-S", "-B", str(payload / "tools/run_source_tests_v101.py"), + "--sdk-checkout", str(pathlib.Path.cwd()), "--contents-sha256", manifest["contents_sha256"], + "--python-sha256", profile["sha256"], "--python-version", profile["version"], + "--output", str(output / "source cohorts with spaces")] + with (output / "cohorts.stdout.txt").open("xb") as stdout, (output / "cohorts.stderr.txt").open("xb") as stderr: + completed = subprocess.run(args, stdin=subprocess.DEVNULL, stdout=stdout, stderr=stderr, timeout=540, check=False) + result["source_wrapper_exit_code"] = completed.returncode + if sum((output / name).stat().st_size for name in ("cohorts.stdout.txt", "cohorts.stderr.txt")) > 8 * 2**20: + raise RuntimeError("Bounded complete source-wrapper output required") + if completed.returncode: + raise RuntimeError("Portable source cohort wrapper failed") + receipt = json.loads((output / "source cohorts with spaces/SOURCE_TEST_RECEIPT.json").read_text()) + if receipt["source_tests_passed"] is not True or len(receipt["cohorts"]) != 4 or not all(row["passed"] for row in receipt["cohorts"]): + raise RuntimeError("Every complete original source cohort must pass") + regressions = receipt.get("successor_regressions", []) + if len(regressions) != 2 or not all(row["passed"] and row["expected_tests"] == 12 for row in regressions): + raise RuntimeError("Both complete successor regression cohorts must pass") + result["original_source_test_executions"] = sum(row["expected_tests"] for row in receipt["cohorts"]) + result["successor_regression_test_executions"] = sum(row["expected_tests"] for row in regressions) + if digest(python) != profile["sha256"]: + raise RuntimeError("Source-test Python changed") + result["actual_linux_source_cohorts_executed"] = sys.platform == "linux" + result["source_controls_passed"] = True + except Exception as error: + result["error"] = type(error).__name__ + ": " + str(error) + finally: + (output / "CI_SOURCE_EXECUTION.json").write_text(json.dumps(result, indent=2) + "\n") + print(json.dumps(result, indent=2)) + raise SystemExit(0 if result["source_controls_passed"] else 2) + PYTHON + + - name: Stage exact public source evidence + id: stage_evidence + if: always() + timeout-minutes: 2 + run: | + PYTHONDONTWRITEBYTECODE=1 python3 -I -S -B - <<'STAGING_PYTHON' + """Select contained public source evidence as regular files for hosted upload.""" + import hashlib + import io + import json + import os + from pathlib import Path, PurePosixPath + import platform + import re + import stat + import sys + import tarfile + + OUTER_SHA = "39ae53df3f72668f63101e0f65606cc41b2787c71292bff0f163031bb4bb309e" + ANCESTOR_SHA = "aebd690e5978aa6373e2177aa7ee2d5bcb8b7e064cc50aee18ae9c4d53fc5601" + INNER_SHA = "d2c90cc3110109337c92f567fdf533dadf475b3f468602b8fcb5e2ed21426ff5" + CONTENTS_SHA = "6ed26546943e29553c6cdf062652ecd30529924da402b53b5b39d3f7f6456080" + PINS_SHA = "b4510c07cfc5078e12ed24a0f1aaa50a80b861b420c9716d94dfae2beeb71164" + MAX_FILE = 20 * 2**20 + MAX_TOTAL = 64 * 2**20 + LABELS = ("v100-ordinary", "v100-optimized", "v102-ordinary", "v102-optimized", "v101-successor-ordinary", "v101-successor-optimized") + PATTERNS = ( + re.compile(rb"authorization\s*:\s*(?:basic|bearer)\s+[A-Za-z0-9_+/=-]{16,}", re.I), + re.compile(rb"(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})"), + re.compile(rb"https?://[^\s/:@]+:[^\s/@]+@", re.I), + re.compile(rb"-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----"), + ) + + + def need(value, message): + if not value: + raise ValueError(message) + + + def digest(raw): + return hashlib.sha256(raw).hexdigest() + + + def public_path(name): + path = PurePosixPath(name) + need(bool(name) and str(path) == name and not path.is_absolute() and all(part not in ("", ".", "..") for part in path.parts), "Canonical contained evidence path required") + forbidden = {".git", ".gitconfig", ".git-credentials", ".netrc", ".ssh", ".aws", ".npmrc", ".pypirc", ".env"} + need(not any(part.casefold() in forbidden for part in path.parts), "Public evidence excludes checkout and credential metadata") + need(not any(path.parts[i:i+2] == ("linux_whole_build_ci_v100", "checkout") for i in range(len(path.parts)-1)), "Provider checkout stays outside public evidence") + return path + + + def read_regular(root, name): + relative = public_path(name) + need(root.resolve(strict=True) == root and stat.S_ISDIR(root.lstat().st_mode), "Exact physical evidence root required") + path = root + for component in relative.parts[:-1]: + path /= component + need(stat.S_ISDIR(path.lstat().st_mode), "Physical contained evidence parent required") + path /= relative.name + before = path.lstat() + need(stat.S_ISREG(before.st_mode) and before.st_nlink == 1 and before.st_size <= MAX_FILE, "Bounded single-link regular evidence file required") + with os.fdopen(os.open(path, os.O_RDONLY | os.O_NOFOLLOW), "rb") as stream: + opened = os.fstat(stream.fileno()) + need((opened.st_dev, opened.st_ino, opened.st_size) == (before.st_dev, before.st_ino, before.st_size), "Stable regular evidence identity required") + raw = stream.read(MAX_FILE + 1) + after = os.fstat(stream.fileno()) + need(len(raw) == before.st_size and (after.st_dev, after.st_ino, after.st_size, after.st_mtime_ns) == (before.st_dev, before.st_ino, before.st_size, before.st_mtime_ns), "Stable complete bounded evidence bytes required") + need(path.resolve(strict=True) == path and path.is_relative_to(root), "Contained physical evidence readback required") + return raw + + + def inspect_public_bytes(name, raw, archive_sha=None): + public_path(name) + if archive_sha is not None: + need(digest(raw) == archive_sha, "Exact public archive identity required") + expanded = 0 + with tarfile.open(fileobj=io.BytesIO(raw), mode="r:gz") as archive: + for index, member in enumerate(archive): + need(index < 4096, "Bounded public archive member count required") + public_path(member.name) + need(member.isfile() or member.isdir() or member.issym(), "Reviewed public archive member kind required") + expanded += member.size + need(member.size <= MAX_FILE and expanded <= MAX_TOTAL, "Bounded public archive metadata required") + if member.isfile() and not member.name.endswith(".tar.gz"): + data = archive.extractfile(member).read(MAX_FILE + 1) + need(not any(pattern.search(data) for pattern in PATTERNS), "Public archive credential-shaped content refused") + return + need(not any(pattern.search(raw) for pattern in PATTERNS), "Public evidence credential-shaped content refused") + + + def stage_evidence(sdk, output, stage): + sdk = Path(sdk) + output = Path(output) + stage = Path(stage) + need(stage.parent.resolve(strict=True) == stage.parent and not stage.exists() and not stage.is_symlink(), "Fresh physical public evidence stage required") + public = sdk / "tools/grant_compile_acceptance" + pin_raw = read_regular(public, "PUBLICATION_PINS.v101.json") + need(digest(pin_raw) == PINS_SHA, "Exact public publication manifest required") + pins = json.loads(pin_raw) + python = Path(sys.executable).resolve(strict=True) + python_sha = digest(python.read_bytes()) + need(any(row["version"] == platform.python_version() and row["sha256"] == python_sha for row in pins["source_python_profiles"][sys.platform]), "Exact observed source Python profile required for staging") + plan = [(public, "PUBLICATION_PINS.v101.json", "public/PUBLICATION_PINS.v101.json", PINS_SHA, None)] + for row in pins["files"]: + archive_sha = row["sha256"] if row["path"].endswith(".tar.gz") else None + plan.append((public, row["path"], "public/" + row["path"], row["sha256"], archive_sha)) + for name in ("CI_SOURCE_EXECUTION.json", "VERIFICATION_RECEIPT.json", "cohorts.stdout.txt", "cohorts.stderr.txt"): + plan.append((output, name, "execution/" + name, None, None)) + cohort_root = "source cohorts with spaces/" + plan.append((output, cohort_root + "SOURCE_TEST_RECEIPT.json", "execution/SOURCE_TEST_RECEIPT.json", None, None)) + for label in LABELS: + for stream in ("stdout", "stderr"): + name = label + "." + stream + ".txt" + plan.append((output, cohort_root + name, "cohorts/" + name, None, None)) + verified_root = "verified package with spaces/" + for name, expected in (("outer-reproduced.tar.gz", OUTER_SHA), ("inner-reproduced.tar.gz", INNER_SHA)): + plan.append((output, verified_root + name, "reproduced/" + name, expected, expected)) + payload = verified_root + "grant-first-build-publication-v101/" + contents = None + try: + contents_raw = read_regular(output, payload + "PACKAGE_CONTENTS.json") + except FileNotFoundError: + pass + else: + need(digest(contents_raw) == CONTENTS_SHA, "Exact reproduced member manifest required") + contents = json.loads(contents_raw) + members = {row["path"]: row["sha256"] for row in contents["files"]} + plan.append((output, payload + "PACKAGE_CONTENTS.json", "manifests/PACKAGE_CONTENTS.json", CONTENTS_SHA, None)) + for name in ("PORTABLE_HELPER_COMPATIBILITY.v101.json", "origin/INNER_TAR_MEMBER_LEDGER.json", "origin/ARCHIVE_MEMBER_ORIGINS_COMPLETE.json", "successor_source/TOOL_SOURCE_PINS.json", "workspace/grant_linux_first_build_v102/SOURCE_PINS.json", "workspace/grant_linux_first_build_v102/ANCESTOR_SOURCE_ROSTER.json"): + plan.append((output, payload + name, "manifests/" + name, members[name], None)) + selected, missing = [], [] + total = 0 + for root, source_name, destination, expected, archive_sha in plan: + public_path(destination) + try: + raw = read_regular(root, source_name) + except FileNotFoundError: + need(root == output, "Every exact public source input required") + missing.append(destination) + continue + need(expected is None or digest(raw) == expected, "Exact selected evidence digest required") + inspect_public_bytes(destination, raw, archive_sha) + total += len(raw) + need(total <= MAX_TOTAL, "Bounded complete public evidence required") + selected.append((destination, raw)) + # Successful source execution requires the complete twelve-stream evidence set. + selected_map = dict(selected) + if "execution/CI_SOURCE_EXECUTION.json" in selected_map: + ci = json.loads(selected_map["execution/CI_SOURCE_EXECUTION.json"]) + if ci.get("source_controls_passed") is True: + need(not missing and contents is not None, "Complete passing source evidence required") + tests = json.loads(selected_map["execution/SOURCE_TEST_RECEIPT.json"]) + rows = tests["cohorts"] + tests["successor_regressions"] + need(len(rows) == 6 and {row["label"] for row in rows} == set(LABELS), "All six original/regression cohorts required") + for row in rows: + for stream in ("stdout", "stderr"): + meta = row[stream] + need(meta["path"] == row["label"] + "." + stream + ".txt", "Exact raw cohort path required") + raw = selected_map["cohorts/" + meta["path"]] + need(len(raw) == meta["bytes"] and digest(raw) == meta["sha256"], "Exact raw cohort stream required") + stage.mkdir(mode=0o700) + rows = [] + for name, raw in selected: + destination = stage / name + destination.parent.mkdir(parents=True, exist_ok=True) + with destination.open("xb") as stream: + stream.write(raw) + destination.chmod(0o644) + need(read_regular(stage, name) == raw, "Exact staged evidence readback required") + rows.append({"path": name, "bytes": len(raw), "sha256": digest(raw), "kind": "regular file"}) + receipt = {"mission": "memory-budget-experiment", "public_evidence_stage_passed": True, + "selection": "Exact named public archives, reproduced archives/manifests, receipts, and twelve raw cohort streams", + "workspace_and_provider_selection": "outside the staged evidence tree", "required_hidden_Grant_inputs": "retained in exact hash-pinned public source archives", + "credential_metadata_refusal_passed": True, "files": rows, "missing_failure_evidence": missing, + "source_python": {"version": platform.python_version(), "sha256": python_sha, "path": str(python)}, + "actual_compiler_container_native_ssh_jobs": 0, "accepted_target_cells": 0, "required_target_cells": 144} + receipt_raw = (json.dumps(receipt, indent=2, sort_keys=True) + "\n").encode() + inspect_public_bytes("PUBLIC_EVIDENCE_STAGE.json", receipt_raw) + with (stage / "PUBLIC_EVIDENCE_STAGE.json").open("xb") as stream: + stream.write(receipt_raw) + expected_names = {row["path"] for row in rows} | {"PUBLIC_EVIDENCE_STAGE.json"} + observed = set() + for path in stage.rglob("*"): + relative = path.relative_to(stage).as_posix() + public_path(relative) + need(not path.is_symlink(), "Physical staged evidence members required") + if path.is_file(): + staged_raw = read_regular(stage, relative) + need(staged_raw == (receipt_raw if relative == "PUBLIC_EVIDENCE_STAGE.json" else selected_map[relative]), "Final staged evidence retains exact selected bytes") + observed.add(relative) + else: + need(stat.S_ISDIR(path.lstat().st_mode), "Physical staged evidence directories required") + need(observed == expected_names, "Complete exact staged evidence membership required") + return receipt + + + if __name__ == "__main__": + receipt = stage_evidence(Path.cwd().resolve(), Path(os.environ["RUNNER_TEMP"]).resolve() / "grant-source-package-controls", + Path(os.environ["RUNNER_TEMP"]).resolve() / "grant-source-package-public-evidence") + print(json.dumps({"public_evidence_stage_passed": True, "regular_files": len(receipt["files"]), "missing_failure_evidence": receipt["missing_failure_evidence"]})) + STAGING_PYTHON + + - name: Preserve source package execution and refusals + if: ${{ always() && steps.stage_evidence.outcome == 'success' }} + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v4.6.2 + with: + name: grant-source-package-${{ matrix.os }} + path: | + ${{ runner.temp }}/grant-source-package-public-evidence + !${{ runner.temp }}/grant-source-package-public-evidence/**/linux_whole_build_ci_v100/checkout/** + !${{ runner.temp }}/grant-source-package-public-evidence/**/.git + !${{ runner.temp }}/grant-source-package-public-evidence/**/.git/** + if-no-files-found: error + retention-days: 30 + include-hidden-files: false diff --git a/.github/workflows/linux-kernel-budget-controls.yml b/.github/workflows/linux-kernel-budget-controls.yml new file mode 100644 index 0000000..b328087 --- /dev/null +++ b/.github/workflows/linux-kernel-budget-controls.yml @@ -0,0 +1,58 @@ +name: Linux kernel budget qualification +on: + pull_request: + paths: + - tools/installation_provenance/** + - .github/workflows/linux-kernel-budget-controls.yml + - tools/whole_build_memory/** +permissions: + contents: read +concurrency: + group: linux-kernel-budget-qualification-${{ github.ref }} + cancel-in-progress: false +jobs: + kernel-budget: + name: Record runner identity and exercise reviewed Linux controls + runs-on: ubuntu-24.04 + timeout-minutes: 10 + steps: + - uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803 # v6 + with: + persist-credentials: false + - name: Read runner identities and compare the reviewed profile + id: profile + shell: bash + run: | + sudo --non-interactive --preserve-env=ImageOS,ImageVersion /usr/bin/python3 -I -S -B tools/installation_provenance/record_linux_runner.py \ + --output "$RUNNER_TEMP/atlas-linux-runner.json" \ + --expected-profile tools/installation_provenance/runner_profile.json \ + --github-output "$GITHUB_OUTPUT" --github-env "$GITHUB_ENV" + - name: Exercise capped, OOM, uncapped and terminal controls + if: steps.profile.outputs.admitted == 'true' + shell: bash + env: + ATLAS_SOURCE_PINS_SHA256: 15e27eea749e5d08f7d41256515b078f256c89fed5c49647c09dc99b99406eae + ATLAS_TERMINAL_READER_SHA256: f35e2a9804afadf514beced484b02777f4ece92a1a33436afb0f10d82bfcdca9 + run: | + /usr/bin/python3 -I -S -B tools/installation_provenance/test_runner_profiles.py + printf '%s %s\n' "$ATLAS_SHA256SUM_SHA256" /usr/bin/sha256sum | /usr/bin/sha256sum --check --strict + printf '%s %s\n' '2177c969114ad070329c3689e98501ea18f99e610189e97c19b98417a79106ee' tools/installation_provenance/run_ci.sh | /usr/bin/sha256sum --check --strict + bash tools/installation_provenance/run_ci.sh + - name: Exercise transient descendants and sibling isolation + if: ${{ always() && steps.profile.outputs.admitted == 'true' }} + shell: bash + run: | + /usr/bin/python3 -I -S -B tools/whole_build_memory/run_host.py \ + --pins-sha256 233f9658ccd015e2c9e7c268723963ed3713dbb2fc4a552f65d2b52a13288cfd \ + --runner-metadata "$RUNNER_TEMP/atlas-linux-runner.json" + - name: Retain runner profile and complete control evidence + if: always() + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7 + with: + name: linux-kernel-budget-${{ github.run_id }}-${{ github.run_attempt }} + path: | + ${{ runner.temp }}/atlas-linux-runner.json + tools/installation_provenance/ci-evidence-*/ + tools/whole_build_memory/ci-evidence-*/ + if-no-files-found: error + retention-days: 14 diff --git a/.github/workflows/memory-budgets.yml b/.github/workflows/memory-budgets.yml index 471753c..c6fe28c 100644 --- a/.github/workflows/memory-budgets.yml +++ b/.github/workflows/memory-budgets.yml @@ -29,7 +29,7 @@ jobs: ruby -rrbconfig -rdigest -e "puts Digest::SHA256.file(RbConfig.ruby).hexdigest" > /results/ruby-sha256.txt ruby -Itest -e "Dir[\"test/*_test.rb\"].sort.each { |file| require File.expand_path(file) }" > /results/portable-fixtures.stdout 2> /results/portable-fixtures.stderr cat /results/portable-fixtures.stdout - ruby -e "text=File.read(ARGV.fetch(0)); abort \"Incomplete portable fixture suite\" unless text.match?(/^112 runs, [0-9]+ assertions, 0 failures, 0 errors, 0 skips$/)" /results/portable-fixtures.stdout + ruby -e "text=File.read(ARGV.fetch(0)); abort \"Incomplete portable fixture suite\" unless text.match?(/^143 runs, [0-9]+ assertions, 0 failures, 0 errors, 0 skips$/)" /results/portable-fixtures.stdout MEMORY_BUDGET_TEST_OUTPUT_PARENT=/tmp ruby test/native_platform_behavior.rb /tmp/native-platform-behavior > /results/native-platform.stdout 2> /results/native-platform.stderr ruby -rjson -e "r=JSON.parse(File.read(ARGV.fetch(0))); abort \"Incomplete native platform fixture cohort\" unless r.fetch(\"passed\") && r.fetch(\"test_count\")==27 && r.fetch(\"cases\").all?{|v| v.fetch(\"passed\")} && r.fetch(\"ELF_link_or_loaded_provider_acceptance\")==false" /tmp/native-platform-behavior/RESULT.json ruby scripts/install_bundle.rb "/tmp/ordinary consumer" > /results/bundle-install.stdout diff --git a/PACKAGE_PINS.json b/PACKAGE_PINS.json index 3c326d8..b3dfbe8 100644 --- a/PACKAGE_PINS.json +++ b/PACKAGE_PINS.json @@ -41,7 +41,7 @@ }, { "file": "docs/0.1.1/native-toolchain.md", - "sha256": "5a0fc398e7cac3cc2beb4e71677383bc722342105cb0268faeaae2d6a7550d33" + "sha256": "6c96c085bf5bb7cadeb45c6d1c37862e076f872e068e195b829c738877f6a987" }, { "file": "docs/0.1.1/prepare-toolchain.md", @@ -49,11 +49,11 @@ }, { "file": "docs/corpus-manifest.json", - "sha256": "837e7c571b25af6e6aceb987268527f02d850f42f982f2e8d4911051cd03a5c8" + "sha256": "d4e6a7e23d6b9795b736a6645c102fb3aa6cdd6785e9a6facc7ed1f33c758000" }, { "file": "docs/corpus.json", - "sha256": "b515d90dfe74db78ad0ae6184f12092c82bd599f6c3f2186a6f0c7ddb4ece4db" + "sha256": "d1f368d6d5bb917f9989308f3cbba4369a7408605f9f0b4e0fb6a60e08cba4d1" }, { "file": "examples/c_allocation_owner.cr", @@ -153,16 +153,20 @@ }, { "file": "scripts/toolchain_profile.rb", - "sha256": "3bf554c7bca8606bf24b3f4b01e41c552b2d454da8b253a164bf73622e117091" + "sha256": "03d437ba7ce3d44bf6ae92b3298afa0db676fc2667b87c34d72686002b1f445f" }, { "file": "skills/crystal-memory-budgets/SKILL.md", - "sha256": "dd8fda6c5e0faa6cd85f5ac2cd2c187955697f041ce98c09999df2a08b5b44ce" + "sha256": "8d5acc89dd11b4dbe54cf85e61f2a4b7b31f7431821c271f773e1a0d0aacd1e1" }, { "file": "skills/crystal-memory-budgets/agents/openai.yaml", "sha256": "7678cc353f933b0dd881b32a8aa6be50a72ddfcbb2fa56e3c9c2ebd152e6784e" }, + { + "file": "skills/crystal-memory-budgets/references/installation-validation.md", + "sha256": "7ec59d18241d7dc4e19b3777f54d8999bced1826f967fe5a509983f68eee5eca" + }, { "file": "spec/fixtures/c/SOURCE_PINS.json", "sha256": "43230cbf98d7e1deaab93e9550a650ded6c545468146c6b62d04cc548faad5bb" diff --git a/docs/0.1.1/native-toolchain.md b/docs/0.1.1/native-toolchain.md index 4ea128a..2a23ce3 100644 --- a/docs/0.1.1/native-toolchain.md +++ b/docs/0.1.1/native-toolchain.md @@ -51,6 +51,16 @@ Apple Ruby can clear `DYLD_LIBRARY_PATH` on exec. `budget.rb` admits the origina The app runner template uses the same helper before and after each build, spec, regression and verifier child. Its report includes the toolchain schema and native manifest SHA. The frozen dependency installer requires schema 3, adding the [Git provider admission](git-provider.md) to these native identities. It restores the approved environment for Minecart version and install children and rechecks native files, Git providers and Minecart bytes after each child. App-owned native link flags, spec helpers and database isolation remain app configuration. A returned native identity keeps an immutable manifest and rechecks its pinned bytes and physical roster before reuse. +## Carry an admitted wrapper's Linux link-search setting + +An ordinary Homebrew Alpha wrapper can assign `LD_RUN_PATH` before its static backend `exec`. The SDK admits that wrapper's hash and backend identity, then calls the backend directly so the prepared allocation-counter `CRYSTAL_PATH` overlay stays active. `ToolchainProfile.wrapper_runtime_environment` restores the wrapper's literal `LD_RUN_PATH` through both `Identity#environment` and `revalidate_selection` at that boundary. It returns this single link-search variable; `run_specs.rb` continues using its prepared overlay and admitted backend. + +Supported source begins with the exact `#!/bin/bash` or `#!/bin/sh` interpreter header and contains one unconditional static backend `exec`, with a leading environment-assignment list, or one unconditional explicit `export` immediately before that `exec`. Whole-line comments and empty lines are supported with ASCII space/tab separation and LF line endings. Other control bytes require a reviewed wrapper form. Raw assignment identifiers use shell assignment syntax; neighboring values are literal. This complete statement roster establishes that the declared setting reaches the backend. The value uses double-quoted, literal absolute colon-separated paths, including paths containing spaces. The actual Homebrew form is `LD_RUN_PATH="${LD_RUN_PATH:+${LD_RUN_PATH}:}/ordinary/lib:/ordinary/opt/openssl@4/lib"`: existing ambient entries keep their position before the literal paths. The reviewed alternate `LD_RUN_PATH="/ordinary/lib${LD_RUN_PATH:+:$LD_RUN_PATH}"` keeps the literal paths first. A literal-only assignment replaces the ambient value. Repeated restoration keeps the same completed search list. + +The helper uses the existing wrapper parser's bounded4096-byte source window and rechecks wrapper/backend hashes before and after interpretation. Restoring a matching runtime assignment requires the complete executable source to fit that window. Matching assignments with dynamic values, unsupported quoting/context, duplicate assignments, relative paths or empty search entries are refused explicitly. Extra statements, control flow, a later `unset`, a quoted command token containing an assignment, and a token printed by `echo` or `printf` each require a separately reviewed wrapper form. Existing wrappers without an `LD_RUN_PATH` assignment and direct-backend profiles keep their prior environment behavior. + +An admitted native overlay is merged afterward. Its explicit nil removals remain authoritative, including the complete loader-variable removals from native manifest schema2 under toolchain profiles2/3. Restoring a wrapper's search setting establishes the direct-backend environment boundary; actual selected ELF libraries, loaded images, ordinary SDK39+39 specs and consumer behavior still need their own hosted qualification. The Ruby fixture controls exercise that boundary without compiling Crystal or loading native consumer libraries. + ## Acceptance evidence Run a named native binary directly first to establish its emitted linker arguments, actual loaded images and normal behavior. Then qualify the ordinary SDK spec entrypoint and ordinary app target under the same pinned native identity. Use `loader_trace: true` in a separately pinned diagnostic manifest to restore `DYLD_PRINT_LIBRARIES=1` at the same boundaries; this changes the manifest and profile identity. diff --git a/docs/corpus-manifest.json b/docs/corpus-manifest.json index 39cfa61..36f8631 100644 --- a/docs/corpus-manifest.json +++ b/docs/corpus-manifest.json @@ -2,12 +2,12 @@ "schema_version": 1, "package_name": "memory_budget", "package_version": "0.1.1", - "distribution_state": "local_candidate", + "distribution_state": "public_review_candidate", "counter_protocol": 1, "source_binding": "Resolve the actual checkout commit/clean state when building a release or projection; this tracked manifest hashes canonical source bytes.", "source_repository": "https://github.com/amberframework/memory_budget", "proposed_repository": "https://github.com/amberframework/memory_budget", - "repository_state": "owner_verified_public_source_readback_pending", + "repository_state": "public_source_verified", "api_basis": { "package_version": "0.1.0", "source_commit": "1a1f89e981b820ff5b375da9b9365be85180190b" @@ -39,7 +39,7 @@ }, { "file": "docs/0.1.1/native-toolchain.md", - "sha256": "5a0fc398e7cac3cc2beb4e71677383bc722342105cb0268faeaae2d6a7550d33" + "sha256": "6c96c085bf5bb7cadeb45c6d1c37862e076f872e068e195b829c738877f6a987" }, { "file": "docs/0.1.1/prepare-toolchain.md", @@ -47,7 +47,7 @@ }, { "file": "docs/corpus.json", - "sha256": "b515d90dfe74db78ad0ae6184f12092c82bd599f6c3f2186a6f0c7ddb4ece4db" + "sha256": "d1f368d6d5bb917f9989308f3cbba4369a7408605f9f0b4e0fb6a60e08cba4d1" }, { "file": "examples/support/memory_budget_sample_record.cr", @@ -55,11 +55,15 @@ }, { "file": "skills/crystal-memory-budgets/SKILL.md", - "sha256": "dd8fda6c5e0faa6cd85f5ac2cd2c187955697f041ce98c09999df2a08b5b44ce" + "sha256": "8d5acc89dd11b4dbe54cf85e61f2a4b7b31f7431821c271f773e1a0d0aacd1e1" }, { "file": "skills/crystal-memory-budgets/agents/openai.yaml", "sha256": "7678cc353f933b0dd881b32a8aa6be50a72ddfcbb2fa56e3c9c2ebd152e6784e" + }, + { + "file": "skills/crystal-memory-budgets/references/installation-validation.md", + "sha256": "7ec59d18241d7dc4e19b3777f54d8999bced1826f967fe5a509983f68eee5eca" } ], "list_of_api_sources": [ @@ -89,7 +93,7 @@ }, { "file": "scripts/toolchain_profile.rb", - "sha256": "3bf554c7bca8606bf24b3f4b01e41c552b2d454da8b253a164bf73622e117091" + "sha256": "03d437ba7ce3d44bf6ae92b3298afa0db676fc2667b87c34d72686002b1f445f" }, { "file": "scripts/budget.rb", diff --git a/docs/corpus.json b/docs/corpus.json index aa72693..d938b8e 100644 --- a/docs/corpus.json +++ b/docs/corpus.json @@ -2,7 +2,7 @@ "schema_version": 1, "package_name": "memory_budget", "package_version": "0.1.1", - "distribution_state": "local_candidate", + "distribution_state": "public_review_candidate", "counter_protocol": 1, "api_basis": { "package_version": "0.1.0", @@ -10,7 +10,7 @@ }, "source_repository": "https://github.com/amberframework/memory_budget", "proposed_repository": "https://github.com/amberframework/memory_budget", - "repository_state": "owner_verified_public_source_readback_pending", + "repository_state": "public_source_verified", "website_prefix": "docs/v2/guides/memory-budgets", "public_prefix": "public/memory-budget-docs/0.1.1", "skill_directory": "skills/crystal-memory-budgets", diff --git a/scripts/toolchain_profile.rb b/scripts/toolchain_profile.rb index 41b628b..bec08b7 100644 --- a/scripts/toolchain_profile.rb +++ b/scripts/toolchain_profile.rb @@ -32,7 +32,9 @@ def environment {"MEMORY_BUDGET_COMPILER" => entrypoint_path, "MEMORY_BUDGET_TOOLCHAIN_LOCK" => profile_path, "MEMORY_BUDGET_TOOLCHAIN_PROFILE_SHA256" => @profile_sha256, "MEMORY_BUDGET_COMPILER_ENTRYPOINT" => entrypoint_path, - "MEMORY_BUDGET_STDLIB" => stdlib_root}.merge(ToolchainProfile.native_environment(profile)).merge(ToolchainProfile.git_environment(profile)) + "MEMORY_BUDGET_STDLIB" => stdlib_root} + .merge(ToolchainProfile.wrapper_runtime_environment(entrypoint_path, compiler_path, profile)) + .merge(ToolchainProfile.native_environment(profile)).merge(ToolchainProfile.git_environment(profile)) end def source_commit(require_git_provider: false) @@ -83,6 +85,14 @@ def executable(explicit_path, command, description) def compiler_backend(entrypoint) source = File.binread(entrypoint, 4096) return entrypoint unless source.start_with?("#!") + has_runtime_assignment = source.lines.any? { |line| !line.sub(/\A[ \t]+/, "").start_with?("#") && line.match?(/\bLD_RUN_PATH[ \t]*=/) } + if has_runtime_assignment + raise AdmissionError, "Wrapper runtime source exceeds the complete 4096-byte admission window" unless File.size(entrypoint) <= 4096 + raise AdmissionError, "Unsupported wrapper LD_RUN_PATH assignment; unsupported shell control byte" if source.match?(/[\x00-\x08\x0b-\x1f\x7f]/) + unless ["#!/bin/bash", "#!/bin/sh"].include?(source.lines.first.delete_suffix("\n")) + raise AdmissionError, "Unsupported wrapper LD_RUN_PATH assignment; use the reviewed static shell interpreter" + end + end commands = source.lines.reject { |line| line.lstrip.start_with?("#") }.map do |line| tokens = Shellwords.split(line) position = tokens.index("exec") @@ -105,6 +115,80 @@ def stdlib_sha256(root) Digest::SHA256.hexdigest(paths.map { |path| "#{Digest::SHA256.file(path).hexdigest} #{path.delete_prefix(root + "/")}\n" }.join) end + # A direct backend keeps the prepared counter overlay. Restore only the + # hash-admitted wrapper's literal Linux link-search setting at this boundary. + def wrapper_runtime_environment(entrypoint, backend, profile, environment = ENV) + raise AdmissionError, "Compiler SHA-256 mismatch" unless Digest::SHA256.file(backend).hexdigest == profile.fetch("compiler_sha256") + return {} if entrypoint == backend + expected = profile["wrapper_sha256"] + raise AdmissionError, "Selected script wrapper requires wrapper_sha256" unless expected + raise AdmissionError, "wrapper SHA-256 mismatch" unless Digest::SHA256.file(entrypoint).hexdigest == expected + source = File.binread(entrypoint, 4096) + unless Digest::SHA256.file(entrypoint).hexdigest == expected && compiler_backend(entrypoint) == backend + raise AdmissionError, "Selected wrapper/backend changed during runtime admission" + end + lines = source.lines.map { |line| line.delete_suffix("\n").sub(/\A[ \t]+/, "").sub(/[ \t]+\z/, "") }.reject { |line| line.empty? || line.start_with?("#") } + assignments = lines.flat_map { |line| line.scan(/\bLD_RUN_PATH[ \t]*=/) } + result = {} + unless assignments.empty? + raise AdmissionError, "Wrapper runtime source exceeds the complete 4096-byte admission window" unless File.size(entrypoint) <= 4096 + raise AdmissionError, "Unsupported wrapper LD_RUN_PATH assignment; unsupported shell control byte" if source.match?(/[\x00-\x08\x0b-\x1f\x7f]/) + unless ["#!/bin/bash", "#!/bin/sh"].include?(source.lines.first.delete_suffix("\n")) + raise AdmissionError, "Unsupported wrapper LD_RUN_PATH assignment; use the reviewed static shell interpreter" + end + raise AdmissionError, "Unsupported wrapper LD_RUN_PATH assignment; one literal assignment is required" unless assignments.size == 1 + # Check the complete statement roster before Shellwords can erase the + # distinction between a shell assignment and a quoted command name. + exec_statement = lines.last && lines.last.match(/\A(?:(.+?)[ \t]+)?exec[ \t]+"([^\x00"\r\n\$`\\]+)"[ \t]+"\$@"\z/) + if exec_statement && !(exec_statement[2].start_with?("/") && File.realpath(exec_statement[2]) == backend) + exec_statement = nil + end + raw_assignments = [] + raw_assignments << exec_statement[1] if exec_statement && exec_statement[1] + if lines.size == 2 && lines.first.start_with?("export ", "export\t") + raw_assignments << lines.first.sub(/\Aexport[ \t]+/, "") + end + token = /[A-Za-z_][A-Za-z0-9_]*=(?:"[^"\r\n]*"|'[^'\r\n]*'|[^ \t"'\\`;$|&(){}<>]+)/ + supported_roster = exec_statement && (lines.size == 1 || (lines.size == 2 && raw_assignments.size >= 1 && lines.first.match?(/\Aexport[ \t]+/))) + valid_assignments = raw_assignments.all? { |raw| raw.match?(/\A#{token}(?:[ \t]+#{token})*\z/) } + unless supported_roster && !raw_assignments.empty? && valid_assignments + raise AdmissionError, "Unsupported wrapper LD_RUN_PATH assignment; use the leading exec environment or an explicit export" + end + pairs = raw_assignments.flat_map { |raw| raw.scan(/([A-Za-z_][A-Za-z0-9_]*)=("[^"\r\n]*"|'[^'\r\n]*'|[^ \t"'\\`;$|&(){}<>]+)/) } + unless pairs.count { |key, _value| key == "LD_RUN_PATH" } == 1 && pairs.all? { |key, value| key == "LD_RUN_PATH" || !value.match?(/[\x00\r\n\$`\\]/) } + raise AdmissionError, "Unsupported wrapper LD_RUN_PATH assignment; static assignment values are required" + end + line = lines.find { |candidate| candidate.match?(/\bLD_RUN_PATH[ \t]*=/) } + match = line.match(/(?:\A|[ \t])LD_RUN_PATH="([^"\r\n]*)"(?=[ \t]|\z)/) + raise AdmissionError, "Unsupported wrapper LD_RUN_PATH assignment; use the reviewed double-quoted literal form" unless match + value = match[1] + prefix = '${LD_RUN_PATH:+${LD_RUN_PATH}:}' + suffix = '${LD_RUN_PATH:+:$LD_RUN_PATH}' + order = value.start_with?(prefix) ? :ambient_first : (value.end_with?(suffix) ? :literal_first : :literal_only) + base = order == :ambient_first ? value.delete_prefix(prefix) : (order == :literal_first ? value.delete_suffix(suffix) : value) + paths = base.split(File::PATH_SEPARATOR, -1) + unless !paths.empty? && paths.all? { |path| path.start_with?("/") && !path.match?(/[\x00\r\n\$`"\\]/) && File.expand_path(path) == path } + raise AdmissionError, "Unsupported wrapper LD_RUN_PATH assignment; literal absolute search paths are required" + end + ambient = environment["LD_RUN_PATH"] + ambient = nil if ambient == "" + restored = if order == :ambient_first + ambient && ambient != base && !ambient.end_with?(File::PATH_SEPARATOR + base) ? ambient + File::PATH_SEPARATOR + base : (ambient || base) + elsif order == :literal_first + ambient && ambient != base && !ambient.start_with?(base + File::PATH_SEPARATOR) ? base + File::PATH_SEPARATOR + ambient : (ambient || base) + else + base + end + result["LD_RUN_PATH"] = restored + end + unless Digest::SHA256.file(entrypoint).hexdigest == expected && Digest::SHA256.file(backend).hexdigest == profile.fetch("compiler_sha256") + raise AdmissionError, "Selected wrapper/backend changed during runtime admission" + end + result + rescue ArgumentError => error + raise AdmissionError, "Invalid wrapper runtime assignment: #{error.message}" + end + def read_profile(path) profile = JSON.parse(File.read(path)) raise AdmissionError, "Invalid toolchain profile #{path}" unless profile.is_a?(Hash) && [1, 2, 3].include?(profile["schema_version"]) @@ -188,7 +272,7 @@ def revalidate_selection unless ENV["MEMORY_BUDGET_COMPILER_SHA256"] == profile.fetch("compiler_sha256") && ENV["MEMORY_BUDGET_STDLIB_SHA256"] == profile.fetch("stdlib_sha256") raise AdmissionError, "Selected compiler/stdlib profile differs" end - native_environment(profile).merge(git_environment(profile)) + wrapper_runtime_environment(entrypoint, backend, profile).merge(native_environment(profile)).merge(git_environment(profile)) rescue Errno::ENOENT, Errno::EACCES, JSON::ParserError => error raise AdmissionError, "Selected toolchain admission failed: #{error.message}" end diff --git a/skills/crystal-memory-budgets/SKILL.md b/skills/crystal-memory-budgets/SKILL.md index 54d20e4..78199ad 100644 --- a/skills/crystal-memory-budgets/SKILL.md +++ b/skills/crystal-memory-budgets/SKILL.md @@ -3,23 +3,26 @@ name: crystal-memory-budgets description: Add, calibrate, and diagnose memory expectations in Crystal and Amber specs and CI using the versioned MemoryBudget contract. metadata: version: "0.1.1" - distribution: "local-candidate" - repository-state: "pending-owner-and-public-readback" + distribution: "public-review-candidate" + repository-state: "public-source-verified" + revision: "draft-4" --- # Crystal memory budgets Turn one concrete operation and its memory limit into a useful executable expectation, then prove normal behavior and an actual over-budget failure. -Read the matching source corpus at `docs/0.1.1/` in the SDK checkout, or the version/source-attributed Amber memory-budget pages supplied by the docs tools. The manifest identifies the exact API/example bytes. This repository package is a local candidate; the public repository owner/release identity, public installation and independent installed-agent qualification require their own receipts. +Read the matching source corpus at `docs/0.1.1/` in the SDK checkout, or the version/source-attributed Amber memory-budget pages supplied by the docs tools. The manifest identifies the exact API/example bytes. Public review source is available in [amberframework/memory_budget](https://github.com/amberframework/memory_budget). Select the consumer's exact release or reviewed commit and verify its manifests. Supported releases, each installed platform/profile, and independent installed-agent qualification have separate acceptance receipts. + +For package installation or a fresh-device rollout, read [installation validation](references/installation-validation.md) before selecting the acceptance workload. Inspect the project's installed toolchain/profile, existing kit, spec helper, policy, hooks and dependency lock. Preserve the app's current setup. Choose the owner/window: synchronous fiber traffic, a joined process operation, a live SQLite connection cache, a whole-process lifetime metric, or an exact compiler/build workload. -For a consumer with native libraries, read `docs/0.1.1/native-toolchain.md`. Use a schema-2 toolchain profile with its required native manifest hash and explicit lock. Preserve the admitted original wrapper when the SDK delegates to its backend. Verify the actual emitted and loaded library closure, then the ordinary SDK/app Ruby entrypoints; those are separate from static file/path admission. Review new native bytes, links, search order or diagnostic loader tracing as a new manifest/profile identity. +For a consumer with native libraries, read `docs/0.1.1/native-toolchain.md`. Use a schema-2 toolchain profile with its required native manifest hash and explicit lock. Frozen dependency installation additionally uses the schema-3 Git provider described in `docs/0.1.1/git-provider.md`. Preserve the admitted original wrapper when the SDK delegates to its backend. Verify the actual emitted and loaded library closure, then the ordinary SDK/app Ruby entrypoints; those are separate from static file/path admission. Review new native bytes, links, search order or diagnostic loader tracing as a new manifest/profile identity. A schema-1 installed SDK example retains its narrower compiler/spec/tutorial scope. Use a real functional assertion. Construct inputs and policy outside the measurement window. Keep app policies in `performance/memory_budget.json`; keep package metadata in `shard.yml`. Calibrate repeated cold/warm behavior and explicit nonempty input counts. -The candidate Amber CLI provides `amber performance init --kind=web|native` for apps without kit collisions and `amber performance check --self-test` for the installed kit. Verify the installed version first. Native starter logic and complete native user journeys have distinct scopes. +Read the installed Amber command help before choosing a CLI path. Candidate builds with these commands offer `amber performance init --kind=web|native` for apps without kit collisions and `amber performance check --self-test` for the installed kit. Use the versioned SDK bundle entrypoints for other supported installations. Native starter logic and complete native user journeys have distinct scopes. Run the same named program normally and with a real allocation regression or tight limit. Require raw typed evidence, complete scenario/metric/capability rosters, source/dependency/policy/executable hashes and admitted counter protocol. Independently verify numerical limits. Missing evidence is failed acceptance. diff --git a/skills/crystal-memory-budgets/references/installation-validation.md b/skills/crystal-memory-budgets/references/installation-validation.md new file mode 100644 index 0000000..afcc214 --- /dev/null +++ b/skills/crystal-memory-budgets/references/installation-validation.md @@ -0,0 +1,17 @@ +# Validate the installed budget tooling + +Use the exact released docs and checksum-bearing source/toolchain manifests selected by the consumer. Record a draft source identity as a draft. Read the actual installed command help and the project package entrypoint before choosing the workload. + +Treat these as separate acceptance results: + +1. **Dependency resolution.** Run the supported writer and frozen installer with the consumer's constraints. Retain the generated root lock, source checksums, installed membership, and package/script ordering. Inspect any nested lock the build creates. Existing DB 0.14 and DB 0.15 compatibility results retain their own exact closures. +2. **Executable construction.** Locate the declared target, postinstall behavior, and installed executable. If a CLI conditionally includes database adapters at compile time, prove the requested adapter is available when that compilation occurs. A consumer build after dependency installation and an executable package with explicit adapter dependencies are distinct supported designs; select the design the library actually implements. +3. **Installed behavior.** Run the produced executable from its installed location with an owned fresh HOME and cache. Exercise the intended operation against a dedicated test database and assert actual schema/data/history, along with the command result. Record the executable hash and its actual tool invocations. A linked program also needs a successful loader/runtime check; on a failed Linux load, retain the generated ELF after its writers retire and inspect its actual dependency/search metadata. +4. **Budget behavior.** Run the named operation with its functional assertions and full metric/scenario coverage. Exercise a real over-budget neighbor and restore the passing workload. Retain raw evidence, limits, metric names, scope, platform/profile, source/lock/binary hashes, and repetition count. +5. **Distribution.** Repeat the supported installation on the required fresh account and other device. Report local, CI, public-source, public-release, and installed-device evidence with their own receipts. A freshly source-built compiler receives its own observed hash and qualification; reuse a prior compiler profile only when its admitted identity matches. + +For API lookup, load the real consumer definitions entry. A launcher can defer the CLI and produce a different API context. Resolve compiler search paths before a child process changes directories; test the actual library layer as well as the stdlib layer when custom or relative paths are supported. + +For an ordinary Homebrew Linux wrapper, verify both the wrapper-built consumer and the SDK's direct-backend spec entrypoint. The wrapper can supply a literal `LD_RUN_PATH` that a direct backend needs when linking its generated executable. The SDK's hash-admitted ToolchainProfile helper restores this setting while `run_specs.rb` keeps the prepared counter-overlay `CRYSTAL_PATH`. Admit the complete unconditional assignment-list/exec or export/exec statement roster and the raw shell assignment identifiers. Preserve ambient-prefix or reviewed ambient-append ordering and exercise repeated restoration. The authoritative native overlay merges afterward, including its explicit loader-variable removals. An unsupported matching wrapper assignment fails admission and needs a reviewed supported wrapper/profile. Keep wrapper crypto success, direct-backend SDK specs, actual generated ELF/loader evidence, and full native/whole-build acceptance as separate results. + +When an enclosing run fails after individual commands succeed, preserve both results and their original timestamps. A later current-parity check earns its own receipt. Keep the release and project acceptance gate open until its entire required workload passes. diff --git a/test/wrapper_runtime_environment_test.rb b/test/wrapper_runtime_environment_test.rb new file mode 100644 index 0000000..b32e318 --- /dev/null +++ b/test/wrapper_runtime_environment_test.rb @@ -0,0 +1,350 @@ +# frozen_string_literal: true +require_relative "portable_toolchain_test" +require_relative "../scripts/toolchain_profile" + +class WrapperRuntimeEnvironmentTest < PortableToolchainTest + def self.runnable_methods + instance_methods(false).grep(/^test_/).map(&:to_s) + end + + def setup + super + @environment["LD_RUN_PATH"] = nil + @environment["MEMORY_BUDGET_NATIVE_COMPONENT_LOCK"] = nil + write_executable(@backend, <<~RUBY) + #!#{RbConfig.ruby} + require "json" + File.open(ENV.fetch("FIXTURE_COMPILER_LOG"), "a") { |file| file.puts JSON.generate(ARGV) } + if ARGV == ["env", "CRYSTAL_PATH"] + puts ENV.fetch("FIXTURE_STDLIB") + else + puts JSON.generate({"arguments" => ARGV, "ld_run_path" => ENV["LD_RUN_PATH"], + "stdlib" => ENV.fetch("CRYSTAL_PATH"), "workers" => ENV.fetch("CRYSTAL_WORKERS"), + "allocation" => ENV.fetch("MEMORY_BUDGET_REQUIRE_ALLOCATION")}) + end + RUBY + @profile["compiler_sha256"] = hash(@backend) + write_profile("normal", @profile) + end + + def base_paths + [File.join(@prefix, "lib"), File.join(@prefix, "opt", "openssl@4", "lib")].join(File::PATH_SEPARATOR) + end + + def runtime_wrapper(value, extra = "") + write_executable(@wrapper, "#!/bin/bash\nCRYSTAL_PATH=\"lib:#{@stdlib}\" LD_RUN_PATH=\"#{value}\" #{extra}exec \"#{@backend}\" \"$@\"\n") + @profile["wrapper_sha256"] = hash(@wrapper) + write_profile("normal", @profile) + end + + def restored(environment = {}) + MemoryBudget::ToolchainProfile.wrapper_runtime_environment(File.realpath(@wrapper), File.realpath(@backend), @profile, environment) + end + + def with_fixture_environment + previous = ENV.to_h + @environment.each { |key, value| value.nil? ? ENV.delete(key) : ENV[key] = value } + yield + ensure + ENV.replace(previous) + end + + def test_actual_homebrew_ambient_prefix_form_reaches_backend_and_keeps_overlay + relocate_prefix("ordinary prefix with spaces") + runtime_wrapper('${LD_RUN_PATH:+${LD_RUN_PATH}:}' + base_paths) + @environment["LD_RUN_PATH"] = "/ambient with spaces/lib" + output, errors, status = bootstrap("spec", "--", "--no-color") + assert status.success?, output + errors + data = JSON.parse(output) + assert_equal "/ambient with spaces/lib:" + base_paths, data.fetch("ld_run_path") + assert_equal "lib:" + File.join(@environment.fetch("CRYSTAL_CACHE_DIR"), "budget-stdlib"), data.fetch("stdlib") + assert_equal "1", data.fetch("allocation") + assert File.file?(File.join(@environment.fetch("CRYSTAL_CACHE_DIR"), "budget-stdlib", "fiber", "allocation_tally.cr")) + assert_equal ["spec", "--threads", "1", "--", "--no-color"], data.fetch("arguments") + end + + def test_optional_exact_ambient_append_suffix_preserves_order + runtime_wrapper(base_paths + '${LD_RUN_PATH:+:$LD_RUN_PATH}') + @environment["LD_RUN_PATH"] = "/ambient/lib" + output, errors, status = bootstrap("build", "fixture with spaces.cr") + assert status.success?, output + errors + assert_equal base_paths + ":/ambient/lib", JSON.parse(output).fetch("ld_run_path") + end + + def test_literal_only_and_empty_ambient_restore_the_static_roster + runtime_wrapper(base_paths) + assert_equal({"LD_RUN_PATH" => base_paths}, restored("LD_RUN_PATH" => "/ambient/lib")) + runtime_wrapper('${LD_RUN_PATH:+${LD_RUN_PATH}:}' + base_paths) + [nil, ""].each { |value| assert_equal({"LD_RUN_PATH" => base_paths}, restored("LD_RUN_PATH" => value)) } + end + + def test_each_supported_order_is_idempotent_across_repeated_restoration + ['${LD_RUN_PATH:+${LD_RUN_PATH}:}' + base_paths, base_paths + '${LD_RUN_PATH:+:$LD_RUN_PATH}', base_paths].each do |value| + runtime_wrapper(value) + first = restored("LD_RUN_PATH" => "/ambient/lib") + assert_equal first, restored(first) + assert_equal first, restored(restored(first)) + end + end + + def test_identity_environment_revalidates_and_restores_only_runtime_link_search + runtime_wrapper('${LD_RUN_PATH:+${LD_RUN_PATH}:}' + base_paths) + @environment["LD_RUN_PATH"] = "/ambient/lib" + with_fixture_environment do + identity = MemoryBudget::ToolchainProfile.resolve(@package) + first = identity.environment + refute first.key?("CRYSTAL_PATH") + assert_equal "/ambient/lib:" + base_paths, first.fetch("LD_RUN_PATH") + ENV.update(first) + assert_equal first, identity.environment + end + end + + def test_revalidate_selection_restores_missing_runtime_link_search + runtime_wrapper('${LD_RUN_PATH:+${LD_RUN_PATH}:}' + base_paths) + with_fixture_environment do + identity = MemoryBudget::ToolchainProfile.resolve(@package) + ENV.update(identity.environment) + ENV["MEMORY_BUDGET_COMPILER"] = identity.compiler_path + ENV["MEMORY_BUDGET_COMPILER_SHA256"] = @profile.fetch("compiler_sha256") + ENV["MEMORY_BUDGET_STDLIB_SHA256"] = @profile.fetch("stdlib_sha256") + ENV.delete("LD_RUN_PATH") + result = MemoryBudget::ToolchainProfile.revalidate_selection + assert_equal({"LD_RUN_PATH" => base_paths}, result) + refute result.key?("CRYSTAL_PATH") + ENV.update(result) + assert_equal result, MemoryBudget::ToolchainProfile.revalidate_selection + end + end + + def test_changed_wrapper_is_rejected_before_runtime_source_is_parsed + runtime_wrapper(base_paths) + @profile["wrapper_sha256"] = "0" * 64 + error = assert_raises(MemoryBudget::ToolchainProfile::AdmissionError) { restored } + assert_includes error.message, "wrapper SHA-256 mismatch" + end + + def test_changed_backend_is_rejected_before_runtime_source_is_parsed + runtime_wrapper(base_paths) + @profile["compiler_sha256"] = "0" * 64 + error = assert_raises(MemoryBudget::ToolchainProfile::AdmissionError) { restored } + assert_includes error.message, "Compiler SHA-256 mismatch" + end + + def test_changed_runtime_wrapper_is_rejected_at_the_ruby_boundary + runtime_wrapper('${LD_RUN_PATH:+${LD_RUN_PATH}:}' + base_paths) + hook = File.join(@temporary, "changed-runtime-wrapper.rb") + File.write(hook, <<~RUBY) + if $PROGRAM_NAME.end_with?("/run_specs.rb") + File.open(ENV.fetch("MEMORY_BUDGET_COMPILER_ENTRYPOINT"), "a") { |file| file.puts "# changed runtime wrapper" } + end + RUBY + @environment["RUBYOPT"] = "-r#{Shellwords.escape(hook)}" + assert_rejected("Selected wrapper SHA-256 mismatch", "spec") + assert_equal [["env", "CRYSTAL_PATH"]], File.readlines(@compiler_log).map { |line| JSON.parse(line) } + end + + def test_dynamic_or_malformed_matching_assignments_are_explicitly_rejected + ['$HOME/lib', '$(printf /dynamic/lib)', '`printf /dynamic/lib`', '/literal/lib:$OTHER', + '/literal/lib:', 'relative/lib', '/literal/../different/lib', + '${LD_RUN_PATH:+${LD_RUN_PATH}:}/literal/lib${LD_RUN_PATH:+:$LD_RUN_PATH}'].each do |value| + runtime_wrapper(value) + error = assert_raises(MemoryBudget::ToolchainProfile::AdmissionError) { restored } + assert_includes error.message, "Unsupported wrapper LD_RUN_PATH assignment", value + end + end + + def test_duplicate_assignments_are_explicitly_rejected + runtime_wrapper(base_paths, 'LD_RUN_PATH="/duplicate/lib" ') + error = assert_raises(MemoryBudget::ToolchainProfile::AdmissionError) { restored } + assert_includes error.message, "one literal assignment" + end + + def test_explicit_export_assignment_reaches_the_admitted_backend + write_executable(@wrapper, "#!/bin/sh\nexport LD_RUN_PATH=\"#{base_paths}\"\nexec \"#{@backend}\" \"$@\"\n") + @profile["wrapper_sha256"] = hash(@wrapper) + write_profile("normal", @profile) + output, errors, status = bootstrap("spec") + assert status.success?, output + errors + assert_equal base_paths, JSON.parse(output).fetch("ld_run_path") + end + + def test_echo_and_printf_arguments_are_rejected_in_the_full_bootstrap + ["echo LD_RUN_PATH=\"#{base_paths}\"", "printf '%s' LD_RUN_PATH=\"#{base_paths}\""].each do |statement| + write_executable(@wrapper, "#!/bin/sh\n#{statement}\nexec \"#{@backend}\" \"$@\"\n") + @profile["wrapper_sha256"] = hash(@wrapper) + write_profile("normal", @profile) + File.delete(@compiler_log) if File.exist?(@compiler_log) + assert_rejected("leading exec environment or an explicit export", "spec") + assert_equal [["env", "CRYSTAL_PATH"]], File.readlines(@compiler_log).map { |line| JSON.parse(line) } + end + end + + def test_export_after_the_static_exec_is_rejected + write_executable(@wrapper, "#!/bin/sh\nexec \"#{@backend}\" \"$@\"\nexport LD_RUN_PATH=\"#{base_paths}\"\n") + @profile["wrapper_sha256"] = hash(@wrapper) + write_profile("normal", @profile) + assert_rejected("leading exec environment or an explicit export", "spec") + end + + def test_unquoted_and_spaced_assignment_forms_are_explicitly_rejected + ['LD_RUN_PATH=/literal/lib', 'LD_RUN_PATH ="/literal/lib"', "LD_RUN_PATH='/literal/lib'"].each do |assignment| + write_executable(@wrapper, "#!/bin/sh\n#{assignment} exec \"#{@backend}\" \"$@\"\n") + @profile["wrapper_sha256"] = hash(@wrapper) + error = assert_raises(MemoryBudget::ToolchainProfile::AdmissionError) { restored } + assert_includes error.message, "Unsupported wrapper LD_RUN_PATH assignment" + end + end + + def test_existing_wrapper_without_runtime_assignment_preserves_ambient_behavior + assert_equal({}, restored("LD_RUN_PATH" => "/ambient/lib")) + @environment["LD_RUN_PATH"] = "/ambient/lib" + output, errors, status = bootstrap("--version") + assert status.success?, output + errors + assert_equal "/ambient/lib", JSON.parse(output).fetch("ld_run_path") + end + + def test_direct_backend_keeps_its_existing_environment_boundary + assert_equal({}, MemoryBudget::ToolchainProfile.wrapper_runtime_environment(File.realpath(@backend), File.realpath(@backend), @profile, "LD_RUN_PATH" => "/ambient/lib")) + end + + def native_overlay_profile(toolchain_schema) + directory = File.join(File.realpath(@temporary), "native library fixture") + FileUtils.mkdir_p(directory) + family = MemoryBudget::NativeEnvironment::LOADER_FAMILIES.fetch(MemoryBudget::NativeEnvironment.platform.fetch("sysname")) + variables = MemoryBudget::NativeEnvironment.environment_variables(2, family) + manifest = {"schema_version" => 2, "loader_family" => family, "profile" => "authoritative-runtime-fixture", + "platform" => MemoryBudget::NativeEnvironment.platform, + "directories" => [MemoryBudget::NativeEnvironment.snapshot_directory(directory)], "files" => [], + "environment" => variables.each_with_object({}) { |key, values| values[key] = [directory] }, "loader_trace" => false} + lock = File.join(@temporary, "native-runtime.json") + File.write(lock, JSON.pretty_generate(manifest) + "\n") + @environment["MEMORY_BUDGET_NATIVE_COMPONENT_LOCK"] = lock + write_profile("normal", @profile.merge("schema_version" => 2, "native_component_manifest_sha256" => hash(lock))) + prepare_dependency_git_profile if toolchain_schema == 3 + end + + def assert_native_overlay_authority(schema) + runtime_wrapper('${LD_RUN_PATH:+${LD_RUN_PATH}:}' + base_paths) + native_overlay_profile(schema) + @environment["LD_RUN_PATH"] = "/ambient/lib" + output, errors, status = bootstrap("--version") + assert status.success?, output + errors + assert_nil JSON.parse(output).fetch("ld_run_path") + with_fixture_environment do + identity = MemoryBudget::ToolchainProfile.resolve(@package) + assert_nil identity.environment.fetch("LD_RUN_PATH") + end + end + + def test_schema_two_native_overlay_explicit_removal_is_authoritative + assert_native_overlay_authority(2) + end + + def test_schema_three_native_overlay_explicit_removal_is_authoritative + assert_native_overlay_authority(3) + end + + def admit_wrapper_source(statements) + write_executable(@wrapper, "#!/bin/bash\n" + statements) + @profile["wrapper_sha256"] = hash(@wrapper) + write_profile("normal", @profile) + end + + def test_export_followed_by_unset_is_rejected_in_the_full_bootstrap + admit_wrapper_source("export LD_RUN_PATH=\"#{base_paths}\"\nunset LD_RUN_PATH\nexec \"#{@backend}\" \"$@\"\n") + assert_rejected("leading exec environment or an explicit export", "spec") + assert_equal [["env", "CRYSTAL_PATH"]], File.readlines(@compiler_log).map { |line| JSON.parse(line) } + end + + def test_conditional_export_is_rejected_in_the_full_bootstrap + admit_wrapper_source("if false; then\n export LD_RUN_PATH=\"#{base_paths}\"\nfi\nexec \"#{@backend}\" \"$@\"\n") + assert_rejected("leading exec environment or an explicit export", "spec") + assert_equal [["env", "CRYSTAL_PATH"]], File.readlines(@compiler_log).map { |line| JSON.parse(line) } + end + + def test_quoted_assignment_identifiers_are_rejected_before_normalization + ["'OTHER=value'", '"OTHER=value"', 'OTHER"="value'].each do |prefix| + admit_wrapper_source("#{prefix} LD_RUN_PATH=\"#{base_paths}\" exec \"#{@backend}\" \"$@\"\n") + assert_rejected("leading exec environment or an explicit export", "spec") + end + end + + def test_extra_statements_and_shell_control_operators_require_review + ["true\n", ":\n", "false || ", "if true; then "].each do |prefix| + admit_wrapper_source(prefix + "LD_RUN_PATH=\"#{base_paths}\" exec \"#{@backend}\" \"$@\"\n") + error = assert_raises(MemoryBudget::ToolchainProfile::AdmissionError) { restored } + assert_includes error.message, "leading exec environment or an explicit export" + end + end + + def test_actual_raw_assignment_identifiers_and_literal_values_are_supported + ['OTHER=value', 'OTHER="value with spaces"', "OTHER='value with spaces'"].each do |prefix| + admit_wrapper_source("#{prefix} LD_RUN_PATH=\"#{base_paths}\" exec \"#{@backend}\" \"$@\"\n") + output, errors, status = bootstrap("spec") + assert status.success?, output + errors + assert_equal base_paths, JSON.parse(output).fetch("ld_run_path") + end + end + + def test_unconditional_export_and_static_exec_assignments_preserve_the_overlay + admit_wrapper_source("export LD_RUN_PATH=\"${LD_RUN_PATH:+${LD_RUN_PATH}:}#{base_paths}\"\nCRYSTAL_PATH=\"lib:#{@stdlib}\" exec \"#{@backend}\" \"$@\"\n") + @environment["LD_RUN_PATH"] = "/ambient/lib" + output, errors, status = bootstrap("spec") + assert status.success?, output + errors + data = JSON.parse(output) + assert_equal "/ambient/lib:" + base_paths, data.fetch("ld_run_path") + assert_equal "lib:" + File.join(@environment.fetch("CRYSTAL_CACHE_DIR"), "budget-stdlib"), data.fetch("stdlib") + end + + def test_dynamic_neighbor_assignments_require_review + ['OTHER="$HOME"', 'OTHER="$(printf dynamic)"', 'OTHER="`printf dynamic`"'].each do |prefix| + admit_wrapper_source("#{prefix} LD_RUN_PATH=\"#{base_paths}\" exec \"#{@backend}\" \"$@\"\n") + error = assert_raises(MemoryBudget::ToolchainProfile::AdmissionError) { restored } + assert_includes error.message, "static assignment values" + end + end + + def test_comments_and_empty_lines_keep_the_unconditional_statement_roster + admit_wrapper_source("# ordinary wrapper comment\n\nexport LD_RUN_PATH=\"#{base_paths}\"\n# selected backend\nexec \"#{@backend}\" \"$@\"\n") + assert_equal({"LD_RUN_PATH" => base_paths}, restored) + end + + def test_complete_runtime_source_is_bounded_at_4096_bytes + runtime_wrapper(base_paths) + source = File.binread(@wrapper) + source += "#" + "x" * (4096 - source.bytesize - 2) + "\n" + write_executable(@wrapper, source) + @profile["wrapper_sha256"] = hash(@wrapper) + assert_equal 4096, File.size(@wrapper) + assert_equal({"LD_RUN_PATH" => base_paths}, restored) + File.open(@wrapper, "a") { |file| file.write("#") } + @profile["wrapper_sha256"] = hash(@wrapper) + assert_equal 4097, File.size(@wrapper) + error = assert_raises(MemoryBudget::ToolchainProfile::AdmissionError) { restored } + assert_includes error.message, "complete 4096-byte admission window" + end + + def test_vertical_whitespace_and_other_control_bytes_require_review + ["\v", "\f", "\r", "\0", "\x7f"].each do |control| + admit_wrapper_source(control + "CRYSTAL_PATH=\"lib:#{@stdlib}\" LD_RUN_PATH=\"#{base_paths}\" exec \"#{@backend}\" \"$@\"\n") + assert_rejected("unsupported shell control byte", "spec") + end + end + + def test_ascii_space_tab_and_lf_keep_supported_shell_meaning + admit_wrapper_source(" \tCRYSTAL_PATH=\"lib:#{@stdlib}\"\tLD_RUN_PATH=\"#{base_paths}\" \texec \"#{@backend}\" \t\"$@\" \t\n") + output, errors, status = bootstrap("spec") + assert status.success?, output + errors + assert_equal base_paths, JSON.parse(output).fetch("ld_run_path") + end + + def test_runtime_wrapper_interpreter_requires_the_reviewed_static_shell_header + ["#!#{RbConfig.ruby}", "#!/bin/false", "#!/usr/bin/env bash", "#!/bin/bash -e", "#! /bin/bash"].each do |header| + write_executable(@wrapper, header + "\nLD_RUN_PATH=\"#{base_paths}\" exec \"#{@backend}\" \"$@\"\n") + @profile["wrapper_sha256"] = hash(@wrapper) + write_profile("normal", @profile) + assert_rejected("reviewed static shell interpreter", "spec") + end + end +end diff --git a/tools/grant_compile_acceptance/PUBLICATION_PINS.json b/tools/grant_compile_acceptance/PUBLICATION_PINS.json new file mode 100644 index 0000000..476bdbe --- /dev/null +++ b/tools/grant_compile_acceptance/PUBLICATION_PINS.json @@ -0,0 +1,45 @@ +{ + "format": "atlas-grant-source-publication-review-v1", + "source_only": true, + "outer_archive_sha256": "aebd690e5978aa6373e2177aa7ee2d5bcb8b7e064cc50aee18ae9c4d53fc5601", + "contents_sha256": "292430bfd276814ed8bfda4e0edb16aa04e582a9bc92bd927c6c4bf2a9beb9c6", + "source_review_receipt_sha256": "3898d7113d7e944df2ce057bf3223e6c85133fe2ef96bc5e90ed384b1b0e7df9", + "target_cells_accepted": 0, + "required_target_cells": 144, + "files": [ + { + "path": "README.md", + "bytes": 3357, + "sha256": "e583771d017ffbbe2de31a71996e23755f5e0ab6ddcc7766d107620e52e7309b" + }, + { + "path": "grant-linux-first-build-publication-v100.tar.gz", + "bytes": 2908563, + "sha256": "aebd690e5978aa6373e2177aa7ee2d5bcb8b7e064cc50aee18ae9c4d53fc5601" + }, + { + "path": "verify_publication.py", + "bytes": 13407, + "sha256": "c7bb0b45e7df41fd45ba28f498b109fce797772bfe4707898c92401bd1bb3041" + } + ], + "source_python_profiles": { + "linux": [ + { + "version": "3.12.3", + "sha256": "e50d468e8b0adfb05733f5b87b3cff34829c4a8c1aea50c865aa8bdfe4bb150f" + } + ], + "darwin": [ + { + "version": "3.15.0", + "sha256": "1955899cb535256cfa477d926d016819e52e747984722c44f76e39a4950fee0e" + }, + { + "version": "3.9.6", + "sha256": "271143990bc83af0fb2404a255038f5faafb96df1584ed7f085e5018c0f33ffb" + } + ] + }, + "provider_scope": "Linux 3.12.3 and macOS 3.15.0 interpreter pins are observed hosted-control profiles. Xcode 3.9.6 is the local source-review profile. Full native dependency closure remains separate for every profile." +} diff --git a/tools/grant_compile_acceptance/PUBLICATION_PINS.v101.json b/tools/grant_compile_acceptance/PUBLICATION_PINS.v101.json new file mode 100644 index 0000000..3003f8e --- /dev/null +++ b/tools/grant_compile_acceptance/PUBLICATION_PINS.v101.json @@ -0,0 +1,57 @@ +{ + "actual_compiler_container_native_ssh_jobs": 0, + "contents_sha256": "6ed26546943e29553c6cdf062652ecd30529924da402b53b5b39d3f7f6456080", + "corrected_hosted_source_acceptance": "pending", + "files": [ + { + "bytes": 3895, + "mode": 420, + "path": "README.md", + "sha256": "ec5de572875c4133a91ebb5b12f9a490f28c0109f5be507afaed3159fd55bd6f" + }, + { + "bytes": 2908563, + "mode": 420, + "path": "grant-linux-first-build-publication-v100.tar.gz", + "sha256": "aebd690e5978aa6373e2177aa7ee2d5bcb8b7e064cc50aee18ae9c4d53fc5601" + }, + { + "bytes": 5511524, + "mode": 420, + "path": "grant-linux-first-build-publication-v101.tar.gz", + "sha256": "39ae53df3f72668f63101e0f65606cc41b2787c71292bff0f163031bb4bb309e" + }, + { + "bytes": 16623, + "mode": 420, + "path": "verify_publication_v101.py", + "sha256": "728f7df0eb6b36c127bc9ea81e8356834cb2272acfd6ae357f8ec27cfe219695" + } + ], + "format": "atlas-grant-source-publication-review-v101", + "frozen_v100_outer_sha256": "aebd690e5978aa6373e2177aa7ee2d5bcb8b7e064cc50aee18ae9c4d53fc5601", + "outer_archive_sha256": "39ae53df3f72668f63101e0f65606cc41b2787c71292bff0f163031bb4bb309e", + "provider_scope": "Linux 3.12.3 and macOS 3.15.0 interpreter pins are observed hosted-control profiles. Xcode 3.9.6 is the local source-review profile. Full native dependency closure remains separate for every profile.", + "required_target_cells": 144, + "source_only": true, + "source_python_profiles": { + "darwin": [ + { + "sha256": "1955899cb535256cfa477d926d016819e52e747984722c44f76e39a4950fee0e", + "version": "3.15.0" + }, + { + "sha256": "271143990bc83af0fb2404a255038f5faafb96df1584ed7f085e5018c0f33ffb", + "version": "3.9.6" + } + ], + "linux": [ + { + "sha256": "e50d468e8b0adfb05733f5b87b3cff34829c4a8c1aea50c865aa8bdfe4bb150f", + "version": "3.12.3" + } + ] + }, + "source_tool_manifest_sha256": "f009edff0608a625517df0e01803be9a349d579d3e2dbdd73d6d05a557109164", + "target_cells_accepted": 0 +} diff --git a/tools/grant_compile_acceptance/README.md b/tools/grant_compile_acceptance/README.md new file mode 100644 index 0000000..1774be3 --- /dev/null +++ b/tools/grant_compile_acceptance/README.md @@ -0,0 +1,17 @@ +# Grant source-package controls + +Mission: **memory-budget-experiment**. This directory contains exact source packets and a named **v101** compatibility successor. Corrected hosted source/package acceptance remains pending. Actual compiler, container, native-target, and SSH workloads remain **0**; the full Grant target remains **0/144**. + +The [checked workflow](../../.github/workflows/grant-source-package-controls.yml) admits the exact v101 manifest, every root source/archive member, and an exact reviewed interpreter version and SHA-256 before importing the active verifier. It physically verifies the package, reproduces exact original inner and successor outer archives, rejects changed archive bytes, runs unchanged original source cohorts through the explicit helper mapping, and runs the new compatibility regressions. Raw output, original failures, and complete hidden-file source evidence are always uploaded. + +The v100 archive remains exact: **2,908,563 bytes**, SHA-256 `aebd690e5978aa6373e2177aa7ee2d5bcb8b7e064cc50aee18ae9c4d53fc5601`. Its anonymous exact public readback and actual Ubuntu/macOS refusal receipts are preserved in the v101 packet. Run [39480858638](https://github.com/amberframework/memory_budget/actions/runs/39480858638) reached source/package work and failed before source cohorts: Ubuntu lacked optional `zlib.__file__`; macOS 3.15 changed gzip's default compression level. Original failures remain authoritative for that run. + +The active successor explicitly writes gzip at level **9** and records checked built-in/file-backed `zlib` layouts. It retains the exact v100 packet and all 76 original payload files, the original manifest in ancestry, and the unchanged **1,626,007-byte** inner source/dependency archive, SHA-256 `d2c90cc3110109337c92f567fdf533dadf475b3f468602b8fcb5e2ed21426ff5`. Every maintained workload, full model fixture, origin row, frozen audit finding, and original contract stays intact. + +The active v101 runner maps a fresh workspace's preparation-helper import to the named v102 portable helper using `PORTABLE_HELPER_COMPATIBILITY.v101.json`. The original helper, preceding portable helper/mapping, all **13 v100** tests, and all **16 v102** tests remain exact. The original tests run in ordinary and optimized modes, together with **12** successor controls per mode. Six serial cohorts use 75-second individual deadlines within the unchanged 540-second wrapper/10-minute step bounds. + +For a manual verification, first compare the chosen interpreter's exact version and executable SHA-256 with `PUBLICATION_PINS.v101.json`, then independently check that manifest's declared hash and every named source/archive byte count and SHA-256. Use the exact admitted `verify_publication_v101.py` with `--archive grant-linux-first-build-publication-v101.tar.gz`, independently declared `--archive-sha256` and `--contents-sha256`, and a fresh `--output` directory. The workflow contains executable admission and complete invocations. + +The manifest separates observed hosted Linux **3.12.3** and macOS **3.15.0** interpreter profiles from the local Xcode **3.9.6** source-review profile. A local pass establishes its exact local provider. Built-in module code is bound to the checked interpreter and import origin; linked native libraries and the complete native dependency closure remain separate gates. + +Frozen v100 metadata retains its historical pending labels and source behavior. The active v101 runner reports corrected hosted qualification as pending until actual execution; the outer workflow derives actual Linux source-cohort execution from the running platform and checks all source cohort/regression receipts. Successful source/package controls establish that scope. Installed compiler readiness, full native closure, customer/release acceptance, real Grant builds, and the complete 144-cell budget target require their own receipts. diff --git a/tools/grant_compile_acceptance/grant-linux-first-build-publication-v100.tar.gz b/tools/grant_compile_acceptance/grant-linux-first-build-publication-v100.tar.gz new file mode 100644 index 0000000..d6e1272 Binary files /dev/null and b/tools/grant_compile_acceptance/grant-linux-first-build-publication-v100.tar.gz differ diff --git a/tools/grant_compile_acceptance/grant-linux-first-build-publication-v101.tar.gz b/tools/grant_compile_acceptance/grant-linux-first-build-publication-v101.tar.gz new file mode 100644 index 0000000..d1c8dc3 Binary files /dev/null and b/tools/grant_compile_acceptance/grant-linux-first-build-publication-v101.tar.gz differ diff --git a/tools/grant_compile_acceptance/verify_publication.py b/tools/grant_compile_acceptance/verify_publication.py new file mode 100644 index 0000000..1e2cdd9 --- /dev/null +++ b/tools/grant_compile_acceptance/verify_publication.py @@ -0,0 +1,226 @@ +#!/usr/bin/env python3 +"""Independently read, physically extract, and reproduce the publication packet.""" +import argparse +import copy +import gzip +import hashlib +import json +import os +from pathlib import Path, PurePosixPath +import stat +import sys +import tarfile +import zlib + +PREFIX = "grant-first-build-publication-v100" +INNER_PATH = "workspace/grant_linux_first_build_v100/prepared/grant-source-and-frozen-dependencies.tar.gz" +INNER_SHA = "d2c90cc3110109337c92f567fdf533dadf475b3f468602b8fcb5e2ed21426ff5" + + +def need(value, message): + if not value: + raise ValueError(message) + + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def parse(raw): + def unique(pairs): + result = {} + for key, value in pairs: + need(key not in result, "Unique JSON fields required") + result[key] = value + return result + def finite(value): + raise ValueError("Finite JSON values required: " + value) + return json.loads(raw, object_pairs_hook=unique, parse_constant=finite) + + +def canonical_sha(value): + return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(",", ":")).encode()).hexdigest() + + +def safe_path(value, root=False): + path = PurePosixPath(value) + need(type(value) is str and path.as_posix() == value and not path.is_absolute() + and ".." not in path.parts and (value != "." or root), "Canonical contained member path required") + return path + + +def verify_payload(root, expected_contents_sha): + root = Path(root).resolve() + manifest = root / "PACKAGE_CONTENTS.json" + need(sha(manifest) == expected_contents_sha, "The independently declared contents manifest must match") + data = parse(manifest.read_bytes()) + need(data["format"] == "atlas-grant-first-build-publication-contents-v1" and data["archive_prefix"] == PREFIX, + "Exact publication format and prefix required") + rows = data["files"] + need(type(rows) is list and len(rows) <= 256 and len({row["path"] for row in rows}) == len(rows), "Unique bounded file roster required") + expected_files = {"PACKAGE_CONTENTS.json"} + for row in rows: + relative = safe_path(row["path"]) + path = root / relative + need(type(row["mode"]) is int and type(row["bytes"]) is int and 0 <= row["bytes"] <= 16 * 2**20, + "Typed bounded file metadata required") + need(path.is_file() and not path.is_symlink() and path.resolve().is_relative_to(root) + and path.stat().st_size == row["bytes"] and stat.S_IMODE(path.stat().st_mode) == row["mode"] + and sha(path) == row["sha256"], "Physical payload bytes/mode differ: " + row["path"]) + expected_files.add(row["path"]) + actual_files = {path.relative_to(root).as_posix() for path in root.rglob("*") if path.is_file()} + need(actual_files == expected_files and all(not path.is_symlink() for path in root.rglob("*")), "Complete ordinary outer file roster required") + actual_directories = {"."} | {path.relative_to(root).as_posix() for path in root.rglob("*") if path.is_dir()} + need(actual_directories == {row["path"] for row in data["directories"]}, "Complete structural directory roster required") + for row in data["directories"]: + safe_path(row["path"], root=True) + need(type(row["mode"]) is int and stat.S_IMODE((root / row["path"]).stat().st_mode) == row["mode"], "Exact outer directory mode required") + need(stat.S_IMODE(manifest.stat().st_mode) == 0o644, "The contents manifest retains its declared mode") + return data + + +def extract_outer(archive_path, target, expected_contents_sha): + with tarfile.open(archive_path, "r:gz") as archive: + members = archive.getmembers() + need(len(members) <= 512 and len({member.name for member in members}) == len(members), "Unique bounded outer archive roster required") + need(sum(member.size for member in members) <= 64 * 2**20, "Finite expanded publication bytes required") + for member in members: + safe_path(member.name) + need(member.name == PREFIX or member.name.startswith(PREFIX + "/"), "Exact outer archive namespace required") + need(member.isfile() or member.isdir(), "Outer members are ordinary files and directories") + need(member.uid == member.gid == member.mtime == 0 and member.uname == member.gname == "", + "Canonical deterministic outer ownership and clock metadata required") + need(member.size <= 16 * 2**20, "Finite outer member size required") + path = target / member.name + if member.isdir(): + path.mkdir(parents=True, exist_ok=True) + else: + path.parent.mkdir(parents=True, exist_ok=True) + with path.open("xb") as stream: + stream.write(archive.extractfile(member).read()) + path.chmod(member.mode) + payload = target / PREFIX + data = verify_payload(payload, expected_contents_sha) + expected = {PREFIX} | {PREFIX + "/" + row["path"] for row in data["directories"] if row["path"] != "."} + expected |= {PREFIX + "/" + row["path"] for row in data["files"]} | {PREFIX + "/PACKAGE_CONTENTS.json"} + need(expected == {member.name for member in members}, "Every outer archive member is covered by the manifest") + return payload, data + + +def extract_inner(inner, destination, ledger, origins): + need(sha(inner) == INNER_SHA and inner.stat().st_size == 1626007, "Exact accepted inner archive required") + by_path = {row["archive_path"]: row for row in origins} + need(len(by_path) == len(origins) == 1549, "Complete unique source-origin roster required") + aliases = [] + with tarfile.open(inner, "r:gz") as archive: + members = archive.getmembers() + need(len(members) == len(ledger) == 1749 and sum(member.size for member in members) <= 64 * 2**20, + "Exact finite inner archive/header roster required") + for ordinal, (member, row) in enumerate(zip(members, ledger), 1): + safe_path(member.name) + need(member.name.startswith("grant/") and row["ordinal"] == ordinal and row["path"] == member.name + and row["mode"] == member.mode and row["bytes"] == member.size, "Exact inner header identity/order/mode required") + kind = "file" if member.isfile() else "directory" if member.isdir() else "symlink" if member.issym() else "unsupported" + need(kind == row["kind"] and kind != "unsupported", "Exact reviewed inner member kind required") + path = destination / member.name + need(all(not parent.is_symlink() for parent in path.parents if parent.is_relative_to(destination)), "Ordinary extraction parents required") + if member.isdir(): + path.mkdir(parents=True, exist_ok=True) + path.chmod(member.mode) + need(row["descendant_payload_members"] == sum(name.startswith(member.name + "/") for name in by_path), "Derived directory origin count differs") + else: + original = by_path[member.name] + need(original["origin_verified"] is True and canonical_sha(original) == row["origin_row_sha256"], "Complete member-origin row differs") + path.parent.mkdir(parents=True, exist_ok=True) + if member.isfile(): + raw = archive.extractfile(member).read() + need(hashlib.sha256(raw).hexdigest() == row["sha256"] == original["sha256"], "Exact inner member bytes required") + with path.open("xb") as stream: + stream.write(raw) + path.chmod(member.mode) + need(sha(path) == row["sha256"] and stat.S_IMODE(path.stat().st_mode) == member.mode, "Physical inner file replay differs") + else: + need(member.linkname == row["target"] == original["target"] and not Path(member.linkname).is_absolute(), "Exact relative alias target required") + need((path.parent / member.linkname).resolve().is_relative_to(destination / "grant/lib"), "Alias remains in the common pinned dependency closure") + path.symlink_to(member.linkname) + if hasattr(os, "lchmod"): + os.lchmod(path, member.mode) + aliases.append({"path": member.name, "target": os.readlink(path), "archive_mode": member.mode, + "physical_mode": stat.S_IMODE(path.lstat().st_mode)}) + need(os.readlink(path) == member.linkname, "Physical alias replay differs") + return members, aliases + + +def rebuild_from_members(destination, members, output): + with output.open("xb") as target: + with gzip.GzipFile(filename="", mode="wb", fileobj=target, mtime=0) as compressed: + with tarfile.open(fileobj=compressed, mode="w", format=tarfile.PAX_FORMAT) as archive: + for original in members: + member = copy.copy(original) + if member.isfile(): + with (destination / member.name).open("rb") as stream: + archive.addfile(member, stream) + else: + archive.addfile(member) + + +def rebuild_outer(payload, contents, output): + names = ["."] + sorted([row["path"] for row in contents["directories"] if row["path"] != "."] + + [row["path"] for row in contents["files"]] + ["PACKAGE_CONTENTS.json"]) + with output.open("xb") as target: + with gzip.GzipFile(filename="", mode="wb", fileobj=target, mtime=0) as compressed: + with tarfile.open(fileobj=compressed, mode="w", format=tarfile.PAX_FORMAT) as archive: + for name in names: + path = payload / name + member = tarfile.TarInfo(PREFIX if name == "." else PREFIX + "/" + name) + member.mode = stat.S_IMODE(path.stat().st_mode) + if path.is_dir(): + member.type = tarfile.DIRTYPE + archive.addfile(member) + else: + member.size = path.stat().st_size + with path.open("rb") as stream: + archive.addfile(member, stream) + + +def verify(archive_path, expected_archive_sha, expected_contents_sha, output): + need(archive_path.stat().st_size <= 20 * 2**20 and sha(archive_path) == expected_archive_sha, "Independently declared bounded outer archive digest required") + output.mkdir(parents=True, exist_ok=False) + payload, contents = extract_outer(archive_path, output, expected_contents_sha) + inner = payload / INNER_PATH + members, aliases = extract_inner(inner, output / "inner-readback", parse((payload / "origin/INNER_TAR_MEMBER_LEDGER.json").read_bytes()), + parse((payload / "origin/ARCHIVE_MEMBER_ORIGINS_COMPLETE.json").read_bytes())) + inner_repeat, outer_repeat = output / "inner-reproduced.tar.gz", output / "outer-reproduced.tar.gz" + rebuild_from_members(output / "inner-readback", members, inner_repeat) + need(sha(inner_repeat) == INNER_SHA, "All physically extracted inner bytes and archived modes reproduce the exact inner digest") + rebuild_outer(payload, contents, outer_repeat) + need(sha(outer_repeat) == expected_archive_sha, "All physically extracted outer bytes/modes reproduce the exact outer digest") + return {"mission": "memory-budget-experiment", "package_verification_passed": True, + "outer_archive_sha256": sha(archive_path), "outer_archive_bytes": archive_path.stat().st_size, + "contents_sha256": expected_contents_sha, "inner_sha256": INNER_SHA, + "inner_reproduced_sha256": sha(inner_repeat), "outer_reproduced_sha256": sha(outer_repeat), + "outer_files": len(contents["files"]) + 1, "outer_directories": len(contents["directories"]), + "inner_header_rows": len(members), "inner_physical_payload_rows": 1549, "aliases": aliases, + "physical_symlink_modes_match_archive_on_this_platform": all(row["archive_mode"] == row["physical_mode"] for row in aliases), + "provider": {"python_version": sys.version, "python_sha256": sha(Path(sys.executable).resolve()), + "zlib_version": zlib.ZLIB_RUNTIME_VERSION, "zlib_module_sha256": sha(Path(zlib.__file__).resolve())}, + "public_commit_upload": "pending-parent", "ordinary_installation_native_projection_actual_build": "pending", + "active_workflow_dependency_admission": "separate future boundary", "actual_compiler_container_native_ssh_jobs": 0, + "accepted_target_cells": 0, "required_target_cells": 144} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--archive", type=Path, required=True) + parser.add_argument("--archive-sha256", required=True) + parser.add_argument("--contents-sha256", required=True) + parser.add_argument("--output", type=Path, required=True) + args = parser.parse_args() + result = verify(args.archive.resolve(), args.archive_sha256, args.contents_sha256, args.output.resolve()) + with (args.output / "VERIFICATION_RECEIPT.json").open("x") as stream: + stream.write(json.dumps(result, indent=2, sort_keys=True) + "\n") + print(json.dumps(result, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/tools/grant_compile_acceptance/verify_publication_v101.py b/tools/grant_compile_acceptance/verify_publication_v101.py new file mode 100644 index 0000000..efe7c60 --- /dev/null +++ b/tools/grant_compile_acceptance/verify_publication_v101.py @@ -0,0 +1,274 @@ +#!/usr/bin/env python3 +"""Independently read, physically extract, and reproduce the publication packet.""" +import argparse +import copy +import gzip +import hashlib +import json +import os +import platform +from pathlib import Path, PurePosixPath +import stat +import sys +import tarfile +import zlib + +PREFIX = "grant-first-build-publication-v101" +INNER_PATH = "workspace/grant_linux_first_build_v100/prepared/grant-source-and-frozen-dependencies.tar.gz" +INNER_SHA = "d2c90cc3110109337c92f567fdf533dadf475b3f468602b8fcb5e2ed21426ff5" +ANCESTOR_SHA = "aebd690e5978aa6373e2177aa7ee2d5bcb8b7e064cc50aee18ae9c4d53fc5601" +SOURCE_PYTHON_PROFILES = { + ("linux", "3.12.3"): "e50d468e8b0adfb05733f5b87b3cff34829c4a8c1aea50c865aa8bdfe4bb150f", + ("darwin", "3.15.0"): "1955899cb535256cfa477d926d016819e52e747984722c44f76e39a4950fee0e", + ("darwin", "3.9.6"): "271143990bc83af0fb2404a255038f5faafb96df1584ed7f085e5018c0f33ffb", +} + + +def need(value, message): + if not value: + raise ValueError(message) + + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def source_provider_metadata(): + """Bind source execution to a reviewed interpreter and record zlib's layout.""" + executable = Path(sys.executable).resolve(strict=True) + version = platform.python_version() + expected = SOURCE_PYTHON_PROFILES.get((sys.platform, version)) + need(expected is not None and executable.is_file() and sha(executable) == expected, + "Exact reviewed source Python version and executable digest required") + spec = getattr(zlib, "__spec__", None) + origin = getattr(spec, "origin", None) + need(getattr(zlib, "__name__", None) == "zlib" and getattr(spec, "name", None) == "zlib", + "Exact zlib module and import-spec names required") + module_file = getattr(zlib, "__file__", None) + if module_file is None: + need(origin == "built-in" and "zlib" in sys.builtin_module_names, + "An absent zlib module file requires an actual built-in origin and name") + provider = {"zlib_module_kind": "built-in", "zlib_module_origin": "built-in", + "zlib_module": None, "zlib_module_sha256": None, + "zlib_module_hash_scope": "Built-in module code belongs to the exact interpreter digest; linked native library closure remains separate"} + else: + need(type(module_file) is str and type(origin) is str, + "File-backed zlib needs explicit module-file and import-origin paths") + path = Path(module_file).resolve(strict=True) + need(path.is_file() and origin != "built-in" and Path(origin).resolve(strict=True) == path, + "File-backed zlib import origin must match its regular module file") + provider = {"zlib_module_kind": "file-backed", "zlib_module_origin": origin, + "zlib_module": str(path), "zlib_module_bytes": path.stat().st_size, + "zlib_module_sha256": sha(path), + "zlib_module_hash_scope": "Observed file-backed source provider metadata; full native dependency closure remains separate"} + compile_version = getattr(zlib, "ZLIB_VERSION", None) + runtime_version = getattr(zlib, "ZLIB_RUNTIME_VERSION", None) + need(type(compile_version) is str and bool(compile_version) + and type(runtime_version) is str and bool(runtime_version), + "Observed zlib compile and runtime versions required") + provider.update({"python_version": sys.version, "python_profile_version": version, + "python_executable": str(executable), "python_sha256": expected, + "zlib_compile_version": compile_version, "zlib_runtime_version": runtime_version, + "full_native_dependency_closure_accepted": False}) + return provider + + +def parse(raw): + def unique(pairs): + result = {} + for key, value in pairs: + need(key not in result, "Unique JSON fields required") + result[key] = value + return result + def finite(value): + raise ValueError("Finite JSON values required: " + value) + return json.loads(raw, object_pairs_hook=unique, parse_constant=finite) + + +def canonical_sha(value): + return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(",", ":")).encode()).hexdigest() + + +def safe_path(value, root=False): + path = PurePosixPath(value) + need(type(value) is str and path.as_posix() == value and not path.is_absolute() + and ".." not in path.parts and (value != "." or root), "Canonical contained member path required") + return path + + +def verify_payload(root, expected_contents_sha, archive_prefix=PREFIX): + root = Path(root).resolve() + manifest = root / "PACKAGE_CONTENTS.json" + need(sha(manifest) == expected_contents_sha, "The independently declared contents manifest must match") + data = parse(manifest.read_bytes()) + need(data["format"] == "atlas-grant-first-build-publication-contents-v1" and data["archive_prefix"] == archive_prefix, + "Exact publication format and prefix required") + rows = data["files"] + need(type(rows) is list and len(rows) <= 256 and len({row["path"] for row in rows}) == len(rows), "Unique bounded file roster required") + expected_files = {"PACKAGE_CONTENTS.json"} + for row in rows: + relative = safe_path(row["path"]) + path = root / relative + need(type(row["mode"]) is int and type(row["bytes"]) is int and 0 <= row["bytes"] <= 16 * 2**20, + "Typed bounded file metadata required") + need(path.is_file() and not path.is_symlink() and path.resolve().is_relative_to(root) + and path.stat().st_size == row["bytes"] and stat.S_IMODE(path.stat().st_mode) == row["mode"] + and sha(path) == row["sha256"], "Physical payload bytes/mode differ: " + row["path"]) + expected_files.add(row["path"]) + actual_files = {path.relative_to(root).as_posix() for path in root.rglob("*") if path.is_file()} + need(actual_files == expected_files and all(not path.is_symlink() for path in root.rglob("*")), "Complete ordinary outer file roster required") + actual_directories = {"."} | {path.relative_to(root).as_posix() for path in root.rglob("*") if path.is_dir()} + need(actual_directories == {row["path"] for row in data["directories"]}, "Complete structural directory roster required") + for row in data["directories"]: + safe_path(row["path"], root=True) + need(type(row["mode"]) is int and stat.S_IMODE((root / row["path"]).stat().st_mode) == row["mode"], "Exact outer directory mode required") + need(stat.S_IMODE(manifest.stat().st_mode) == 0o644, "The contents manifest retains its declared mode") + return data + + +def extract_outer(archive_path, target, expected_contents_sha, archive_prefix=PREFIX): + with tarfile.open(archive_path, "r:gz") as archive: + members = archive.getmembers() + need(len(members) <= 512 and len({member.name for member in members}) == len(members), "Unique bounded outer archive roster required") + need(sum(member.size for member in members) <= 64 * 2**20, "Finite expanded publication bytes required") + for member in members: + safe_path(member.name) + need(member.name == archive_prefix or member.name.startswith(archive_prefix + "/"), "Exact outer archive namespace required") + need(member.isfile() or member.isdir(), "Outer members are ordinary files and directories") + need(member.uid == member.gid == member.mtime == 0 and member.uname == member.gname == "", + "Canonical deterministic outer ownership and clock metadata required") + need(member.size <= 16 * 2**20, "Finite outer member size required") + path = target / member.name + if member.isdir(): + path.mkdir(parents=True, exist_ok=True) + else: + path.parent.mkdir(parents=True, exist_ok=True) + with path.open("xb") as stream: + stream.write(archive.extractfile(member).read()) + path.chmod(member.mode) + payload = target / archive_prefix + data = verify_payload(payload, expected_contents_sha, archive_prefix) + expected = {archive_prefix} | {archive_prefix + "/" + row["path"] for row in data["directories"] if row["path"] != "."} + expected |= {archive_prefix + "/" + row["path"] for row in data["files"]} | {archive_prefix + "/PACKAGE_CONTENTS.json"} + need(expected == {member.name for member in members}, "Every outer archive member is covered by the manifest") + return payload, data + + +def extract_inner(inner, destination, ledger, origins): + need(sha(inner) == INNER_SHA and inner.stat().st_size == 1626007, "Exact accepted inner archive required") + by_path = {row["archive_path"]: row for row in origins} + need(len(by_path) == len(origins) == 1549, "Complete unique source-origin roster required") + aliases = [] + with tarfile.open(inner, "r:gz") as archive: + members = archive.getmembers() + need(len(members) == len(ledger) == 1749 and sum(member.size for member in members) <= 64 * 2**20, + "Exact finite inner archive/header roster required") + for ordinal, (member, row) in enumerate(zip(members, ledger), 1): + safe_path(member.name) + need(member.name.startswith("grant/") and row["ordinal"] == ordinal and row["path"] == member.name + and row["mode"] == member.mode and row["bytes"] == member.size, "Exact inner header identity/order/mode required") + kind = "file" if member.isfile() else "directory" if member.isdir() else "symlink" if member.issym() else "unsupported" + need(kind == row["kind"] and kind != "unsupported", "Exact reviewed inner member kind required") + path = destination / member.name + need(all(not parent.is_symlink() for parent in path.parents if parent.is_relative_to(destination)), "Ordinary extraction parents required") + if member.isdir(): + path.mkdir(parents=True, exist_ok=True) + path.chmod(member.mode) + need(row["descendant_payload_members"] == sum(name.startswith(member.name + "/") for name in by_path), "Derived directory origin count differs") + else: + original = by_path[member.name] + need(original["origin_verified"] is True and canonical_sha(original) == row["origin_row_sha256"], "Complete member-origin row differs") + path.parent.mkdir(parents=True, exist_ok=True) + if member.isfile(): + raw = archive.extractfile(member).read() + need(hashlib.sha256(raw).hexdigest() == row["sha256"] == original["sha256"], "Exact inner member bytes required") + with path.open("xb") as stream: + stream.write(raw) + path.chmod(member.mode) + need(sha(path) == row["sha256"] and stat.S_IMODE(path.stat().st_mode) == member.mode, "Physical inner file replay differs") + else: + need(member.linkname == row["target"] == original["target"] and not Path(member.linkname).is_absolute(), "Exact relative alias target required") + need((path.parent / member.linkname).resolve().is_relative_to(destination / "grant/lib"), "Alias remains in the common pinned dependency closure") + path.symlink_to(member.linkname) + if hasattr(os, "lchmod"): + os.lchmod(path, member.mode) + aliases.append({"path": member.name, "target": os.readlink(path), "archive_mode": member.mode, + "physical_mode": stat.S_IMODE(path.lstat().st_mode)}) + need(os.readlink(path) == member.linkname, "Physical alias replay differs") + return members, aliases + + +def rebuild_from_members(destination, members, output): + with output.open("xb") as target: + with gzip.GzipFile(filename="", mode="wb", fileobj=target, mtime=0, compresslevel=9) as compressed: + with tarfile.open(fileobj=compressed, mode="w", format=tarfile.PAX_FORMAT) as archive: + for original in members: + member = copy.copy(original) + if member.isfile(): + with (destination / member.name).open("rb") as stream: + archive.addfile(member, stream) + else: + archive.addfile(member) + + +def rebuild_outer(payload, contents, output): + names = ["."] + sorted([row["path"] for row in contents["directories"] if row["path"] != "."] + + [row["path"] for row in contents["files"]] + ["PACKAGE_CONTENTS.json"]) + with output.open("xb") as target: + with gzip.GzipFile(filename="", mode="wb", fileobj=target, mtime=0, compresslevel=9) as compressed: + with tarfile.open(fileobj=compressed, mode="w", format=tarfile.PAX_FORMAT) as archive: + for name in names: + path = payload / name + member = tarfile.TarInfo(PREFIX if name == "." else PREFIX + "/" + name) + member.mode = stat.S_IMODE(path.stat().st_mode) + if path.is_dir(): + member.type = tarfile.DIRTYPE + archive.addfile(member) + else: + member.size = path.stat().st_size + with path.open("rb") as stream: + archive.addfile(member, stream) + + +def verify(archive_path, expected_archive_sha, expected_contents_sha, output): + need(archive_path.stat().st_size <= 20 * 2**20 and sha(archive_path) == expected_archive_sha, "Independently declared bounded outer archive digest required") + provider = source_provider_metadata() + output.mkdir(parents=True, exist_ok=False) + payload, contents = extract_outer(archive_path, output, expected_contents_sha) + need(sha(payload / "ancestry/grant-linux-first-build-publication-v100.tar.gz") == ANCESTOR_SHA, "Exact frozen v100 publication packet required") + inner = payload / INNER_PATH + members, aliases = extract_inner(inner, output / "inner-readback", parse((payload / "origin/INNER_TAR_MEMBER_LEDGER.json").read_bytes()), + parse((payload / "origin/ARCHIVE_MEMBER_ORIGINS_COMPLETE.json").read_bytes())) + inner_repeat, outer_repeat = output / "inner-reproduced.tar.gz", output / "outer-reproduced.tar.gz" + rebuild_from_members(output / "inner-readback", members, inner_repeat) + need(sha(inner_repeat) == INNER_SHA, "All physically extracted inner bytes and archived modes reproduce the exact inner digest") + rebuild_outer(payload, contents, outer_repeat) + need(sha(outer_repeat) == expected_archive_sha, "All physically extracted outer bytes/modes reproduce the exact outer digest") + return {"mission": "memory-budget-experiment", "package_verification_passed": True, + "outer_archive_sha256": sha(archive_path), "outer_archive_bytes": archive_path.stat().st_size, + "contents_sha256": expected_contents_sha, "inner_sha256": INNER_SHA, + "inner_reproduced_sha256": sha(inner_repeat), "outer_reproduced_sha256": sha(outer_repeat), + "outer_files": len(contents["files"]) + 1, "outer_directories": len(contents["directories"]), + "inner_header_rows": len(members), "inner_physical_payload_rows": 1549, "aliases": aliases, + "physical_symlink_modes_match_archive_on_this_platform": all(row["archive_mode"] == row["physical_mode"] for row in aliases), + "provider": provider, "ancestor_outer_sha256": ANCESTOR_SHA, + "public_commit_upload": "pending-parent", "ordinary_installation_native_projection_actual_build": "pending", + "active_workflow_dependency_admission": "separate future boundary", "actual_compiler_container_native_ssh_jobs": 0, + "accepted_target_cells": 0, "required_target_cells": 144} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--archive", type=Path, required=True) + parser.add_argument("--archive-sha256", required=True) + parser.add_argument("--contents-sha256", required=True) + parser.add_argument("--output", type=Path, required=True) + args = parser.parse_args() + result = verify(args.archive.resolve(), args.archive_sha256, args.contents_sha256, args.output.resolve()) + with (args.output / "VERIFICATION_RECEIPT.json").open("x") as stream: + stream.write(json.dumps(result, indent=2, sort_keys=True) + "\n") + print(json.dumps(result, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/tools/installation_provenance/README.md b/tools/installation_provenance/README.md new file mode 100644 index 0000000..a6bf2f3 --- /dev/null +++ b/tools/installation_provenance/README.md @@ -0,0 +1,54 @@ +# Linux kernel budget qualification + +These controls qualify a finite Linux container environment for the memory +budget and installation-provenance tooling. The SDK's installed package and +Grant's complete-build acceptance retain their respective contracts. + +The first CI run records a candidate runner profile. A read-only metadata +collector hashes the installed Docker client, the live daemon executable, +Python, Bash, sudo, sha256sum, and timeout. It records the daemon's reported +version and Git revision, kernel, cgroup controller, and GitHub image identity. +Reading the daemon executable uses the hosted VM's administrative metadata +access. This phase starts zero containers and earns zero workload acceptance. +The missing reviewed profile produces exit 2 while retaining the candidate +artifact, so pending qualification remains a failed gate. + +Review the candidate and commit its exact `profile` object as one entry in +`runner_profile.json`, using the `atlas-linux-runner-profile-set-v1` format. +The finite roster holds separately reviewed complete profiles. The next +job compares every observed field against one complete entry before admitting +the Docker workloads. Nine admission controls exercise exact matches and +refusals for changed, mixed, incomplete, duplicate, or wrongly typed profiles. +Profile drift refuses before workload entry. The runner image and kernel +remain an explicit observed platform boundary. + +The workload source manifest binds seven Python files by SHA256. The original +54 source controls ran in both ordinary and optimized modes on the recorded +Darwin ARM64 development profile. The Linux reader uses the current numeric +PID path so its physical-file identity checks work with the kernel's process +files. Four additional controls reject external snapshots with missing event +counters or Boolean/fractional measurements, bringing each cohort to 58. +The Linux workflow exercises separate capped ordinary and optimized containers, a real +OOM allocation, an uncapped refusal, and external terminal verification. +The driver records and removes only its exact owned container identities. + +Workloads use the digest-pinned Python image, read-only source and cgroup +mounts, one CPU, 64 process slots, zero swap, a bounded temporary filesystem, +and a page-aligned memory ceiling. The OOM control needs an admitted probe, +exit 137, and Docker's actual OOM marker. An uncapped container must refuse +before loading the test modules. Raw results, inspections, and cleanup +readbacks are retained as CI artifacts. + +`memory.peak` measures charged memory for the current cgroup and descendants. +It differs from compiler-process RSS. The kernel also documents temporary +limit overshoot and the ownership of shared or migrated pages. Actual peak, +event counters, process membership, short-lived children, sibling isolation, +and complete terminal evidence need their own qualification before this +measurement can participate in a complete Grant build contract. See the +[kernel memory controller documentation](https://docs.kernel.org/admin-guide/cgroup-v2.html). + +Grant's default-feature 300/500-model target remains strictly below +2,000,000,000 bytes for both required memory metrics across its complete +matrix. These installation-protocol controls alone accept zero Grant cells, +execute zero Homebrew commands, and establish zero ordinary compiler +installations. Their runtime reports preserve those scopes explicitly. diff --git a/tools/installation_provenance/SOURCE_PINS.json b/tools/installation_provenance/SOURCE_PINS.json new file mode 100644 index 0000000..51b3719 --- /dev/null +++ b/tools/installation_provenance/SOURCE_PINS.json @@ -0,0 +1,47 @@ +{ + "format": "atlas-linux-control-sources-v1", + "files": [ + { + "path": "cgroup_budget.py", + "bytes": 7977, + "mode": 420, + "sha256": "c7d84f2916401b3d977246b69f94769fdf3c368511af45fb795607cfc199347f" + }, + { + "path": "test_cgroup_budget.py", + "bytes": 7788, + "mode": 420, + "sha256": "e0a85d445d8cf45508802e692ab85c62e2cbee5c815c5555e89bdca337c59ba2" + }, + { + "path": "native_image_protocol.py", + "bytes": 8642, + "mode": 420, + "sha256": "b7705b1b85f24ba296d5565e3981451b58f7a3a9c9f6d79a7bc9b824877eddf5" + }, + { + "path": "test_native_image_protocol.py", + "bytes": 10227, + "mode": 420, + "sha256": "22f6762ad3ebb0e1d689dab8357a9571b591cc25420bf3293654cd7117a201ad" + }, + { + "path": "run_controls.py", + "bytes": 6538, + "mode": 420, + "sha256": "0a0ab3361b9714dcb67a7a2dde7b6e4507c4b2dd09b8131492c5cc2e1d2c3cee" + }, + { + "path": "verify_terminal.py", + "bytes": 8763, + "mode": 420, + "sha256": "f35e2a9804afadf514beced484b02777f4ece92a1a33436afb0f10d82bfcdca9" + }, + { + "path": "test_verify_terminal.py", + "bytes": 9116, + "mode": 420, + "sha256": "6b8166acba4ec1813095f302366429a47decee37daa97eb1484b538a22f44ff1" + } + ] +} diff --git a/tools/installation_provenance/cgroup_budget.py b/tools/installation_provenance/cgroup_budget.py new file mode 100644 index 0000000..106682c --- /dev/null +++ b/tools/installation_provenance/cgroup_budget.py @@ -0,0 +1,179 @@ +"""Read a finite, read-only cgroup-v2 budget through a bounded interface.""" +from dataclasses import asdict, dataclass +from pathlib import Path +import os +import re +import stat +import sys + + +class BudgetRefused(RuntimeError): + pass + + +def require(value, message): + if not value: + raise BudgetRefused(message) + + +def number(raw): + require(type(raw) is str and re.fullmatch(r'(0|[1-9][0-9]*)\n?', raw) is not None, + 'A complete finite nonnegative decimal value is required') + return int(raw.strip()) + + +@dataclass(frozen=True) +class Limits: + strict_memory_bytes: int + page_size: int + cpu_quota: int = 100000 + cpu_period: int = 100000 + maximum_processes: int = 64 + + def __post_init__(self): + require(all(type(value) is int for value in asdict(self).values()), + 'Typed integer limits are required') + require(4096 <= self.page_size <= 65536 and self.page_size & (self.page_size-1) == 0, + 'A supported power-of-two kernel page size is required') + require(self.page_size < self.strict_memory_bytes <= 2_000_000_000, + 'A positive strict memory budget up to the Grant target is required') + require(self.cpu_quota == self.cpu_period == 100000 + and self.maximum_processes == 64, + 'The qualified profile uses one CPU and 64 process slots') + + @property + def hard_memory_bytes(self): + # The kernel can round a memory limit upward to a page boundary. + return ((self.strict_memory_bytes-1)//self.page_size)*self.page_size + + +def read_small(path, maximum=4096): + path = Path(path) + before = path.lstat() + require(stat.S_ISREG(before.st_mode) and path.resolve(strict=True) == path, + 'A physical regular kernel control file is required') + descriptor = os.open(str(path), os.O_RDONLY | os.O_NOFOLLOW) + with os.fdopen(descriptor, 'rb') as stream: + opened = os.fstat(stream.fileno()) + require((opened.st_dev, opened.st_ino) == (before.st_dev, before.st_ino), + 'The opened kernel control file must retain its identity') + raw = stream.read(maximum+1) + require(0 < len(raw) <= maximum, 'A complete bounded kernel control value is required') + after = path.lstat() + require((after.st_dev, after.st_ino) == (before.st_dev, before.st_ino), + 'The kernel control path must retain its identity') + return raw.decode('ascii', 'strict') + + +def verify_mount(mountinfo, membership): + require(membership == '0::/\n', 'A private unified cgroup namespace is required') + matches = [] + for line in mountinfo.splitlines(): + fields = line.split() + if len(fields) >= 10 and fields[4] == '/sys/fs/cgroup': + separator = fields.index('-') if '-' in fields else -1 + require(separator >= 6 and len(fields) >= separator+4, + 'A complete cgroup mountinfo entry is required') + matches.append(fields[separator+1] == 'cgroup2' + and 'ro' in fields[5].split(',') + and 'rw' not in fields[5].split(',')) + require(matches == [True], 'Exactly one read-only cgroup-v2 mount is required') + + +def events(raw): + result = {} + for line in raw.splitlines(): + fields = line.split(' ') + require(len(fields) == 2 and re.fullmatch('[a-z_]+', fields[0]) is not None + and fields[0] not in result, 'Unique complete memory event rows are required') + result[fields[0]] = number(fields[1]) + require({'low', 'high', 'max', 'oom', 'oom_kill'} <= set(result), + 'The kernel memory pressure and OOM event counters are required') + return result + + +@dataclass(frozen=True) +class Snapshot: + memory_max: int + memory_current: int + memory_peak: int + swap_max: int + swap_current: int + cpu_max: str + cpu_burst: int + pids_max: int + pids_current: int + memory_events: dict + + +def read_snapshot(read): + return Snapshot( + memory_max=number(read('memory.max')), + memory_current=number(read('memory.current')), + memory_peak=number(read('memory.peak')), + swap_max=number(read('memory.swap.max')), + swap_current=number(read('memory.swap.current')), + cpu_max=read('cpu.max'), cpu_burst=number(read('cpu.max.burst')), + pids_max=number(read('pids.max')), pids_current=number(read('pids.current')), + memory_events=events(read('memory.events'))) + + +def verify_snapshot(snapshot, limits): + require(isinstance(snapshot, Snapshot) and isinstance(limits, Limits), + 'Typed kernel snapshot and declared limits are required') + counters = (snapshot.memory_max, snapshot.memory_current, snapshot.memory_peak, + snapshot.swap_max, snapshot.swap_current, snapshot.cpu_burst, + snapshot.pids_max, snapshot.pids_current) + require(all(type(value) is int and value >= 0 for value in counters) + and type(snapshot.cpu_max) is str, + 'Complete nonnegative integer kernel counters are required') + require(type(snapshot.memory_events) is dict + and {'low', 'high', 'max', 'oom', 'oom_kill'} <= set(snapshot.memory_events) + and all(type(key) is str and re.fullmatch('[a-z_]+', key) is not None + and type(value) is int and value >= 0 + for key, value in snapshot.memory_events.items()), + 'Complete typed pressure and OOM event counters are required') + require(snapshot.memory_max == limits.hard_memory_bytes, + 'The exact page-aligned strict memory ceiling must be active') + require(0 < snapshot.memory_current <= snapshot.memory_peak < limits.strict_memory_bytes, + 'Positive current and peak memory must fit the strict byte budget') + require(snapshot.swap_max == snapshot.swap_current == 0, + 'The kernel must enforce zero swap for this profile') + require(snapshot.cpu_max == f'{limits.cpu_quota} {limits.cpu_period}\n' + and snapshot.cpu_burst == 0, 'The exact one-CPU quota with zero burst is required') + require(snapshot.pids_max == limits.maximum_processes + and 0 < snapshot.pids_current <= snapshot.pids_max, + 'The exact finite process ceiling must be active') + require(all(value == 0 for value in snapshot.memory_events.values()), + 'A successful control run must retain zero memory pressure and OOM events') + return snapshot + + +def compare_snapshots(before, after, limits): + verify_snapshot(before, limits) + verify_snapshot(after, limits) + require(after.memory_peak >= before.memory_peak, + 'The cgroup lifetime peak must retain its earlier high-water mark') + require(set(before.memory_events) == set(after.memory_events), + 'The kernel event schema must remain stable across the workload') + return dict(scope='current-cgroup-and-descendants-through-final-snapshot-v1', + limits=asdict(limits), hard_memory_bytes=limits.hard_memory_bytes, + before=asdict(before), after=asdict(after), + compiler_process_rss_accepted=False, complete_Grant_build_accepted=False, + lifetime_container_enforcement_requires_external_terminal_inspection=True) + + +class CurrentCgroup: + """The production perimeter uses fixed kernel paths; fixtures use pure functions.""" + def __init__(self, limits): + require(sys.platform == 'linux', 'This provider requires the Linux kernel') + require(os.sysconf('SC_PAGE_SIZE') == limits.page_size, + 'The declared page size must match the running kernel') + self.limits = limits + + def snapshot(self): + process = Path('/proc') / str(os.getpid()) + verify_mount(read_small(process/'mountinfo', 1024*1024), + read_small(process/'cgroup')) + return verify_snapshot(read_snapshot( + lambda name: read_small(Path('/sys/fs/cgroup')/name)), self.limits) diff --git a/tools/installation_provenance/evidence/README.md b/tools/installation_provenance/evidence/README.md new file mode 100644 index 0000000..0c2e1a3 --- /dev/null +++ b/tools/installation_provenance/evidence/README.md @@ -0,0 +1,37 @@ +# Executed Linux control evidence + +The October 20 bundle records +[run 39435844814](https://github.com/amberframework/memory_budget/actions/runs/39435844814) +at source `98ce154b71f6896eff941d8662a9288e08eddc5a`. The ZIP is the original +42-file GitHub artifact, verified against its published SHA256 +`4562b5d0e1398f63a725bde4b180ce148101ed3846cf8b1ccecb04346389a0a3`. +The adjacent JSON summarizes the executed scopes and remaining gates. + +Both ordinary and optimized Python ran 58 cases with zero failures, errors, +skips, expected failures, or unexpected successes. Nine runner admission +cases passed. A separate admitted 128 MiB allocation probe was killed in its +64 MiB container with exit 137 and the actual Docker OOM marker. An uncapped +container refused with exit 2 before loading its tests. All five owned +containers, including the independent terminal reader, were removed and +read back absent. + +The archive includes the source-bound inner results, Docker image and +container inspections, actual exits, test logs, and cleanup records. Extract +a hash-verified copy into a private review directory. The four case results +and `TERMINAL_ACCEPTANCE.json` are under +`memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39435844814-1/`. +The hosted runner identity is under `_temp/atlas-linux-runner.json`. + +For a replay with a verified Python runtime and this exact source, run the +existing `verify_terminal.py` with `--evidence` pointing to that extracted +case directory and `--pins-sha256` +`15e27eea749e5d08f7d41256515b078f256c89fed5c49647c09dc99b99406eae`. +It rechecks the source roster, numerical budgets, complete cohorts, image, +commands and terminal states. The cleanup records separately identify each +removed container. Replaying recorded evidence retains its original run +identity; a fresh kernel qualification creates its own workload and results. + +These are control-suite measurements, with charged cgroup peaks through +their final snapshots. Compiler RSS, complete-build descendant coverage, +shared-page ownership, ordinary SDK/compiler installation, and clean-device +acceptance remain required. Grant's final 300/500-model matrix remains 0/144. diff --git a/tools/installation_provenance/evidence/linux-controls-20261020-98ce154.json b/tools/installation_provenance/evidence/linux-controls-20261020-98ce154.json new file mode 100644 index 0000000..85d547e --- /dev/null +++ b/tools/installation_provenance/evidence/linux-controls-20261020-98ce154.json @@ -0,0 +1,88 @@ +{ + "format": "atlas-linux-kernel-control-evidence-v1", + "source_commit": "98ce154b71f6896eff941d8662a9288e08eddc5a", + "workflow_url": "https://github.com/amberframework/memory_budget/actions/runs/39435844814", + "archive": { + "file": "linux-controls-20261020-98ce154.zip", + "sha256": "4562b5d0e1398f63a725bde4b180ce148101ed3846cf8b1ccecb04346389a0a3", + "bytes": 50197, + "raw_file_count": 42 + }, + "source_manifest_sha256": "15e27eea749e5d08f7d41256515b078f256c89fed5c49647c09dc99b99406eae", + "cohorts": [ + { + "mode": "ordinary", + "tests": 58, + "peak_bytes": 21069824, + "strict_budget_bytes": 536870912 + }, + { + "mode": "optimized", + "tests": 58, + "peak_bytes": 20594688, + "strict_budget_bytes": 536870912 + } + ], + "profile_admission_cases": 9, + "container_cases": [ + { + "case": "ordinary", + "container_id": "bfe1cff7a2aad0bee393c98dc730fa25148bede39b0ebd4e28a94420af7b5da7", + "exit_code": 0, + "OOMKilled": false + }, + { + "case": "optimized", + "container_id": "e314ae8fba4848418ba1ba4d8197ec4f4b90347b468724c10a765799d9ba20c2", + "exit_code": 0, + "OOMKilled": false + }, + { + "case": "oom", + "container_id": "e50ca67544a7e3a07f2686384a4d6b5f6d265c2b79b205aa36b3bd4f77cabb82", + "exit_code": 137, + "OOMKilled": true + }, + { + "case": "uncapped", + "container_id": "5f870fde8fc794b3de5d610cde6f9941b982ca6b534ed11f72468512531c447b", + "exit_code": 2, + "OOMKilled": false + } + ], + "removed_owned_containers": 5, + "changed_actual_snapshot_controls": [ + { + "case": "empty_events", + "rejected": true, + "reason": "Complete typed pressure and OOM event counters are required" + }, + { + "case": "missing_oom_kill", + "rejected": true, + "reason": "Complete typed pressure and OOM event counters are required" + }, + { + "case": "boolean_measurements", + "rejected": true, + "reason": "Complete nonnegative integer kernel counters are required" + }, + { + "case": "float_measurements", + "rejected": true, + "reason": "Complete nonnegative integer kernel counters are required" + } + ], + "actual_Crystal_compilations": 0, + "actual_Grant_cells": 0, + "installed_SDK_accepted": false, + "clean_device_installation_accepted": false, + "complete_Grant_build_provider_qualified": false, + "remaining_build_provider_gates": [ + "short-lived and fork-exec descendants", + "membership and sibling isolation", + "shared/migrated memory-charge boundaries", + "complete build and terminal window", + "compiler-process RSS qualification" + ] +} diff --git a/tools/installation_provenance/evidence/linux-controls-20261020-98ce154.zip b/tools/installation_provenance/evidence/linux-controls-20261020-98ce154.zip new file mode 100644 index 0000000..bf0fe8d Binary files /dev/null and b/tools/installation_provenance/evidence/linux-controls-20261020-98ce154.zip differ diff --git a/tools/installation_provenance/native_image_protocol.py b/tools/installation_provenance/native_image_protocol.py new file mode 100644 index 0000000..80419d3 --- /dev/null +++ b/tools/installation_provenance/native_image_protocol.py @@ -0,0 +1,180 @@ +"""Validate a source-bound worker boundary before publishing its acknowledgment.""" +from dataclasses import dataclass +from pathlib import Path +import datetime +import hashlib +import json +import os +import re +import stat + +SCOPE = 'kernel-file-mappings-at-stable-worker-boundary-v1' +CASES = ('original', 'payload_damaged', 'payload_restored', 'signature_damaged', + 'signature_restored', 'key_damaged', 'key_restored') + + +def require(value, message): + if not value: + raise RuntimeError(message) + + +def signature(value): + return (value.st_dev, value.st_ino, value.st_mode, value.st_size, + value.st_mtime_ns, value.st_ctime_ns) + + +@dataclass(frozen=True) +class ExpectedWorker: + pid: int + birth: str + parent: int + group: int + uid: int + ruby_path: str + selected_case: str + nonce: str + + def __post_init__(self): + require(type(self.pid) is int and self.pid > 1 + and type(self.parent) is int and self.parent > 1 + and self.group == self.pid and type(self.group) is int + and type(self.uid) is int and self.uid == 501, + 'Exact ordinary-owner worker PID, parent and created group required') + require(type(self.birth) is str and 0 < len(self.birth) <= 128 + and type(self.ruby_path) is str and Path(self.ruby_path).is_absolute() + and self.selected_case in CASES and type(self.nonce) is str + and re.fullmatch('[0-9a-f]{64}', self.nonce) is not None, + 'Exact worker birth, Ruby path, original case and nonce required') + + +@dataclass(frozen=True) +class SourceAlias: + path: str + link_text: str + resolved_path: str + + +@dataclass(frozen=True) +class PhysicalImage: + path: str + bytes: int + sha256: str + mode: int + + def __post_init__(self): + require(type(self.path) is str and Path(self.path).is_absolute() + and type(self.bytes) is int and 0 < self.bytes <= 128*2**20 + and type(self.mode) is int and 0 <= self.mode <= 0o7777 + and type(self.sha256) is str + and re.fullmatch('[0-9a-f]{64}', self.sha256) is not None, + 'Bounded exact physical image source reference required') + + +def parse_ready(raw, expected, now): + require(type(raw) is bytes and 0 < len(raw) <= 16_384, + 'Complete bounded ready record required') + value = json.loads(raw.decode('utf-8', 'strict')) + require(type(value) is dict and set(value) == { + 'format', 'scope', 'pid', 'uid', 'selected_case', 'nonce', 'Ruby_path', + 'observed_at', 'foreign_signals'}, 'Exact ready record schema required') + require(value['format'] == 'atlas-native-image-boundary-ready-v1' + and value['scope'] == SCOPE and type(value['pid']) is int + and value['pid'] == expected.pid and type(value['uid']) is int + and value['uid'] == expected.uid and value['nonce'] == expected.nonce + and value['selected_case'] == expected.selected_case + and value['Ruby_path'] == expected.ruby_path + and type(value['foreign_signals']) is int and value['foreign_signals'] == 0, + 'Exact owned ready identity, case, source and signal boundary required') + observed = datetime.datetime.fromisoformat(value['observed_at'].replace('Z', '+00:00')) + require(observed.tzinfo is not None and now.tzinfo is not None + and observed.utcoffset() == now.utcoffset() == datetime.timedelta(0) + and 0 <= (now-observed).total_seconds() <= 8, + 'Fresh aware UTC worker boundary required') + return value + + +def verify_actor(rows, expected): + value = rows.get(expected.pid) + require(type(value) is dict and value.get('birth') == expected.birth + and value.get('parent') == expected.parent and value.get('group') == expected.group + and value.get('real_uid') == value.get('effective_uid') == expected.uid + and value.get('uid_semantics') == 'real-user-id', + 'Current exact worker birth, ancestry, group and qualified real/effective UID required') + + +def parse_kernel_mappings(raw, expected_pid): + require(type(raw) is bytes and 0 < len(raw) <= 256*2**10, + 'Complete bounded raw kernel mapping output required') + lines = raw.decode('utf-8', 'strict').splitlines() + require(lines and lines[0] == 'p'+str(expected_pid) + and all(line.startswith('n/') and 1 < len(line) <= 4097 for line in lines[1:]) + and 0 < len(lines)-1 <= 1024, 'Exact one-PID lsof-Fpn kernel file roster required') + return sorted({line[1:] for line in lines[1:]}) + + +def resolve_admitted_path(path, list_of_aliases): + path = Path(path) + require(path.is_absolute(), 'Absolute observed image path required') + aliases = {item.path: item for item in list_of_aliases} + require(len(aliases) == len(list_of_aliases), 'Unique admitted alias roster required') + for component in list(reversed(path.parents)) + [path]: + if component.is_symlink(): + expected = aliases.get(str(component)) + require(expected is not None and os.readlink(component) == expected.link_text + and str(component.resolve(strict=True)) == expected.resolved_path, + 'Every observed image alias needs its exact literal and physical authority') + return path.resolve(strict=True) + + +def verify_physical_image(path, expected): + path = Path(path) + before = path.lstat() + require(str(path) == expected.path and path.resolve(strict=True) == path + and stat.S_ISREG(before.st_mode) and before.st_size == expected.bytes + and stat.S_IMODE(before.st_mode) == expected.mode, + 'Exact declared physical image kind, size and mode required') + digest = hashlib.sha256() + descriptor = os.open(str(path), os.O_RDONLY | os.O_NOFOLLOW) + with os.fdopen(descriptor, 'rb') as stream: + opened = os.fstat(stream.fileno()) + require(signature(before) == signature(opened), 'Stable opened image descriptor required') + for block in iter(lambda: stream.read(65536), b''): + digest.update(block) + require(signature(opened) == signature(os.fstat(stream.fileno())), + 'Physical image descriptor changed during streaming verification') + require(signature(before) == signature(path.lstat()) and path.resolve(strict=True) == path + and digest.hexdigest() == expected.sha256, 'Exact stable physical image bytes required') + return dict(path=str(path), bytes=before.st_size, mode=expected.mode, + sha256=expected.sha256, physical_source_bytes_verified=True) + + +def qualify_frame(ready_raw, kernel_raw, expected, rows_before, read_rows_after, + physical_images, list_of_aliases, utc_now): + ready = parse_ready(ready_raw, expected, utc_now()) + verify_actor(rows_before, expected) + names = parse_kernel_mappings(kernel_raw, expected.pid) + physical, system = [], [] + physical_bytes = 0 + for name in names: + if name.startswith(('/System/', '/usr/lib/')): + system.append(dict(path=name, physical_source_bytes_verified=False, + scope='Operating-system image/shared-cache boundary; separate platform qualification required')) + continue + path = resolve_admitted_path(name, list_of_aliases) + reference = physical_images.get(str(path)) + require(isinstance(reference, PhysicalImage), 'Each observed physical image needs its admitted source reference') + physical_bytes += reference.bytes + require(physical_bytes <= 128*2**20, 'Complete physical image verification fits128MiB') + physical.append(dict(verify_physical_image(path, reference), observed_path=name)) + require(expected.ruby_path in {item['path'] for item in physical}, + 'The observed worker must map the exact admitted Ruby executable') + verify_actor(read_rows_after(), expected) + parse_ready(ready_raw, expected, utc_now()) + raw_hash = hashlib.sha256(kernel_raw).hexdigest() + return dict(passed=True, scope=SCOPE, ready=ready, raw_frame_sha256=raw_hash, + physical_images=physical, system_images=system, + sampled_kernel_mapping_only=True, complete_provider_profile_accepted=False, + quantitative_acceptance=False, foreign_signals=0, + acknowledgment=dict(format='atlas-native-image-boundary-ack-v1', scope=SCOPE, + passed=True, nonce=expected.nonce, pid=expected.pid, + selected_case=expected.selected_case, raw_frame_sha256=raw_hash)) diff --git a/tools/installation_provenance/record_linux_runner.py b/tools/installation_provenance/record_linux_runner.py new file mode 100644 index 0000000..ebd8269 --- /dev/null +++ b/tools/installation_provenance/record_linux_runner.py @@ -0,0 +1,181 @@ +"""Record a read-only runner candidate and admit only a reviewed exact profile.""" + +import argparse +import datetime +import hashlib +import http.client +import json +import os +from pathlib import Path +import re +import shutil +import socket +import stat +import sys + + +def require(value, message): + if not value: + raise RuntimeError(message) + + +def file_identity(path): + path = Path(path).resolve(strict=True) + before = path.stat() + require(stat.S_ISREG(before.st_mode) and 0 < before.st_size <= 256 * 2**20, + "A bounded physical executable file is required: " + str(path)) + digest = hashlib.sha256() + with path.open("rb") as stream: + for block in iter(lambda: stream.read(65536), b""): + digest.update(block) + after = path.stat() + fields = lambda value: (value.st_dev, value.st_ino, value.st_mode, value.st_size, + value.st_mtime_ns, value.st_ctime_ns) + require(fields(before) == fields(after), "Executable identity changed while reading") + return {"path": str(path), "bytes": before.st_size, "sha256": digest.hexdigest()} + + +def docker_api(path): + endpoint = Path("/var/run/docker.sock").resolve(strict=True) + before = endpoint.stat() + require(stat.S_ISSOCK(before.st_mode), "A local Docker API socket is required") + with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as connection: + connection.settimeout(5) + connection.connect(str(endpoint)) + connection.sendall(("GET " + path + " HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n").encode("ascii")) + response = http.client.HTTPResponse(connection) + response.begin() + require(response.status == 200, "Read-only Docker metadata request failed") + raw = response.read(2**20 + 1) + require(0 < len(raw) <= 2**20, "Bounded Docker metadata is required") + after = endpoint.stat() + require((before.st_dev, before.st_ino) == (after.st_dev, after.st_ino), + "The local Docker API socket must retain its identity") + value = json.loads(raw) + require(isinstance(value, dict), "Docker metadata needs one object") + return value + + +def process_start_time(pid): + raw = Path("/proc/" + str(pid) + "/stat").read_text() + require(len(raw) <= 16384, "Bounded process identity is required") + return raw.rsplit(")", 1)[1].split()[19] + + +def package_versions(): + raw = Path("/var/lib/dpkg/status").read_text() + require(len(raw.encode()) <= 16 * 2**20, "Bounded package metadata is required") + selected = {"bash", "sudo", "coreutils", "python3.12-minimal", "docker-ce-cli", + "docker-ce", "moby-cli", "moby-engine", "containerd.io"} + result = {} + for paragraph in raw.split("\n\n"): + fields = dict(line.split(": ", 1) for line in paragraph.splitlines() + if line and not line[0].isspace() and ": " in line) + if fields.get("Package") in selected and fields.get("Status") == "install ok installed": + result[fields["Package"]] = fields["Version"] + require({"bash", "sudo", "coreutils", "python3.12-minimal"} <= set(result), + "The directly used bootstrap package versions are required") + return result + + +def candidate(): + require(sys.platform == "linux" and os.geteuid() == 0, + "Read-only Linux metadata collection needs access to the daemon executable") + docker = shutil.which("docker") + require(docker is not None, "The installed Docker client is required") + pid_text = Path("/run/docker.pid").read_text().strip() + require(re.fullmatch("[1-9][0-9]{0,8}", pid_text) is not None, + "The running Docker daemon PID is required") + pid = int(pid_text) + started = process_start_time(pid) + daemon = file_identity("/proc/" + str(pid) + "/exe") + require(Path(daemon["path"]).name == "dockerd", "The recorded process must be dockerd") + version = docker_api("/version") + info = docker_api("/info") + tools = {key: file_identity(path) for key, path in { + "docker_cli": docker, "sha256sum": "/usr/bin/sha256sum", "timeout": "/usr/bin/timeout", + "bash": "/usr/bin/bash", "sudo": "/usr/bin/sudo", "python": sys.executable, + }.items()} + tools["docker_daemon"] = daemon + require(process_start_time(pid) == started, "The running daemon identity must remain stable") + require(re.fullmatch(r"[0-9]+\.[0-9]+\.[0-9]+(?:[-+][A-Za-z0-9_.-]+)?", version["Version"]) is not None, + "A complete Docker server version is required") + profile = {key + "_sha256": value["sha256"] for key, value in tools.items()} + profile.update({ + "docker_server_version": version["Version"], "docker_server_git_commit": version["GitCommit"], + "docker_api_version": version["ApiVersion"], "kernel_release": os.uname().release, + "machine": os.uname().machine, "runner_image_os": os.environ.get("ImageOS", ""), + "runner_image_version": os.environ.get("ImageVersion", ""), + "cgroup_version": str(info["CgroupVersion"]), "cgroup_driver": info["CgroupDriver"], + "memory_limit_supported": info["MemoryLimit"], "swap_limit_supported": info["SwapLimit"], + "package_versions": package_versions(), + }) + require(all(value != "" for value in profile.values()), "Complete observed runner metadata is required") + require(profile["machine"] == "x86_64" and profile["cgroup_version"] == "2" + and profile["memory_limit_supported"] is True and profile["swap_limit_supported"] is True, + "The proposed runner needs x86_64 cgroup-v2 memory and swap enforcement") + return {"profile": profile, "tools": tools, "daemon_pid": pid, + "daemon_start_time_ticks": started, "python_version": sys.version} + + +def reviewed_profile(expected, observed): + require(expected.get("format") == "atlas-linux-runner-profile-set-v1", + "The reviewed profile-set format is required") + entries = expected.get("profiles") + require(isinstance(entries, list) and 1 <= len(entries) <= 4, + "A nonempty finite reviewed profile roster is required") + encoded = [] + for entry in entries: + require(isinstance(entry, dict) and entry.get("format") == "atlas-linux-runner-profile-v1" + and isinstance(entry.get("profile"), dict), "Every reviewed profile needs its exact format") + encoded.append(json.dumps(entry["profile"], sort_keys=True, separators=(",", ":"))) + require(len(set(encoded)) == len(encoded), "Unique reviewed profiles are required") + actual = json.dumps(observed, sort_keys=True, separators=(",", ":")) + matches = [entry for entry, identity in zip(entries, encoded) if identity == actual] + require(len(matches) == 1, "Observed runner must match one complete reviewed profile") + return matches[0] + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", required=True) + parser.add_argument("--expected-profile", required=True) + parser.add_argument("--github-output", required=True) + parser.add_argument("--github-env", required=True) + args = parser.parse_args() + result = {"format": "atlas-linux-runner-candidate-v1", "admitted": False, + "actual_container_workloads": 0, "actual_Grant_cells": 0, + "observed_at": datetime.datetime.now(datetime.timezone.utc).isoformat(), + "collector": file_identity(__file__)} + try: + result.update(candidate()) + expected_path = Path(args.expected_profile) + if expected_path.is_file(): + expected = reviewed_profile(json.loads(expected_path.read_text()), result["profile"]) + result.update(admitted=True, state="reviewed-profile-matched") + exports = { + "ATLAS_DOCKER_CLI_SHA256": expected["profile"]["docker_cli_sha256"], + "ATLAS_DOCKER_SERVER_VERSION": expected["profile"]["docker_server_version"], + "ATLAS_SHA256SUM_SHA256": expected["profile"]["sha256sum_sha256"], + "ATLAS_TIMEOUT_SHA256": expected["profile"]["timeout_sha256"], + } + require(all(isinstance(value, str) and "\n" not in value and "\r" not in value + for value in exports.values()), "Single-line reviewed profile values are required") + with Path(args.github_env).open("a") as stream: + for key, value in exports.items(): + stream.write(key + "=" + value + "\n") + else: + result["state"] = "candidate-recorded; reviewed-profile-and-actual-controls-pending" + except Exception as error: + result.update(state="refused-before-container-workloads", error=str(error)) + raise + finally: + Path(args.output).write_text(json.dumps(result, indent=2) + "\n") + with Path(args.github_output).open("a") as stream: + stream.write("admitted=" + str(result["admitted"]).lower() + "\n") + print(json.dumps(result, indent=2)) + return 0 if result["admitted"] else 2 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/installation_provenance/run_ci.sh b/tools/installation_provenance/run_ci.sh new file mode 100644 index 0000000..7f9659d --- /dev/null +++ b/tools/installation_provenance/run_ci.sh @@ -0,0 +1,99 @@ +#!/usr/bin/env bash +set -euo pipefail + +# The reviewed runner profile supplies these exact bootstrap tool pins. +: "${ATLAS_DOCKER_CLI_SHA256:?Reviewed Docker CLI SHA256 required}" +: "${ATLAS_DOCKER_SERVER_VERSION:?Reviewed Docker daemon version required}" +: "${ATLAS_SHA256SUM_SHA256:?Reviewed sha256sum tool SHA256 required}" +: "${ATLAS_TIMEOUT_SHA256:?Reviewed timeout tool SHA256 required}" +: "${ATLAS_SOURCE_PINS_SHA256:?Reviewed executable source-manifest SHA256 required}" +: "${ATLAS_TERMINAL_READER_SHA256:?Reviewed terminal reader SHA256 required}" +: "${GITHUB_RUN_ID:?Exact CI run identity required}" +: "${GITHUB_RUN_ATTEMPT:?Exact CI attempt required}" + +[[ "$GITHUB_RUN_ID" =~ ^[0-9]+$ && "$GITHUB_RUN_ATTEMPT" =~ ^[0-9]+$ ]] +source_root="$(cd -- "$(dirname -- "$0")" && pwd -P)" +docker_cli="$(command -v docker)" +[[ "$docker_cli" = /* && -f "$docker_cli" ]] +printf '%s %s\n' "$ATLAS_SHA256SUM_SHA256" /usr/bin/sha256sum | /usr/bin/sha256sum --check --strict +printf '%s %s\n' "$ATLAS_TIMEOUT_SHA256" /usr/bin/timeout | /usr/bin/sha256sum --check --strict +printf '%s %s\n' "$ATLAS_DOCKER_CLI_SHA256" "$docker_cli" | /usr/bin/sha256sum --check --strict +printf '%s %s\n' "$ATLAS_SOURCE_PINS_SHA256" "$source_root/SOURCE_PINS.json" | /usr/bin/sha256sum --check --strict +printf '%s %s\n' "$ATLAS_TERMINAL_READER_SHA256" "$source_root/verify_terminal.py" | /usr/bin/sha256sum --check --strict +[[ "$("$docker_cli" version --format '{{.Server.Version}}')" == "$ATLAS_DOCKER_SERVER_VERSION" ]] +# The pinned x86_64 Linux profile uses4096-byte pages; inner readers verify it. + +image='python:3.12.10-slim@sha256:fd95fa221297a88e1cf49c55ec1828edd7c5a428187e67b5d1805692d11588db' +evidence="$source_root/ci-evidence-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}" +mkdir -- "$evidence" +chmod 0777 -- "$evidence" +"$docker_cli" version > "$evidence/docker-version.txt" +"$docker_cli" pull "$image" +"$docker_cli" image inspect "$image" > "$evidence/image-inspect.json" +containers=() +cleanup() { + local status=$? + for identity in "${containers[@]}"; do + "$docker_cli" inspect "$identity" > "$evidence/${identity}.cleanup-before.json" || status=1 + "$docker_cli" rm --force "$identity" > "$evidence/${identity}.cleanup.txt" || status=1 + "$docker_cli" ps --all --no-trunc --filter "id=$identity" --format '{{.ID}}' \ + > "$evidence/${identity}.cleanup-after.txt" || status=1 + [[ ! -s "$evidence/${identity}.cleanup-after.txt" ]] || status=1 + done + exit "$status" +} +trap cleanup EXIT + +for selected in ordinary optimized oom uncapped; do + profile=(--memory 536866816 --memory-swap 536866816) + mode=controls + strict=536870912 + optimization=() + [[ "$selected" != optimized ]] || optimization=(-O) + if [[ "$selected" == oom ]]; then + profile=(--memory 67104768 --memory-swap 67104768) + mode=oom-probe + strict=67108864 + elif [[ "$selected" == uncapped ]]; then + profile=() + mode=uncapped-probe + fi + identity="$("$docker_cli" create --name "atlas-install-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}-${selected}" \ + --network none --cpus 1 --pids-limit 64 --cgroupns private --read-only \ + --cap-drop ALL --security-opt no-new-privileges --user 501:501 \ + --tmpfs /tmp:rw,nosuid,nodev,noexec,size=384m,mode=1777 \ + --mount "type=bind,src=$source_root,dst=/source,readonly" \ + --mount "type=bind,src=$evidence,dst=/evidence" \ + "${profile[@]}" "$image" python3 -I -S -B "${optimization[@]}" /source/run_controls.py \ + --pins-sha256 "$ATLAS_SOURCE_PINS_SHA256" --mode "$mode" \ + --strict-memory-bytes "$strict" --output "/evidence/${selected}.json")" + [[ "$identity" =~ ^[0-9a-f]{64}$ ]] + containers+=("$identity") + status=0 + /usr/bin/timeout --foreground --kill-after=10s 90s "$docker_cli" start --attach "$identity" \ + > "$evidence/${selected}.stdout.txt" 2> "$evidence/${selected}.stderr.txt" || status=$? + printf '%s\n' "$status" > "$evidence/${selected}.client-exit.txt" + "$docker_cli" inspect "$identity" > "$evidence/${selected}.inspect.json" + expected=0 + [[ "$selected" != oom ]] || expected=137 + [[ "$selected" != uncapped ]] || expected=2 + [[ "$status" == "$expected" ]] + [[ "$("$docker_cli" inspect --format '{{.State.Status}}' "$identity")" == exited ]] + # Actual kernel and inner results determine acceptance below. +done + +identity="$("$docker_cli" create --name "atlas-install-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}-terminal-reader" \ + --network none --cpus 1 --memory 67104768 --memory-swap 67104768 \ + --pids-limit 64 --read-only --cap-drop ALL --security-opt no-new-privileges --user 501:501 \ + --mount "type=bind,src=$source_root,dst=/source,readonly" \ + --mount "type=bind,src=$evidence,dst=/evidence" \ + "$image" python3 -I -S -B /source/verify_terminal.py \ + --evidence /evidence --pins-sha256 "$ATLAS_SOURCE_PINS_SHA256")" +[[ "$identity" =~ ^[0-9a-f]{64}$ ]] +containers+=("$identity") +status=0 +/usr/bin/timeout --foreground --kill-after=10s 30s "$docker_cli" start --attach "$identity" \ + > "$evidence/terminal-reader.stdout.txt" 2> "$evidence/terminal-reader.stderr.txt" || status=$? +"$docker_cli" inspect "$identity" > "$evidence/terminal-reader.inspect.json" +[[ "$status" == 0 ]] +[[ "$("$docker_cli" inspect --format '{{.State.Status}} {{.State.ExitCode}} {{.State.OOMKilled}}' "$identity")" == 'exited 0 false' ]] diff --git a/tools/installation_provenance/run_controls.py b/tools/installation_provenance/run_controls.py new file mode 100644 index 0000000..468b6a2 --- /dev/null +++ b/tools/installation_provenance/run_controls.py @@ -0,0 +1,128 @@ +"""Run the installation protocol controls inside an externally fenced container.""" +from pathlib import Path +import argparse +import datetime +import hashlib +import io +import json +import os +import re +import stat +import sys +import unittest + + +def require(value, message): + if not value: + raise RuntimeError(message) + + +def digest(path): + result = hashlib.sha256() + with Path(path).open('rb') as stream: + for block in iter(lambda: stream.read(65536), b''): + result.update(block) + return result.hexdigest() + + +def verify_sources(root, manifest, expected): + require(re.fullmatch('[0-9a-f]{64}', expected) is not None and digest(manifest) == expected, + 'The caller must supply the exact approved source-manifest digest') + require(manifest.stat().st_size <= 16384, 'The source manifest must fit 16 KiB') + packet = json.loads(manifest.read_text()) + require(packet['format'] == 'atlas-linux-control-sources-v1' + and 1 <= len(packet['files']) <= 16, 'A finite versioned source roster is required') + names = set() + for row in packet['files']: + name = row['path'] + require(type(name) is str and '/' not in name and name not in ('.', '..') + and name not in names, 'Unique source basenames are required') + names.add(name) + path = root/name + status = path.lstat() + require(path.resolve(strict=True) == path and stat.S_ISREG(status.st_mode) + and status.st_size == row['bytes'] <= 1024*1024 + and stat.S_IMODE(status.st_mode) == row['mode'] + and digest(path) == row['sha256'], 'An approved physical source changed: '+name) + require(names == {'cgroup_budget.py', 'test_cgroup_budget.py', 'native_image_protocol.py', + 'test_native_image_protocol.py', 'run_controls.py', + 'verify_terminal.py', 'test_verify_terminal.py'}, + 'The exact complete executable source roster is required') + return packet + + +class BoundedText(io.StringIO): + def write(self, value): + require(self.tell()+len(value) <= 128*1024, 'The complete test log must fit 128 KiB') + return super().write(value) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--pins-sha256', required=True) + parser.add_argument('--mode', choices=('controls', 'oom-probe', 'uncapped-probe'), required=True) + parser.add_argument('--strict-memory-bytes', required=True, type=int) + parser.add_argument('--output', required=True) + arguments = parser.parse_args() + root = Path(__file__).resolve().parent + output = Path(arguments.output) + require(output.is_absolute() and output.parent.resolve(strict=True) == output.parent, + 'A physical absolute output directory is required') + sources = verify_sources(root, root/'SOURCE_PINS.json', arguments.pins_sha256) + sys.path.insert(0, str(root)) + import cgroup_budget as budget + report = dict(format='atlas-linux-installation-control-result-v1', passed=False, + mode=arguments.mode, started_at=datetime.datetime.now(datetime.timezone.utc).isoformat(), + source_manifest_sha256=arguments.pins_sha256, python_version=sys.version, + python_executable=str(Path(sys.executable).resolve()), + python_sha256=digest(Path(sys.executable).resolve()), + kernel=os.uname().release, platform=os.uname().machine, + actual_Homebrew_commands=0, actual_Crystal_compilations=0, + actual_Grant_cells=0, source_files=len(sources['files'])) + try: + limits = budget.Limits(arguments.strict_memory_bytes, os.sysconf('SC_PAGE_SIZE')) + provider = budget.CurrentCgroup(limits) + before = provider.snapshot() + except budget.BudgetRefused as error: + report.update(refused_before_workload=True, reason=str(error), tests_run=0) + output.write_text(json.dumps(report, indent=2)+'\n') + return 2 + require(arguments.mode != 'uncapped-probe', 'The uncapped negative probe unexpectedly passed admission') + if arguments.mode == 'oom-probe': + require(arguments.strict_memory_bytes == 64*2**20, 'The OOM control uses its exact 64 MiB budget') + report.update(admitted=True, before=budget.asdict(before), expected_termination='kernel-cgroup-OOM') + output.write_text(json.dumps(report, indent=2)+'\n') + print('ATLAS_OOM_PROBE_ADMITTED', flush=True) + allocation = bytearray(128*2**20) + for offset in range(0, len(allocation), limits.page_size): + allocation[offset] = 1 + require(len(allocation) == 0, 'The kernel OOM control unexpectedly completed its128MiB allocation') + require(arguments.strict_memory_bytes == 512*2**20, 'The ordinary controls use their exact 512 MiB budget') + import test_cgroup_budget + import test_native_image_protocol + import test_verify_terminal + suite = unittest.TestSuite(unittest.defaultTestLoader.loadTestsFromModule(module) + for module in (test_cgroup_budget, test_native_image_protocol, + test_verify_terminal)) + require(suite.countTestCases() == 58, 'The exact 58 authored controls are required') + stream = BoundedText() + result = unittest.TextTestRunner(stream=stream, verbosity=2).run(suite) + verify_sources(root, root/'SOURCE_PINS.json', arguments.pins_sha256) + after = provider.snapshot() + report.update(budget.compare_snapshots(before, after, limits), + tests_run=result.testsRun, failures=len(result.failures), errors=len(result.errors), + skipped=len(result.skipped), expected_failures=len(result.expectedFailures), + unexpected_successes=len(result.unexpectedSuccesses), + optimized_python=not __debug__, log=stream.getvalue(), + finished_at=datetime.datetime.now(datetime.timezone.utc).isoformat()) + report['passed'] = (result.wasSuccessful() and result.testsRun == 58 + and not result.skipped and not result.expectedFailures + and not result.unexpectedSuccesses) + output.write_text(json.dumps(report, indent=2)+'\n') + print(json.dumps({key: report[key] for key in ('passed', 'tests_run', 'failures', 'errors', + 'optimized_python', 'hard_memory_bytes')})) + return 0 if report['passed'] else 1 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/tools/installation_provenance/runner_profile.json b/tools/installation_provenance/runner_profile.json new file mode 100644 index 0000000..ebde098 --- /dev/null +++ b/tools/installation_provenance/runner_profile.json @@ -0,0 +1,87 @@ +{ + "format": "atlas-linux-runner-profile-set-v1", + "profiles": [ + { + "format": "atlas-linux-runner-profile-v1", + "profile": { + "docker_cli_sha256": "6435ff9214bf8e0931078fb0980809728cac0a54a526d4f28a26d3e48132b58d", + "sha256sum_sha256": "4d2db56c867e5324e0084c9e897f6360d37517de77ac96f2bd31494223d69a60", + "timeout_sha256": "12690a043dfd555a6c14ccc1564f5649c18f1762c0d6ff66729948130898ec52", + "bash_sha256": "bc5945feb8bd26203ebfafea5ce1878bb2e32cb8fb50ab7ae395cfb1e1aaaef1", + "sudo_sha256": "6ae6665cc51295ea8aaba94a3377dafa563f950aafc6296c0704fb33401a31ff", + "python_sha256": "e50d468e8b0adfb05733f5b87b3cff34829c4a8c1aea50c865aa8bdfe4bb150f", + "docker_daemon_sha256": "b8644399e73e2c9b32ea3983daf3a9856a483a79196bea10c01977d2b021fe71", + "docker_server_version": "28.0.4", + "docker_server_git_commit": "6430e49", + "docker_api_version": "1.48", + "kernel_release": "7.0.0-1017-azure", + "machine": "x86_64", + "runner_image_os": "ubuntu24", + "runner_image_version": "20261018.339.1", + "cgroup_version": "2", + "cgroup_driver": "systemd", + "memory_limit_supported": true, + "swap_limit_supported": true, + "package_versions": { + "bash": "5.2.21-2ubuntu4", + "containerd.io": "2.4.2-2~ubuntu.24.04~noble", + "coreutils": "9.4-3ubuntu6.3", + "docker-ce": "5:28.0.4-1~ubuntu.24.04~noble", + "docker-ce-cli": "5:28.0.4-1~ubuntu.24.04~noble", + "python3.12-minimal": "3.12.3-1ubuntu0.17", + "sudo": "1.9.15p5-3ubuntu5.24.04.4" + } + }, + "review": { + "source_commit": "510b76a47b120afeb70211b3ac199e51e89cc44b", + "read_only_run": "https://github.com/amberframework/memory_budget/actions/runs/39433354318", + "candidate_sha256": "03538662c7b7e224e771cbeca7007ad6660a1d0a6b043f394bcf1a5cbec36a9b", + "collector_sha256": "3a3bfbdf275dc43015d2bf7422c23b581cc29c811fef1fb7f7ab402eb90a4104", + "runner_image_reference": "https://github.com/actions/runner-images/blob/ubuntu24/20261018.339/images/ubuntu/Ubuntu2404-Readme.md", + "docker_release_reference": "https://github.com/moby/moby/releases/tag/v28.0.4", + "docker_release_commit_matches": true, + "scope": "Exact direct driver tools and observed hosted kernel/image; actual container controls and complete-build ownership qualification remain required" + } + }, + { + "format": "atlas-linux-runner-profile-v1", + "profile": { + "docker_cli_sha256": "6435ff9214bf8e0931078fb0980809728cac0a54a526d4f28a26d3e48132b58d", + "sha256sum_sha256": "4d2db56c867e5324e0084c9e897f6360d37517de77ac96f2bd31494223d69a60", + "timeout_sha256": "12690a043dfd555a6c14ccc1564f5649c18f1762c0d6ff66729948130898ec52", + "bash_sha256": "bc5945feb8bd26203ebfafea5ce1878bb2e32cb8fb50ab7ae395cfb1e1aaaef1", + "sudo_sha256": "6ae6665cc51295ea8aaba94a3377dafa563f950aafc6296c0704fb33401a31ff", + "python_sha256": "e50d468e8b0adfb05733f5b87b3cff34829c4a8c1aea50c865aa8bdfe4bb150f", + "docker_daemon_sha256": "b8644399e73e2c9b32ea3983daf3a9856a483a79196bea10c01977d2b021fe71", + "docker_server_version": "28.0.4", + "docker_server_git_commit": "6430e49", + "docker_api_version": "1.48", + "kernel_release": "6.17.0-1022-azure", + "machine": "x86_64", + "runner_image_os": "ubuntu24", + "runner_image_version": "20261012.334.1", + "cgroup_version": "2", + "cgroup_driver": "systemd", + "memory_limit_supported": true, + "swap_limit_supported": true, + "package_versions": { + "bash": "5.2.21-2ubuntu4", + "containerd.io": "2.4.1-2~ubuntu.24.04~noble", + "coreutils": "9.4-3ubuntu6.3", + "docker-ce": "5:28.0.4-1~ubuntu.24.04~noble", + "docker-ce-cli": "5:28.0.4-1~ubuntu.24.04~noble", + "python3.12-minimal": "3.12.3-1ubuntu0.17", + "sudo": "1.9.15p5-3ubuntu5.24.04.4" + } + }, + "review": { + "source_commit": "9f94f22e148df7b1f1e3fa316748739baaf84c09", + "read_only_run": "https://github.com/amberframework/memory_budget/actions/runs/39433737581", + "candidate_sha256": "626b0ae8b043061ae57333d80dba10bbbedbf3a4e8b51750b1a5e0d739ec0873", + "direct_tool_hashes_match_first_profile": true, + "runner_image_reference": "https://github.com/actions/runner-images/blob/ubuntu24/20261012.334/images/ubuntu/Ubuntu2404-Readme.md", + "scope": "Second separately observed exact hosted platform; actual container controls and complete-build ownership qualification remain required" + } + } + ] +} diff --git a/tools/installation_provenance/test_cgroup_budget.py b/tools/installation_provenance/test_cgroup_budget.py new file mode 100644 index 0000000..4ca6e3f --- /dev/null +++ b/tools/installation_provenance/test_cgroup_budget.py @@ -0,0 +1,153 @@ +"""Exercise the kernel budget parser with exact positive and changed fixtures.""" +from dataclasses import replace +from pathlib import Path +import tempfile +import unittest +import cgroup_budget as budget + + +MOUNT = '29 23 0:26 / /sys/fs/cgroup ro,nosuid,nodev,noexec,relatime - cgroup2 cgroup rw\n' + + +class CgroupBudget(unittest.TestCase): + def setUp(self): + self.limits = budget.Limits(512*2**20, 4096) + self.values = {'memory.max': str(self.limits.hard_memory_bytes)+'\n', + 'memory.current': '16777216\n', 'memory.peak': '33554432\n', + 'memory.swap.max': '0\n', 'memory.swap.current': '0\n', + 'cpu.max': '100000 100000\n', 'cpu.max.burst': '0\n', + 'pids.max': '64\n', 'pids.current': '1\n', + 'memory.events': 'low 0\nhigh 0\nmax 0\noom 0\noom_kill 0\noom_group_kill 0\n'} + + def snapshot(self, values=None): + return budget.read_snapshot((self.values if values is None else values).__getitem__) + + def test_finite_profile_accepts_and_preserves_measurement_scope(self): + value = budget.compare_snapshots(self.snapshot(), self.snapshot(), self.limits) + self.assertEqual('current-cgroup-and-descendants-through-final-snapshot-v1', value['scope']) + self.assertFalse(value['complete_Grant_build_accepted']) + + def test_decimal_Grant_target_rounds_down_below_strict_budget(self): + for page in (4096, 16384, 65536): + limits = budget.Limits(2_000_000_000, page) + self.assertLess(limits.hard_memory_bytes, 2_000_000_000) + self.assertEqual(0, limits.hard_memory_bytes % page) + self.assertLessEqual(2_000_000_000-limits.hard_memory_bytes, page) + + def test_page_aligned_budget_still_enforces_strict_less_than(self): + self.assertEqual(512*2**20-4096, self.limits.hard_memory_bytes) + + def test_invalid_typed_limits_refuse(self): + for values in ((True, 4096), (2_000_000_001, 4096), (4096, 4096), + (512*2**20, 10000)): + with self.subTest(values=values), self.assertRaises(budget.BudgetRefused): + budget.Limits(*values) + + def test_unqualified_CPU_and_process_profiles_refuse(self): + for fields in ({'cpu_quota': 200000}, {'maximum_processes': 128}, + {'cpu_period': 200000}): + with self.assertRaises(budget.BudgetRefused): + replace(self.limits, **fields) + + def test_unlimited_negative_boolean_and_incomplete_numbers_refuse(self): + for raw in ('max\n', '-1\n', '01\n', '1 2\n', '1\n2\n', '', True, '1\n\n'): + with self.subTest(raw=raw), self.assertRaises(budget.BudgetRefused): + budget.number(raw) + + def test_exact_readonly_private_cgroup2_mount_accepts(self): + budget.verify_mount(MOUNT, '0::/\n') + + def test_other_namespace_membership_refuses(self): + for member in ('0::/host/service\n', '1:memory:/\n', '0::/\n1:cpu:/\n'): + with self.assertRaises(budget.BudgetRefused): + budget.verify_mount(MOUNT, member) + + def test_writable_legacy_duplicate_and_missing_mount_refuse(self): + for mount in (MOUNT.replace('ro,nosuid', 'rw,nosuid'), + MOUNT.replace('cgroup2', 'cgroup'), MOUNT+MOUNT, '', + '1 2 3 / /sys/fs/cgroup ro - cgroup2\n'): + with self.subTest(mount=mount), self.assertRaises(budget.BudgetRefused): + budget.verify_mount(mount, '0::/\n') + + def test_changed_memory_limit_refuses(self): + for value in (self.limits.hard_memory_bytes+4096, self.limits.hard_memory_bytes-4096): + with self.assertRaises(budget.BudgetRefused): + budget.verify_snapshot(replace(self.snapshot(), memory_max=value), self.limits) + + def test_peak_at_budget_or_below_current_refuses(self): + for peak in (self.limits.strict_memory_bytes, self.limits.strict_memory_bytes+4096, 1): + with self.assertRaises(budget.BudgetRefused): + budget.verify_snapshot(replace(self.snapshot(), memory_peak=peak), self.limits) + + def test_swap_quota_burst_and_process_changes_refuse(self): + for fields in ({'swap_max': 4096}, {'swap_current': 4096}, + {'cpu_max': 'max 100000\n'}, {'cpu_max': '200000 100000\n'}, + {'cpu_burst': 10000}, {'pids_max': 128}, {'pids_current': 0}, + {'pids_current': 65}): + with self.subTest(fields=fields), self.assertRaises(budget.BudgetRefused): + budget.verify_snapshot(replace(self.snapshot(), **fields), self.limits) + + def test_each_pressure_and_OOM_event_refuses_then_restores(self): + for key in self.snapshot().memory_events: + changed = dict(self.snapshot().memory_events, **{key: 1}) + with self.subTest(key=key), self.assertRaises(budget.BudgetRefused): + budget.verify_snapshot(replace(self.snapshot(), memory_events=changed), self.limits) + budget.verify_snapshot(self.snapshot(), self.limits) + + def test_missing_duplicate_negative_and_malformed_events_refuse(self): + for raw in ('max 0\n', self.values['memory.events']+'oom 0\n', + self.values['memory.events'].replace('oom 0', 'oom -1'), + self.values['memory.events'].replace('max 0', 'max 0')): + with self.assertRaises(budget.BudgetRefused): + budget.events(raw) + + def test_peak_reset_between_snapshots_refuses(self): + before = replace(self.snapshot(), memory_peak=40*2**20) + with self.assertRaisesRegex(budget.BudgetRefused, 'high-water'): + budget.compare_snapshots(before, self.snapshot(), self.limits) + + def test_event_schema_change_between_snapshots_refuses(self): + after = replace(self.snapshot(), memory_events=dict(self.snapshot().memory_events, new_counter=0)) + with self.assertRaisesRegex(budget.BudgetRefused, 'schema'): + budget.compare_snapshots(self.snapshot(), after, self.limits) + + def test_physical_small_file_accepts_oversize_and_alias_refuse(self): + with tempfile.TemporaryDirectory() as name: + root = Path(name).resolve() + file = root/'control' + file.write_bytes(b'123\n') + self.assertEqual('123\n', budget.read_small(file)) + with self.assertRaises(budget.BudgetRefused): + budget.read_small(file, 3) + alias = root/'alias' + alias.symlink_to(file.name) + with self.assertRaises(budget.BudgetRefused): + budget.read_small(alias) + + def test_missing_kernel_control_refuses(self): + values = dict(self.values) + del values['memory.peak'] + with self.assertRaises(KeyError): + self.snapshot(values) + + def test_external_boolean_measurements_refuse(self): + with self.assertRaises(budget.BudgetRefused): + budget.verify_snapshot(replace(self.snapshot(), memory_current=True, memory_peak=True), self.limits) + + def test_external_fractional_measurements_refuse(self): + with self.assertRaises(budget.BudgetRefused): + budget.verify_snapshot(replace(self.snapshot(), memory_current=1.5, memory_peak=2.5), self.limits) + + def test_external_empty_event_roster_refuses(self): + with self.assertRaises(budget.BudgetRefused): + budget.verify_snapshot(replace(self.snapshot(), memory_events={}), self.limits) + + def test_external_missing_OOM_counter_refuses(self): + counters = dict(self.snapshot().memory_events) + del counters['oom_kill'] + with self.assertRaises(budget.BudgetRefused): + budget.verify_snapshot(replace(self.snapshot(), memory_events=counters), self.limits) + + +if __name__ == '__main__': + unittest.main() diff --git a/tools/installation_provenance/test_native_image_protocol.py b/tools/installation_provenance/test_native_image_protocol.py new file mode 100644 index 0000000..3759e0f --- /dev/null +++ b/tools/installation_provenance/test_native_image_protocol.py @@ -0,0 +1,205 @@ +"""Exercise source, identity, time and aggregate-read fences with controlled files.""" +from dataclasses import replace +from pathlib import Path +import copy +import datetime +import hashlib +import json +import tempfile +import unittest +from unittest.mock import patch +import native_image_protocol as protocol + +NOW = datetime.datetime(2026, 10, 20, 1, 38, tzinfo=datetime.timezone.utc) + + +def sha(path): + value = hashlib.sha256() + with Path(path).open('rb') as stream: + for block in iter(lambda: stream.read(65536), b''): + value.update(block) + return value.hexdigest() + + +class NativeImageProtocol(unittest.TestCase): + def setUp(self): + temporary = tempfile.TemporaryDirectory() + self.addCleanup(temporary.cleanup) + self.root = Path(temporary.name).resolve() + self.ruby = self.root/'ruby' + self.crypto = self.root/'crypto.so' + self.ruby.write_bytes(b'pinned Ruby fixture') + self.ruby.chmod(0o755) + self.crypto.write_bytes(b'pinned crypto fixture') + self.crypto.chmod(0o644) + self.expected = protocol.ExpectedWorker(101, 'exact-fixture-birth', 99, 101, 501, + str(self.ruby), 'original', 'a'*64) + self.rows = {101: dict(birth=self.expected.birth, parent=99, group=101, + real_uid=501, effective_uid=501, uid_semantics='real-user-id')} + self.ready = dict(format='atlas-native-image-boundary-ready-v1', scope=protocol.SCOPE, + pid=101, uid=501, selected_case='original', nonce='a'*64, + Ruby_path=str(self.ruby), observed_at=NOW.isoformat(), foreign_signals=0) + self.images = {str(path): self.reference(path) for path in (self.ruby, self.crypto)} + self.kernel = ('p101\nn'+str(self.ruby)+'\nn'+str(self.crypto)+ + '\nn/usr/lib/libSystem.B.dylib\n').encode() + + def reference(self, path): + return protocol.PhysicalImage(str(path), path.stat().st_size, sha(path), + path.stat().st_mode & 0o7777) + + def qualify(self, ready=None, kernel=None, expected=None, before=None, + after=None, images=None, aliases=(), clock=lambda: NOW): + return protocol.qualify_frame(json.dumps(self.ready if ready is None else ready).encode(), + self.kernel if kernel is None else kernel, self.expected if expected is None else expected, + self.rows if before is None else before, + (lambda: self.rows) if after is None else after, + self.images if images is None else images, aliases, clock) + + def test_complete_physical_frame_binds_exact_acknowledgment(self): + result = self.qualify() + self.assertTrue(result['passed']) + self.assertEqual(hashlib.sha256(self.kernel).hexdigest(), result['acknowledgment']['raw_frame_sha256']) + self.assertEqual(101, result['acknowledgment']['pid']) + self.assertEqual(2, len(result['physical_images'])) + + def test_all_seven_original_signature_case_boundaries_are_distinct(self): + for selected in protocol.CASES: + expected = replace(self.expected, selected_case=selected) + ready = dict(self.ready, selected_case=selected) + self.assertEqual(selected, self.qualify(ready=ready, expected=expected)['acknowledgment']['selected_case']) + + def test_missing_and_extra_ready_schema_fields_refuse(self): + for changed in (dict(self.ready, extra=True), {k: v for k, v in self.ready.items() if k != 'nonce'}): + with self.assertRaisesRegex(RuntimeError, 'schema'): + self.qualify(ready=changed) + + def test_wrong_format_scope_and_boolean_numeric_fields_refuse(self): + for field, value in [('format', 'other'), ('scope', 'other'), ('pid', True), + ('uid', False), ('foreign_signals', False)]: + with self.subTest(field=field), self.assertRaises(RuntimeError): + self.qualify(ready=dict(self.ready, **{field: value})) + + def test_wrong_nonce_actor_case_and_Ruby_path_refuse(self): + for field, value in [('nonce', 'b'*64), ('pid', 102), ('uid', 503), + ('selected_case', 'key_damaged'), ('Ruby_path', '/other/ruby')]: + with self.subTest(field=field), self.assertRaises(RuntimeError): + self.qualify(ready=dict(self.ready, **{field: value})) + + def test_future_stale_and_naive_ready_clocks_refuse(self): + for value in (NOW+datetime.timedelta(seconds=1), NOW-datetime.timedelta(seconds=9), + NOW.replace(tzinfo=None)): + with self.assertRaises(RuntimeError): + self.qualify(ready=dict(self.ready, observed_at=value.isoformat())) + + def test_replaced_before_actor_birth_group_parent_and_UID_refuse(self): + for field, value in [('birth', 'later-birth'), ('group', 102), ('parent', 98), + ('real_uid', 503), ('effective_uid', 503), ('uid_semantics', 'effective-only')]: + rows = copy.deepcopy(self.rows) + rows[101][field] = value + with self.subTest(field=field), self.assertRaises(RuntimeError): + self.qualify(before=rows) + + def test_replaced_after_actor_refuses_then_restores(self): + rows = copy.deepcopy(self.rows) + rows[101]['birth'] = 'later-birth' + with self.assertRaises(RuntimeError): + self.qualify(after=lambda: rows) + self.assertTrue(self.qualify()['passed']) + + def test_another_kernel_PID_refuses(self): + with self.assertRaisesRegex(RuntimeError, 'one-PID'): + self.qualify(kernel=self.kernel.replace(b'p101\n', b'p102\n')) + + def test_wrong_kernel_field_shape_refuses(self): + for raw in (b'p101\nftxt\nn/one\n', b'p101\nnrelative\n', b'p101\np102\nn/one\n'): + with self.assertRaises(RuntimeError): + self.qualify(kernel=raw) + + def test_empty_and_oversized_kernel_output_refuse(self): + for raw in (b'', b'x'*(256*2**10+1)): + with self.assertRaises(RuntimeError): + self.qualify(kernel=raw) + + def test_missing_actual_Ruby_image_refuses(self): + with self.assertRaisesRegex(RuntimeError, 'Ruby executable'): + self.qualify(kernel=('p101\nn'+str(self.crypto)+'\n').encode()) + + def test_unadmitted_physical_image_refuses(self): + extra = self.root/'unadmitted.so' + extra.write_bytes(b'other input') + with self.assertRaisesRegex(RuntimeError, 'admitted source reference'): + self.qualify(kernel=self.kernel+('n'+str(extra)+'\n').encode()) + + def test_changed_physical_bytes_and_mode_refuse_then_restore(self): + original = self.crypto.read_bytes() + self.crypto.write_bytes(b'changed crypto fixture') + with self.assertRaises(RuntimeError): + self.qualify() + self.crypto.write_bytes(original) + self.crypto.chmod(0o600) + with self.assertRaises(RuntimeError): + self.qualify() + self.crypto.chmod(0o644) + self.assertTrue(self.qualify()['passed']) + + def test_exact_alias_accepts_and_same_byte_alias_diversion_refuses(self): + link = self.root/'selected.so' + alternate = self.root/'same-bytes.so' + alternate.write_bytes(self.crypto.read_bytes()) + link.symlink_to(self.crypto) + admitted = protocol.SourceAlias(str(link), str(self.crypto), str(self.crypto)) + raw = self.kernel.replace(('n'+str(self.crypto)).encode(), ('n'+str(link)).encode()) + self.assertTrue(self.qualify(kernel=raw, aliases=(admitted,))['passed']) + link.unlink() + link.symlink_to(alternate) + with self.assertRaisesRegex(RuntimeError, 'alias'): + self.qualify(kernel=raw, aliases=(admitted,)) + link.unlink() + link.symlink_to(self.crypto) + self.assertTrue(self.qualify(kernel=raw, aliases=(admitted,))['passed']) + + def test_final_actor_and_time_checks_follow_real_physical_hashing(self): + verified = [] + original = protocol.verify_physical_image + def image(path, expected): + value = original(path, expected) + verified.append(str(path)) + return value + def rows_after(): + self.assertEqual(2, len(verified)) + return self.rows + with patch.object(protocol, 'verify_physical_image', image): + self.assertTrue(self.qualify(after=rows_after)['passed']) + clock = iter((NOW, NOW+datetime.timedelta(seconds=9))) + with self.assertRaisesRegex(RuntimeError, 'Fresh'): + self.qualify(clock=lambda: next(clock)) + + def test_system_cache_boundary_retains_separate_qualification(self): + result = self.qualify() + self.assertFalse(result['system_images'][0]['physical_source_bytes_verified']) + self.assertFalse(result['complete_provider_profile_accepted']) + self.assertFalse(result['quantitative_acceptance']) + self.assertEqual(0, result['foreign_signals']) + + def test_aggregate128MiB_fence_and_guard_removal_sensitivity(self): + extra = [self.root/('extra'+str(index).zfill(2)+'.so') for index in range(16)] + # Every file fits the existing16MiB per-file source-control fence. + # The aggregate still exceeds the actual128MiB verification budget. + for path in [self.crypto]+extra: + with path.open('wb') as stream: + stream.truncate(8*2**20) + path.chmod(0o644) + images = {str(path): self.reference(path) for path in [self.ruby, self.crypto]+extra} + raw = self.kernel+''.join('n'+str(path)+'\n' for path in extra).encode() + with self.assertRaisesRegex(RuntimeError, 'fits128MiB'): + self.qualify(images=images, kernel=raw) + original = protocol.require + def removed_budget_guard(value, message): + if message != 'Complete physical image verification fits128MiB': + original(value, message) + with patch.object(protocol, 'require', removed_budget_guard): + self.assertTrue(self.qualify(images=images, kernel=raw)['passed']) + + +if __name__ == '__main__': + unittest.main(verbosity=2) diff --git a/tools/installation_provenance/test_runner_profiles.py b/tools/installation_provenance/test_runner_profiles.py new file mode 100644 index 0000000..52eab29 --- /dev/null +++ b/tools/installation_provenance/test_runner_profiles.py @@ -0,0 +1,61 @@ +"""Exercise complete-profile admission and its missing, mixed, and forged controls.""" + +import copy +from pathlib import Path +import sys +import unittest + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from record_linux_runner import reviewed_profile + + +class RunnerProfileTest(unittest.TestCase): + def setUp(self): + self.first = {"tool_sha256": "a" * 64, "kernel": "kernel-one", "image": "image-one", "memory": True} + self.second = {**self.first, "kernel": "kernel-two", "image": "image-two"} + self.configured = {"format": "atlas-linux-runner-profile-set-v1", "profiles": [ + {"format": "atlas-linux-runner-profile-v1", "profile": self.first}, + {"format": "atlas-linux-runner-profile-v1", "profile": self.second}, + ]} + + def test_exact_first_profile(self): + self.assertEqual(reviewed_profile(self.configured, self.first)["profile"], self.first) + + def test_exact_second_profile(self): + self.assertEqual(reviewed_profile(self.configured, self.second)["profile"], self.second) + + def test_changed_tool_hash_is_refused(self): + with self.assertRaises(RuntimeError): + reviewed_profile(self.configured, {**self.first, "tool_sha256": "b" * 64}) + + def test_mixed_image_and_kernel_are_refused(self): + with self.assertRaises(RuntimeError): + reviewed_profile(self.configured, {**self.first, "image": self.second["image"]}) + + def test_missing_field_is_refused(self): + changed = dict(self.first) + del changed["memory"] + with self.assertRaises(RuntimeError): + reviewed_profile(self.configured, changed) + + def test_boolean_as_integer_is_refused(self): + with self.assertRaises(RuntimeError): + reviewed_profile(self.configured, {**self.first, "memory": 1}) + + def test_empty_roster_is_refused(self): + with self.assertRaises(RuntimeError): + reviewed_profile({**self.configured, "profiles": []}, self.first) + + def test_duplicate_profile_is_refused(self): + changed = copy.deepcopy(self.configured) + changed["profiles"].append(copy.deepcopy(changed["profiles"][0])) + with self.assertRaises(RuntimeError): + reviewed_profile(changed, self.first) + + def test_unsupported_format_is_refused(self): + with self.assertRaises(RuntimeError): + reviewed_profile({**self.configured, "format": "unknown"}, self.first) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tools/installation_provenance/test_verify_terminal.py b/tools/installation_provenance/test_verify_terminal.py new file mode 100644 index 0000000..f2e4a0e --- /dev/null +++ b/tools/installation_provenance/test_verify_terminal.py @@ -0,0 +1,188 @@ +"""Alter complete four-container evidence packets and exercise the actual reader.""" +from pathlib import Path +import copy +import json +import tempfile +import unittest +import cgroup_budget as budget +import verify_terminal as reader + + +class TerminalControls(unittest.TestCase): + def setUp(self): + temporary = tempfile.TemporaryDirectory() + self.addCleanup(temporary.cleanup) + self.root = Path(temporary.name).resolve() + self.pins = 'a'*64 + self.image_id = 'sha256:'+'b'*64 + self.files = {'image-inspect.json': [dict(Id=self.image_id, + RepoDigests=['python@'+reader.IMAGE.split('@')[1]], Config=dict(Env=['PATH=/usr/local/bin:/usr/bin:/bin']))]} + limits = budget.Limits(512*2**20, 4096) + sample = budget.Snapshot(limits.hard_memory_bytes, 16*2**20, 32*2**20, + 0, 0, '100000 100000\n', 0, 64, 1, + dict(low=0, high=0, max=0, oom=0, oom_kill=0)) + for index, selected in enumerate(('ordinary', 'optimized', 'oom', 'uncapped'), 1): + cap = limits.hard_memory_bytes if index <= 2 else (64*2**20-4096 if index == 3 else 0) + command = ['python3', '-I', '-S', '-B']+(['-O'] if selected == 'optimized' else []) + command.extend(['/source/run_controls.py', '--pins-sha256', self.pins, + '--mode', 'oom-probe' if selected == 'oom' else 'uncapped-probe' if selected == 'uncapped' else 'controls', + '--strict-memory-bytes', str(64*2**20 if selected == 'oom' else 512*2**20), + '--output', '/evidence/'+selected+'.json']) + self.files[selected+'.inspect.json'] = [dict(Id=str(index)*64, Image=self.image_id, + Config=dict(Image=reader.IMAGE, User='501:501', Cmd=command, Entrypoint=None, + Env=['PATH=/usr/local/bin:/usr/bin:/bin']), + State=dict(Status='exited', Running=False, Paused=False, Restarting=False, + Dead=False, Error='', ExitCode=(137 if index == 3 else 2 if index == 4 else 0), + OOMKilled=index == 3), + HostConfig=dict(NetworkMode='none', ReadonlyRootfs=True, NanoCpus=1_000_000_000, + PidsLimit=64, Privileged=False, CgroupnsMode='private', AutoRemove=False, + CapDrop=['ALL'], SecurityOpt=['no-new-privileges'], Memory=cap, MemorySwap=cap, + Tmpfs={'/tmp': 'rw,nosuid,nodev,noexec,size=384m,mode=1777'}), + Mounts=[dict(Type='bind', Destination='/source', RW=False), + dict(Type='bind', Destination='/evidence', RW=True)])] + result = dict(format='atlas-linux-installation-control-result-v1', + source_manifest_sha256=self.pins, actual_Homebrew_commands=0, + actual_Crystal_compilations=0, actual_Grant_cells=0) + if index <= 2: + result.update(limits=budget.asdict(limits), before=budget.asdict(sample), + after=budget.asdict(sample), passed=True, tests_run=58, failures=0, errors=0, + skipped=0, expected_failures=0, unexpected_successes=0, + optimized_python=selected == 'optimized') + elif index == 3: + result.update(admitted=True, expected_termination='kernel-cgroup-OOM') + else: + result.update(refused_before_workload=True, tests_run=0, + reason='A complete finite nonnegative decimal value is required') + self.files[selected+'.json'] = result + + def validate(self): + for name, value in self.files.items(): + (self.root/name).write_text(json.dumps(value)) + return reader.validate(self.root, self.pins) + + def inspect(self, selected='ordinary'): + return self.files[selected+'.inspect.json'][0] + + def test_complete_packet_accepts_all_four_distinct_controls(self): + result = self.validate() + self.assertTrue(result['passed']) + self.assertEqual(4, len(result['cases'])) + self.assertFalse(result['Grant_under_2GB_accepted']) + + def test_exit137_without_kernel_OOM_flag_refuses(self): + self.inspect('oom')['State']['OOMKilled'] = False + with self.assertRaisesRegex(RuntimeError, 'kernel OOM'): + self.validate() + + def test_kernel_OOM_flag_with_other_exit_refuses(self): + self.inspect('oom')['State']['ExitCode'] = 1 + with self.assertRaises(RuntimeError): + self.validate() + + def test_uncapped_probe_running_tests_refuses(self): + self.files['uncapped.json']['tests_run'] = 1 + with self.assertRaises(RuntimeError): + self.validate() + + def test_uncapped_ordinary_container_refuses(self): + self.inspect()['HostConfig']['Memory'] = 0 + with self.assertRaises(RuntimeError): + self.validate() + self.inspect()['HostConfig']['Memory'] = 512*2**20-4096 + self.files['ordinary.json']['limits']['strict_memory_bytes'] = 2_000_000_000 + with self.assertRaises(RuntimeError): + self.validate() + + def test_writable_source_mount_refuses(self): + self.inspect()['Mounts'][0]['RW'] = True + with self.assertRaises(RuntimeError): + self.validate() + + def test_extra_host_mount_refuses(self): + self.inspect()['Mounts'].append(dict(Type='bind', Destination='/extra', RW=False)) + with self.assertRaises(RuntimeError): + self.validate() + + def test_changed_registry_digest_or_container_image_refuses(self): + original = copy.deepcopy(self.files) + self.files['image-inspect.json'][0]['RepoDigests'] = ['python@sha256:'+'c'*64] + with self.assertRaises(RuntimeError): + self.validate() + self.files = original + self.inspect()['Image'] = 'sha256:'+'c'*64 + with self.assertRaises(RuntimeError): + self.validate() + + def test_reused_container_identity_refuses(self): + self.inspect('optimized')['Id'] = self.inspect()['Id'] + with self.assertRaises(RuntimeError): + self.validate() + + def test_skipped_expected_failure_and_missing_case_refuse(self): + original = copy.deepcopy(self.files) + for field, value in (('skipped', 1), ('expected_failures', 1), ('tests_run', 53)): + self.files = copy.deepcopy(original) + self.files['ordinary.json'][field] = value + with self.subTest(field=field), self.assertRaises(RuntimeError): + self.validate() + + def test_optimized_cohort_mislabeled_refuses(self): + self.files['optimized.json']['optimized_python'] = False + with self.assertRaises(RuntimeError): + self.validate() + + def test_changed_source_manifest_refuses(self): + original = copy.deepcopy(self.files) + self.files['ordinary.json']['source_manifest_sha256'] = 'c'*64 + with self.assertRaises(RuntimeError): + self.validate() + self.files = original + self.inspect()['Config']['Cmd'][-1] = '/evidence/replaced.json' + with self.assertRaises(RuntimeError): + self.validate() + self.inspect()['Config']['Cmd'][-1] = '/evidence/ordinary.json' + self.inspect()['Config']['Env'].append('PYTHONPATH=/other') + with self.assertRaises(RuntimeError): + self.validate() + + def test_host_namespace_or_raised_CPU_quota_refuses(self): + original = copy.deepcopy(self.files) + for field, value in (('CgroupnsMode', 'host'), ('NanoCpus', 2_000_000_000)): + self.files = copy.deepcopy(original) + self.inspect()['HostConfig'][field] = value + with self.subTest(field=field), self.assertRaises(RuntimeError): + self.validate() + + def test_additional_swap_capacity_refuses(self): + self.inspect()['HostConfig']['MemorySwap'] *= 2 + with self.assertRaises(RuntimeError): + self.validate() + + def test_nonterminal_container_refuses(self): + self.inspect()['State'].update(Status='running', Running=True) + with self.assertRaises(RuntimeError): + self.validate() + + def test_wrong_tmpfs_size_or_kind_refuses(self): + original = copy.deepcopy(self.files) + self.inspect()['HostConfig']['Tmpfs']['/tmp'] += ',size=3g' + with self.assertRaises(RuntimeError): + self.validate() + self.files = original + self.inspect()['Mounts'].append(dict(Type='volume', Destination='/tmp', RW=True)) + with self.assertRaises(RuntimeError): + self.validate() + + def test_reported_pass_with_overbudget_peak_refuses(self): + self.files['ordinary.json']['after']['memory_peak'] = 512*2**20 + with self.assertRaises(budget.BudgetRefused): + self.validate() + + def test_documented_separate_tmpfs_mount_and_security_spelling_accept(self): + self.inspect()['Mounts'].append(dict(Type='tmpfs', Destination='/tmp', RW=True)) + self.inspect()['HostConfig']['SecurityOpt'] = ['no-new-privileges=true'] + self.assertTrue(self.validate()['passed']) + + +if __name__ == '__main__': + unittest.main() diff --git a/tools/installation_provenance/verify_terminal.py b/tools/installation_provenance/verify_terminal.py new file mode 100644 index 0000000..b85e857 --- /dev/null +++ b/tools/installation_provenance/verify_terminal.py @@ -0,0 +1,148 @@ +"""Require both inner behavior results and external container terminal evidence.""" +from pathlib import Path +import argparse +import hashlib +import json +import re +import sys + + +IMAGE = 'python:3.12.10-slim@sha256:fd95fa221297a88e1cf49c55ec1828edd7c5a428187e67b5d1805692d11588db' + + +def require(value, message): + if not value: + raise RuntimeError(message) + + +def read_json(path, maximum=1024*1024): + raw = path.read_bytes() + require(0 < len(raw) <= maximum, 'A complete bounded evidence file is required') + return json.loads(raw) + + +def validate(root, pins_hash): + import cgroup_budget as budget + image = read_json(root/'image-inspect.json') + require(type(image) is list and len(image) == 1 + and re.fullmatch('sha256:[0-9a-f]{64}', image[0]['Id']) is not None + and any(value in image[0]['RepoDigests'] for value in ( + 'python@sha256:fd95fa221297a88e1cf49c55ec1828edd7c5a428187e67b5d1805692d11588db', + 'docker.io/library/python@sha256:fd95fa221297a88e1cf49c55ec1828edd7c5a428187e67b5d1805692d11588db')), + 'The actual local image must retain the reviewed registry digest') + accepted = [] + identities = set() + for selected in ('ordinary', 'optimized', 'oom', 'uncapped'): + value = read_json(root/(selected+'.inspect.json')) + require(type(value) is list and len(value) == 1, 'Exactly one owned container is required') + container = value[0] + require(re.fullmatch('[0-9a-f]{64}', container['Id']) is not None, + 'An exact Docker container identity is required') + require(container['Id'] not in identities and container['Image'] == image[0]['Id'], + 'Each control needs a distinct container of the actual pinned image') + identities.add(container['Id']) + state, host = container['State'], container['HostConfig'] + expected_command = ['python3', '-I', '-S', '-B'] + if selected == 'optimized': + expected_command.append('-O') + expected_mode = 'oom-probe' if selected == 'oom' else 'uncapped-probe' if selected == 'uncapped' else 'controls' + expected_budget = str(64*2**20 if selected == 'oom' else 512*2**20) + expected_command.extend(['/source/run_controls.py', '--pins-sha256', pins_hash, + '--mode', expected_mode, '--strict-memory-bytes', expected_budget, + '--output', '/evidence/'+selected+'.json']) + require(container['Config']['Cmd'] == expected_command + and container['Config']['Entrypoint'] is None + and container['Config']['Env'] == image[0]['Config']['Env'], + 'The exact case command and pinned image environment are required') + require(state['Status'] == 'exited' and state['Running'] is False + and state['Paused'] is False and state['Restarting'] is False + and state['Dead'] is False and state['Error'] == '', + 'The owned container must reach an unambiguous terminal state') + require(container['Config']['Image'] == IMAGE and host['NetworkMode'] == 'none' + and host['ReadonlyRootfs'] is True and host['NanoCpus'] == 1_000_000_000 + and host['PidsLimit'] == 64 and host['Privileged'] is False + and host['CgroupnsMode'] == 'private' and host['AutoRemove'] is False, + 'The reviewed finite isolated container profile must remain active') + require(host['CapDrop'] == ['ALL'] and host['SecurityOpt'] in ( + ['no-new-privileges'], ['no-new-privileges=true']), + 'The reduced-privilege container profile must remain active') + require(container['Config']['User'] == '501:501', 'The ordinary non-root test identity is required') + require(sorted((item['Destination'], item['RW']) for item in container['Mounts'] + if item['Type'] == 'bind') + == [('/evidence', True), ('/source', False)], + 'Only read-only source and the owned evidence mount are admitted') + others = [item for item in container['Mounts'] if item['Type'] != 'bind'] + require(others == [] or (len(others) == 1 and others[0]['Type'] == 'tmpfs' + and others[0]['Destination'] == '/tmp' and others[0]['RW'] is True), + 'Any separately reported temporary mount must be the exact private tmpfs') + require(set(host['Tmpfs']) == {'/tmp'} + and sorted(host['Tmpfs']['/tmp'].split(',')) + == sorted(['rw', 'nosuid', 'nodev', 'noexec', 'size=384m', 'mode=1777']), + 'The exact private temporary filesystem ceiling is required') + result = read_json(root/(selected+'.json')) + require(result['format'] == 'atlas-linux-installation-control-result-v1' + and result['source_manifest_sha256'] == pins_hash + and result['actual_Homebrew_commands'] == result['actual_Crystal_compilations'] + == result['actual_Grant_cells'] == 0, + 'The exact source and installation-protocol-only scope must be retained') + if selected in ('ordinary', 'optimized'): + limits = budget.Limits(**result['limits']) + require(limits.strict_memory_bytes == 512*2**20, + 'The declared ordinary strict budget must remain exactly512MiB') + budget.compare_snapshots(budget.Snapshot(**result['before']), + budget.Snapshot(**result['after']), limits) + hard = limits.hard_memory_bytes + require(host['Memory'] == host['MemorySwap'] == hard + and state['ExitCode'] == 0 and state['OOMKilled'] is False + and result['passed'] is True and result['tests_run'] == 58 + and result['failures'] == result['errors'] == result['skipped'] + == result['expected_failures'] == result['unexpected_successes'] == 0 + and result['optimized_python'] is (selected == 'optimized'), + 'Both exact 58-case cohorts must pass inside their finite kernel ceiling') + elif selected == 'oom': + require(host['Memory'] == host['MemorySwap'] == 64*2**20-4096 + and state['ExitCode'] == 137 and state['OOMKilled'] is True + and result['admitted'] is True + and result['expected_termination'] == 'kernel-cgroup-OOM', + 'The small deliberate allocation must reach real kernel OOM termination') + else: + require(host['Memory'] == host['MemorySwap'] == 0 + and state['ExitCode'] == 2 and state['OOMKilled'] is False + and result['refused_before_workload'] is True and result['tests_run'] == 0 + and 'finite' in result['reason'], + 'An unfenced container must refuse before the workload starts') + accepted.append(dict(case=selected, container_id=container['Id'], + exit_code=state['ExitCode'], OOMKilled=state['OOMKilled'])) + return dict(passed=True, format='atlas-linux-installation-terminal-controls-v1', + cases=accepted, actual_Grant_cells=0, actual_Homebrew_commands=0, + installed_SDK_accepted=False, clean_device_installation_accepted=False, + Grant_under_2GB_accepted=False) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--evidence', required=True) + parser.add_argument('--pins-sha256', required=True) + arguments = parser.parse_args() + source = Path(__file__).resolve().parent + packet_path = source/'SOURCE_PINS.json' + require(packet_path.stat().st_size <= 16384 + and hashlib.sha256(packet_path.read_bytes()).hexdigest() == arguments.pins_sha256, + 'The exact reviewed source manifest is required before local imports') + packet = read_json(packet_path, 16384) + reference = next(item for item in packet['files'] if item['path'] == 'run_controls.py') + helper = source/'run_controls.py' + require(helper.resolve(strict=True) == helper and helper.stat().st_size == reference['bytes'] + and hashlib.sha256(helper.read_bytes()).hexdigest() == reference['sha256'], + 'The source-verification helper must retain its exact physical bytes') + sys.path.insert(0, str(source)) + from run_controls import verify_sources + verify_sources(source, packet_path, arguments.pins_sha256) + result = validate(Path(arguments.evidence), arguments.pins_sha256) + (Path(arguments.evidence)/'TERMINAL_ACCEPTANCE.json').write_text(json.dumps(result, indent=2)+'\n') + print(json.dumps(result)) + return 0 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/tools/whole_build_memory/README.md b/tools/whole_build_memory/README.md new file mode 100644 index 0000000..a888e51 --- /dev/null +++ b/tools/whole_build_memory/README.md @@ -0,0 +1,57 @@ +# Whole-build process-boundary qualification + +This source candidate extends the accepted Linux installation-control gate. +The existing seven-file provider and 58-case cohorts retain their identities. +The new probes test three child lifetimes and a concurrent private sibling +allocation in fresh capped containers, in ordinary and optimized Python. + +Each direct child touches 64 MiB of private pages. The parent samples entry +and final state, joins the process, and requires the kernel peak to retain the +allocation after current memory falls. The fork/exec case additionally binds +the PID and kernel start time across exec. The detached case creates a new +session, lets its launcher exit, then requires the supervisor to observe, +adopt, release, and reap the remaining worker before ending the window. + +The sibling observer and load overlap. The load touches 192 MiB while the +observer remains below 96 MiB. Read-only host metadata binds the actual Docker +identities and process start times to distinct sibling cgroup paths. The +inner cgroup identity must agree with that host context. + +The host driver verifies exact tool/source/profile identities, executes the +sixteen fresh containers, checks commands, kernel limits, functional page counts, +membership and terminal results, then removes only its exact owned identities +and reads them back absent. All measurements and cleanup records become CI +artifacts. Missing or inconsistent evidence fails acceptance. + +Fifty sensitivity controls change copies of the actual observations across +both execution modes. They challenge retained peaks, process birth and +adoption, orphan membership, sibling charges and hierarchy, kernel counters, +executed commands, complete parent membership, and window boundaries. Every changed copy must fail; the restored actual +dataset must pass. Original observations remain available in the artifact. + +RSS counters have a separate scope and unit. Each process records its own +maximum RSS and the maximum RSS among its waited children in Linux KiB. +Two additional overlapping-worker cases each hold two consumed 64-MiB private +allocations simultaneously. Their whole-group charge must cover both while +the waited-child maximum remains the largest individual worker. Every child +is joined before the final measurement. Damaged-unit, summed-RSS, lost-peak, +typed-counter and missing-live-worker controls challenge these boundaries. +The actual compiler has its own remaining acceptance; this synthetic protocol +supplies a tested measurement boundary. + +The shared-page pair adds a 96-MiB file first touched by its writer. Both +consumers verify the full content signature and physical inode and touch +every page through a live mapping. The observer's RSS must rise while its +own cgroup charge stays below 48 MiB; the writer must retain at least 96 MiB +of charge while the observer is live. Independent host metadata binds both +siblings and the same complete file. The driver rehashes and removes the +two owned temporary data files after all containers return, and retains +their identities and absent readbacks in the artifact. Each root probe also +requires a refused write handle to the read-only cgroup control file. +Actual process migration retains a separate acceptance requirement. + +These are synthetic private-allocation and process-boundary controls. Their +actual execution and raw verification determine which claims are earned. +Actual process migration, other shared cache/reclaim behavior, compiler-process RSS, a complete real build, +ordinary installation, and Grant's 300/500-model matrix retain their separate +required evidence. See the [kernel cgroup documentation](https://docs.kernel.org/admin-guide/cgroup-v2.html). diff --git a/tools/whole_build_memory/SOURCE_PINS.json b/tools/whole_build_memory/SOURCE_PINS.json new file mode 100644 index 0000000..4ccf3cd --- /dev/null +++ b/tools/whole_build_memory/SOURCE_PINS.json @@ -0,0 +1,23 @@ +{ + "format": "atlas-whole-build-probe-sources-v1", + "files": [ + { + "path": "probe.py", + "mode": 420, + "bytes": 22408, + "sha256": "2f1955f43f394949952454b40098b227adb022c20a49c67946d7af02315f5b87" + }, + { + "path": "run_host.py", + "mode": 420, + "bytes": 11827, + "sha256": "253d9b49d74580e5efd1c1d1b168055033c4cda10137cd839d504cf3b5d0d1cb" + }, + { + "path": "verify_results.py", + "mode": 420, + "bytes": 25919, + "sha256": "f7ccf48f2168a865448760c6f6986df009378f7d3a16b1ab6f10d145d04ed2b8" + } + ] +} diff --git a/tools/whole_build_memory/evidence/README.md b/tools/whole_build_memory/evidence/README.md new file mode 100644 index 0000000..2f3e60f --- /dev/null +++ b/tools/whole_build_memory/evidence/README.md @@ -0,0 +1,163 @@ +# Executed Linux descendant qualification + +## Shared-page charge extension + +Source `c33b03334b49c46e810f7d196428020b848777bd`, manifest +`233f9658ccd015e2c9e7c268723963ed3713dbb2fc4a552f65d2b52a13288cfd`, +adds four live shared-page cases and a cgroup write-permission refusal. +[Actual run 39451872353](https://github.com/amberframework/memory_budget/actions/runs/39451872353) +passes sixteen workloads, fifty changed-result controls, the preserved +58-case cohorts and nine profile cases, real OOM and uncapped refusal, and +complete return of all twenty-one containers and two temporary data files. +Independent replay binds all 210 raw files. The original seven-file +provider retains its existing identity. + +Both consumers map and consume the same 96-MiB file. Full content hash, +inode, device, size, owner and mode agree across both consumers, the live +host check and cleanup. The writer retains its charge while the reader is +live. The ordinary case records: + +| Observation | Bytes | +| --- | ---: | +| Shared file | 100,663,296 | +| Reader RSS high-water mark | 127,991,808 | +| Reader current cgroup charge | 17,899,520 | +| Writer current charge while reader is live | 121,696,256 | + +The result shows a resident mapping whose charge remains with a separate +live owner. It supports distinct process-RSS and cgroup-charge policies. +Kernel documentation describes the broader +[memory ownership boundary](https://docs.kernel.org/admin-guide/cgroup-v2.html#memory-ownership). +This experiment earns its observed file-mapping scope. Actual process +migration and other cache/reclaim situations remain separate. + +Archive `linux-shared-39451872353.zip` is 214,487 bytes, SHA256 +`19c4b36d2d60f3c988226f58597e7f1aa8f91a4e6cf09807a725051bc9903bdc`. +The GitHub metadata and complete acceptance roster are retained beside it. +Replay uses this exact source commit and manifest, token `39451872353-1`, +and the descendant evidence directory containing `HOST_RESULT.json`. +The same validator entry points below apply. Each data-file owner must +also record its initial absence, verified complete identity and final +removal; the temporary data files are absent from the artifact. + +Every root probe observed EACCES when requesting a write handle for the +read-only cgroup membership file. Mount and privilege checks remain in +place. This is a tested mutation-permission boundary; actual process +migration remains unaccepted. Actual compiler/build, ordinary installation, +device proof and the observed Docker OOM-marker reliability question also +remain open. Grant remains **0/144**. + +## RSS protocol extension + +Source `3ea3bfcc55e1e520ee25d69000ea5e8d17d4a62a` adds self and +largest-waited-child RSS counters, with Linux KiB units, to every observation. +The new source manifest is +`a2b816772ffc66ed8bebbb405c52f54434baa663a5d6afae63e87252da1b287c`. +The original seven-file provider is unchanged. Two further cases hold two +consumed 64-MiB private allocations live at once. In the ordinary case, +the largest waited-child RSS peak is 94,117,888 bytes and the whole-group +charged peak is 185,487,360 bytes. This demonstrates why the two metrics +need their own names and budgets. Linux documents the largest-child scope +in [getrusage](https://man7.org/linux/man-pages/man2/getrusage.2.html). + +[Actual run 39449551836, attempt 2](https://github.com/amberframework/memory_budget/actions/runs/39449551836/attempts/2) +passes twelve probes, 34 changed-actual-result controls, the preserved +58-case cohorts and nine profile controls, real OOM and uncapped refusal, +and complete return of all seventeen containers. Independent replay binds +all 162 raw files. Archive `linux-rss-39449551836-attempt-2.zip` is +169,372 bytes, SHA256 +`4ff7637e68a81fa5ed218733a14238219b9b9908a23cdddc4a836136da7999cf`. +The acceptance and GitHub metadata files are retained beside it. Replay +uses that source commit, its exact manifest, token `39449551836-2`, and the +directory containing `HOST_RESULT.json`. The same validation entry points +described below apply. + +The original attempt is also retained. Its ordinary/optimized controls +passed, but the deliberately over-limit process exited 137 with Docker's +OOM marker false. The existing predicate refused before the RSS stage. +All five containers were removed and read back absent. One controlled +repeat retained the same source and exact OOM predicate; the complete +observed tool/kernel/runner profiles match between attempts. A successful +repeat preserves the first attempt's evidence. The missing marker's cause +and its effect on operational reliability remain open release questions. + +The first archive is 49,299 bytes, SHA256 +`e3600ec03e73ffb8eaeec868628fd70b85ec38e610bf9420b36e0fc5b850843f`, +with its complete 41-file roster and five returns in the refusal JSON. +The repeat decision is also retained. The gate continues to require the +actual OOM marker; exit 137 alone earns no OOM acceptance. + +This extension qualifies synthetic self/largest-child RSS observations. +The actual compiler, shared/migrated charges, whole real builds, normal +installation and devices remain required. Grant remains **0/144**. + +## Earlier descendant and sibling dataset + +Source `b2da5a87af39cbb198d315512d60a4f7e7fc0431` passed the +[actual hosted run](https://github.com/amberframework/memory_budget/actions/runs/39447776437). +Its exact three-file source manifest is +`061ece6c4c78bd2e1c471facfcc048d81db09065f5935e3cda925a07bcfb8f09`. +The original seven-file provider manifest remains +`15e27eea749e5d08f7d41256515b078f256c89fed5c49647c09dc99b99406eae`. + +The accepted archive `linux-descendants-39447776437.zip` is 146,765 bytes, +SHA256 `5bbdcbb53413e7f95fb67f310802a925cb767d2b06ea451dc409704fae059b4d`. +That digest matches GitHub's artifact metadata retained beside it. Its 140 raw +files include runner identity, ten actual probes, both preserved 58-case +cohorts, kernel OOM and uncapped controls, full terminal inspections, and all +fifteen owned-container removal and absent readbacks. The acceptance JSON +lists every raw path, length, and SHA256. + +The ten probes cover direct children, fork/exec children, detached children, +and simultaneous sibling observer/load processes, each in ordinary and +optimized Python. All three child paths touch 64 MiB. Their final kernel +peaks retain the retired charge after the supervisor rejoins every worker. +The separate sibling load touches 192 MiB while the observer remains below +96 MiB; host Docker/PID/cgroup identities bind the two separate siblings. +Twenty-four changed copies of actual observations are rejected, and the +restored actual dataset passes. Independent replay also verifies every +terminal result and cleanup record. + +## The reader defect that the first green run missed + +The earlier source `568aee6a60f380612f13c29aa2610ddc7c90aaf3` passed its +[ten actual workloads and sixteen original damage controls](https://github.com/amberframework/memory_budget/actions/runs/39447337794). +Its complete initial archive is retained as +`linux-descendants-39447337794-initial.zip`, 146,576 bytes, +SHA256 `0cf4bd1a5db3c72ed5fee971e8c5734efa0504500aa5ce8abe90de67d696a5c9`. +Independent review removed parent/launcher PIDs from the hot worker records; +the old validator accepted all six changed cases. The audit JSON preserves +those observations. The corrected reader requires every live parent and +worker, and binds entry/allocation/adoption observations to the complete +window. Fresh execution and 24 damage controls qualify that correction. + +## Replaying the results + +Verify the archive digest against the retained GitHub metadata and use the +exact source commit above. Extract the complete archive into a private +directory, preserving its paths. The two entry points in +`tools/whole_build_memory/verify_results.py` are +`validate(evidence_directory, source_manifest_sha256, run_token)` and +`sensitivity_controls(evidence_directory, source_manifest_sha256, run_token)`. +Use the descendant directory containing `HOST_RESULT.json`, the source +manifest above, and run token `39447776437-1`. Both functions read the actual +dataset and verify the complete source roster before accepting it. Compare +their complete results with `HOST_RESULT.json`; then verify each owner in +its cleanup-before, removal, and cleanup-after files. Docker's `Mounts` +array may arrive in different orders; compare its complete unique records +by destination while preserving every field. + +The exact runtime image and host tool/profile hashes are retained in the +raw metadata. The runtime image is +`python:3.12.10-slim@sha256:fd95fa221297a88e1cf49c55ec1828edd7c5a428187e67b5d1805692d11588db`. +The complete fresh execution remains in +`.github/workflows/linux-kernel-budget-controls.yml`. + +## Acceptance boundary + +This dataset qualifies private-allocation descendant peak retention, +recorded membership and window boundaries, sibling isolation, and terminal +return on the admitted Linux profile. The reported peak is cgroup-charged +memory. Shared/migrated-page charge behavior, compiler-process RSS, +complete real builds, ordinary SDK installation and clean devices retain +their separate required evidence. Accepted Grant target cells remain **0/144**. diff --git a/tools/whole_build_memory/evidence/initial-membership-reader-gap.json b/tools/whole_build_memory/evidence/initial-membership-reader-gap.json new file mode 100644 index 0000000..635bb29 --- /dev/null +++ b/tools/whole_build_memory/evidence/initial-membership-reader-gap.json @@ -0,0 +1,30 @@ +{ + "source": "568aee6a60f380612f13c29aa2610ddc7c90aaf3", + "actual_result_mutation": "omit parent and launcher from hot worker membership", + "observations": [ + { + "case": "ordinary-direct.json", + "changed_roster_accepted": true + }, + { + "case": "ordinary-fork-exec.json", + "changed_roster_accepted": true + }, + { + "case": "ordinary-detached.json", + "changed_roster_accepted": true + }, + { + "case": "optimized-direct.json", + "changed_roster_accepted": true + }, + { + "case": "optimized-fork-exec.json", + "changed_roster_accepted": true + }, + { + "case": "optimized-detached.json", + "changed_roster_accepted": true + } + ] +} diff --git a/tools/whole_build_memory/evidence/linux-descendants-39447337794-initial.zip b/tools/whole_build_memory/evidence/linux-descendants-39447337794-initial.zip new file mode 100644 index 0000000..6bd5e67 Binary files /dev/null and b/tools/whole_build_memory/evidence/linux-descendants-39447337794-initial.zip differ diff --git a/tools/whole_build_memory/evidence/linux-descendants-39447776437.acceptance.json b/tools/whole_build_memory/evidence/linux-descendants-39447776437.acceptance.json new file mode 100644 index 0000000..bf3d9b8 --- /dev/null +++ b/tools/whole_build_memory/evidence/linux-descendants-39447776437.acceptance.json @@ -0,0 +1,1056 @@ +{ + "passed": true, + "observed_at": "2026-10-20T15:24:48.992157+00:00", + "scope": "Linux private-allocation descendant peak retention, exact membership, sibling isolation and terminal return", + "source_commit": "b2da5a87af39cbb198d315512d60a4f7e7fc0431", + "source_manifest_sha256": "061ece6c4c78bd2e1c471facfcc048d81db09065f5935e3cda925a07bcfb8f09", + "provider_manifest_sha256": "15e27eea749e5d08f7d41256515b078f256c89fed5c49647c09dc99b99406eae", + "workflow_url": "https://github.com/amberframework/memory_budget/actions/runs/39447776437", + "pull_request": "https://github.com/amberframework/memory_budget/pull/2", + "artifact_id": 12276662830, + "archive_sha256": "5bbdcbb53413e7f95fb67f310802a925cb767d2b06ea451dc409704fae059b4d", + "archive_published_digest": "sha256:5bbdcbb53413e7f95fb67f310802a925cb767d2b06ea451dc409704fae059b4d", + "accepted_probe_cases": 10, + "changed_actual_result_controls": { + "passed": true, + "controls": [ + { + "mode": "ordinary", + "case": "lost_retired_peak", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "The final kernel peak must retain the retired private allocation" + }, + { + "mode": "ordinary", + "case": "changed_exec_birth", + "changed_actual_file": "ordinary-fork-exec.json", + "rejected": true, + "reason": "The same forked process must exec and be reaped by the actual launcher" + }, + { + "mode": "ordinary", + "case": "lost_adoption", + "changed_actual_file": "ordinary-detached.json", + "rejected": true, + "reason": "Detached process/session identity, adoption, mode and normal join required" + }, + { + "mode": "ordinary", + "case": "omitted_live_orphan", + "changed_actual_file": "ordinary-detached.json", + "rejected": true, + "reason": "The detached worker must be observed after its launcher retires" + }, + { + "mode": "ordinary", + "case": "mixed_sibling_charge", + "changed_actual_file": "ordinary-observer.json", + "rejected": true, + "reason": "Sibling private allocation must remain outside the observer budget" + }, + { + "mode": "ordinary", + "case": "same_host_cgroup", + "changed_actual_file": "ordinary-sibling-host.json", + "rejected": true, + "reason": "Actual host sibling hierarchy required" + }, + { + "mode": "ordinary", + "case": "missing_kernel_events", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "Complete typed pressure and OOM event counters are required" + }, + { + "mode": "ordinary", + "case": "changed_command", + "changed_actual_file": "ordinary-direct.inspect.json", + "rejected": true, + "reason": "Exact distinct image, command, mode and environment required" + }, + { + "mode": "ordinary", + "case": "omitted_direct_parent", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "ordinary", + "case": "omitted_fork_parents", + "changed_actual_file": "ordinary-fork-exec.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "ordinary", + "case": "omitted_detached_parents", + "changed_actual_file": "ordinary-detached.json", + "rejected": true, + "reason": "Every live supervisor, launcher and worker must appear inside the measured window" + }, + { + "mode": "ordinary", + "case": "allocation_outside_window", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "optimized", + "case": "lost_retired_peak", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "The final kernel peak must retain the retired private allocation" + }, + { + "mode": "optimized", + "case": "changed_exec_birth", + "changed_actual_file": "optimized-fork-exec.json", + "rejected": true, + "reason": "The same forked process must exec and be reaped by the actual launcher" + }, + { + "mode": "optimized", + "case": "lost_adoption", + "changed_actual_file": "optimized-detached.json", + "rejected": true, + "reason": "Detached process/session identity, adoption, mode and normal join required" + }, + { + "mode": "optimized", + "case": "omitted_live_orphan", + "changed_actual_file": "optimized-detached.json", + "rejected": true, + "reason": "The detached worker must be observed after its launcher retires" + }, + { + "mode": "optimized", + "case": "mixed_sibling_charge", + "changed_actual_file": "optimized-observer.json", + "rejected": true, + "reason": "Sibling private allocation must remain outside the observer budget" + }, + { + "mode": "optimized", + "case": "same_host_cgroup", + "changed_actual_file": "optimized-sibling-host.json", + "rejected": true, + "reason": "Actual host sibling hierarchy required" + }, + { + "mode": "optimized", + "case": "missing_kernel_events", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "Complete typed pressure and OOM event counters are required" + }, + { + "mode": "optimized", + "case": "changed_command", + "changed_actual_file": "optimized-direct.inspect.json", + "rejected": true, + "reason": "Exact distinct image, command, mode and environment required" + }, + { + "mode": "optimized", + "case": "omitted_direct_parent", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "optimized", + "case": "omitted_fork_parents", + "changed_actual_file": "optimized-fork-exec.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "optimized", + "case": "omitted_detached_parents", + "changed_actual_file": "optimized-detached.json", + "rejected": true, + "reason": "Every live supervisor, launcher and worker must appear inside the measured window" + }, + { + "mode": "optimized", + "case": "allocation_outside_window", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + } + ], + "restored_actual_accepted": true + }, + "preserved_cohorts": [ + { + "mode": "ordinary", + "tests": 58 + }, + { + "mode": "optimized", + "tests": 58 + } + ], + "profile_admission_cases": 9, + "measurements": [ + { + "case": "optimized-detached", + "before_current_bytes": 17387520, + "after_current_bytes": 17530880, + "retained_charged_peak_bytes": 109641728, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ] + }, + { + "case": "optimized-direct", + "before_current_bytes": 17534976, + "after_current_bytes": 17575936, + "retained_charged_peak_bytes": 101400576, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ] + }, + { + "case": "optimized-fork-exec", + "before_current_bytes": 17485824, + "after_current_bytes": 17879040, + "retained_charged_peak_bytes": 117981184, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ] + }, + { + "case": "optimized-load", + "before_current_bytes": 17698816, + "after_current_bytes": 17674240, + "retained_charged_peak_bytes": 219279360, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ] + }, + { + "case": "optimized-observer", + "before_current_bytes": 17424384, + "after_current_bytes": 17408000, + "retained_charged_peak_bytes": 17707008, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ] + }, + { + "case": "ordinary-detached", + "before_current_bytes": 16764928, + "after_current_bytes": 16830464, + "retained_charged_peak_bytes": 109555712, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ] + }, + { + "case": "ordinary-direct", + "before_current_bytes": 16945152, + "after_current_bytes": 17076224, + "retained_charged_peak_bytes": 100646912, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ] + }, + { + "case": "ordinary-fork-exec", + "before_current_bytes": 16814080, + "after_current_bytes": 17383424, + "retained_charged_peak_bytes": 117428224, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ] + }, + { + "case": "ordinary-load", + "before_current_bytes": 17571840, + "after_current_bytes": 17543168, + "retained_charged_peak_bytes": 219414528, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ] + }, + { + "case": "ordinary-observer", + "before_current_bytes": 16756736, + "after_current_bytes": 16707584, + "retained_charged_peak_bytes": 17674240, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ] + } + ], + "all_owned_containers_removed": [ + "06b86717d23fc3eca89eae3d3f83ee6aeb28970303a142f969b81989a2ed7d72", + "2f2bdf73ff676a552cb42ffb37b0064e241507b4fa36d02031e04cbacc6fef1e", + "3ac07189b5b5df05bc0d668054ad3be87438c5e271ac8372cd8e885a74f25eb9", + "46b531dd4c8f265f7c8f4f37020ac9e1c011e0083ff8dc92a193ad7144525a73", + "47d9387ee2bb904ac698ef2e07d12edcaf070252f5666a1a72d9df8a6e7462cb", + "51a9962361d055d5fffa120eecc59fbd2293a31b69450552e6c8e0910a0ecb71", + "67fe32a8e203049ac3522dcf851bffa076bb0918b556b415a3aa59c2eb91c057", + "7351a8a5a19f6c6ec07db12baa13c2871de02203f00232a2f0984c947852375f", + "90a850f512fee1bf7a48506920d691665a1941d36b4e01c971a8aebf8edef361", + "92d5aeaa2c9ac1206a35517336d2994c2acd8e00281eb3f5ce5f4ca3c15503ea", + "a7c87a1da254a8c03058cea6afa5292b1faa0af3d60afceccff5224331171177", + "c85901ba053e34b639388408b68492ad2ba785251dd738584a320149291f333f", + "db1b1d86767aaf817cfa031ffd1d1578e716d00f2cfeda33f6ce5f17b022573d", + "e5f9a55aeb78f12ab333a3c17e6492b1936dd44421651c9f171e4bd567317536", + "fb9c557a31209ece63da30e94e080a7dcf40d6a2363cc56a21d384e58afbbf34" + ], + "original_reader_gap": { + "path": "DESCENDANT_MEMBERSHIP_SENSITIVITY_AUDIT.json", + "sha256": "2ce22c4bfee61bf30551967e45a74ad168bc7f720591af084d545226031dd611", + "cases": 6 + }, + "raw_files": [ + { + "path": "descendants-39447776437/_temp/atlas-linux-runner.json", + "bytes": 3166, + "sha256": "8c6d7f589c9693eae10a17b263d5777358023e4bae61335928e902c708f6238f" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/2f2bdf73ff676a552cb42ffb37b0064e241507b4fa36d02031e04cbacc6fef1e.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/2f2bdf73ff676a552cb42ffb37b0064e241507b4fa36d02031e04cbacc6fef1e.cleanup-before.json", + "bytes": 10030, + "sha256": "3233cb53798b17f036dd633d4f8e05c04be39b2c7c00ff80b18b2c180841a11b" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/2f2bdf73ff676a552cb42ffb37b0064e241507b4fa36d02031e04cbacc6fef1e.cleanup.txt", + "bytes": 65, + "sha256": "67d23a32086490c11ae580646701ced79c0c5e1400f828ffc4fcb477a0ca6d71" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/46b531dd4c8f265f7c8f4f37020ac9e1c011e0083ff8dc92a193ad7144525a73.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/46b531dd4c8f265f7c8f4f37020ac9e1c011e0083ff8dc92a193ad7144525a73.cleanup-before.json", + "bytes": 9692, + "sha256": "8c96370b27e1b3138e098a4601d09302bbe070d7222c2656cb3b33ee02ab0bc6" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/46b531dd4c8f265f7c8f4f37020ac9e1c011e0083ff8dc92a193ad7144525a73.cleanup.txt", + "bytes": 65, + "sha256": "794e5e1fa45c1ba960924da2ba211f065cd7b73be48c9e968db26bcb169abcd3" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/7351a8a5a19f6c6ec07db12baa13c2871de02203f00232a2f0984c947852375f.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/7351a8a5a19f6c6ec07db12baa13c2871de02203f00232a2f0984c947852375f.cleanup-before.json", + "bytes": 10047, + "sha256": "9de787fb87f0bdeef82f30e039d0dff780a0e40527c5ef015bfc4a274372b1e2" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/7351a8a5a19f6c6ec07db12baa13c2871de02203f00232a2f0984c947852375f.cleanup.txt", + "bytes": 65, + "sha256": "3d76d1b9f4203cf0729af6d0c949d5d1618dae43e4e34167a7c08ce0b958a9ed" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/TERMINAL_ACCEPTANCE.json", + "bytes": 979, + "sha256": "c65e1a7a610ad66c8410859c5d42d8773e0c52eebf2628dc13aedc41653c34f0" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/a7c87a1da254a8c03058cea6afa5292b1faa0af3d60afceccff5224331171177.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/a7c87a1da254a8c03058cea6afa5292b1faa0af3d60afceccff5224331171177.cleanup-before.json", + "bytes": 10090, + "sha256": "982712f183cef3fdb1ffc23f4b9e2a9987b235c5e5126c414ee9f8bb08dcb3a2" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/a7c87a1da254a8c03058cea6afa5292b1faa0af3d60afceccff5224331171177.cleanup.txt", + "bytes": 65, + "sha256": "8cafeaf4fcff4976a58116ea190c2097f0bd57120df552dc5472d85a7cf25227" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/db1b1d86767aaf817cfa031ffd1d1578e716d00f2cfeda33f6ce5f17b022573d.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/db1b1d86767aaf817cfa031ffd1d1578e716d00f2cfeda33f6ce5f17b022573d.cleanup-before.json", + "bytes": 10042, + "sha256": "b8a53eb8ff4fb99b484cb3a3314cae2601f9f5a602806807c095dd797090b1c7" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/db1b1d86767aaf817cfa031ffd1d1578e716d00f2cfeda33f6ce5f17b022573d.cleanup.txt", + "bytes": 65, + "sha256": "daf771e2d2edea1d16b7e9b4be495fa3844d0e4f37ab0dfb474b522746f4efce" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/docker-version.txt", + "bytes": 769, + "sha256": "7ba4296d98811b3f6017879e4adb5452f8fe84ab8242b9bfd4fe14e394459098" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/image-inspect.json", + "bytes": 2761, + "sha256": "d13a2343013fce26ebed9867149ae25d3e0e4536b54c8493ae6f6c9b9f79c907" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/oom.client-exit.txt", + "bytes": 4, + "sha256": "e3b9c2844b5a5c2677b3a2279db2ec8487491dd9a23d6b22fac153391b3bb63c" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/oom.inspect.json", + "bytes": 10030, + "sha256": "3233cb53798b17f036dd633d4f8e05c04be39b2c7c00ff80b18b2c180841a11b" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/oom.json", + "bytes": 1093, + "sha256": "6f8120e8cda8f3682d506462ee5abff482888cf73c547319aa1d2d0e292905fc" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/oom.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/oom.stdout.txt", + "bytes": 25, + "sha256": "f3543810a54f40b085722baba561f6fc9f617643baeb8def6b5ff20ec3906fbe" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/optimized.client-exit.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/optimized.inspect.json", + "bytes": 10090, + "sha256": "982712f183cef3fdb1ffc23f4b9e2a9987b235c5e5126c414ee9f8bb08dcb3a2" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/optimized.json", + "bytes": 10543, + "sha256": "ed673ba3323d4a641dbfc11d9415b003feb6fe65ebff45ed0005d0346b8864d0" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/optimized.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/optimized.stdout.txt", + "bytes": 120, + "sha256": "48682fb7a0ad60b153234896eecbdac0ab3e4e8d6219fc9b05800530a8cec2df" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/ordinary.client-exit.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/ordinary.inspect.json", + "bytes": 10047, + "sha256": "7539df1506b494e1600ad8ab10c6d5b584d57a38af723982f47dd9011630bd7d" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/ordinary.json", + "bytes": 10544, + "sha256": "85b3e1a5b2957ab341d90115c3a0c35fca95dfad524acbb4183365f66ed55f32" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/ordinary.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/ordinary.stdout.txt", + "bytes": 121, + "sha256": "b845d0f25f5cb004e5d049eabbf9d0d8b8bc6601db21cbdd9101007e19b3b19c" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/terminal-reader.inspect.json", + "bytes": 9692, + "sha256": "8c96370b27e1b3138e098a4601d09302bbe070d7222c2656cb3b33ee02ab0bc6" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/terminal-reader.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/terminal-reader.stdout.txt", + "bytes": 821, + "sha256": "2b99cba09b2532458209da8716bda38c547277658e06a9d0f85e3c8e42d657f7" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/uncapped.client-exit.txt", + "bytes": 2, + "sha256": "53c234e5e8472b6ac51c1ae1cab3fe06fad053beb8ebfd8977b010655bfdd3c3" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/uncapped.inspect.json", + "bytes": 10042, + "sha256": "ce879dc9819e599a4cba83568f99a2c2f2730a0d6992cefd1a3f57aa4e3601a6" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/uncapped.json", + "bytes": 767, + "sha256": "f69637448b1d87b05a796530f7334932fd703fc02232a9f2a58c5ba4bdfc3c6f" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/uncapped.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39447776437-1/uncapped.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/HOST_RESULT.json", + "bytes": 10416, + "sha256": "39e6e14f1575f90201e3a931da042f70e1c3025fd79730543e395ad9b5b84280" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/image-inspect.json", + "bytes": 2403, + "sha256": "577cf7cbc2e736bf03c5fb30c574d3afddad538988293ca5533a6371b977cfbe" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-detached.child.json", + "bytes": 933, + "sha256": "e044a8fff49684f3a1df5f85b780afcabdc65f7f4dceefc88eeb23017b6ce1a8" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-detached.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-detached.cleanup-before.json", + "bytes": 8366, + "sha256": "a2458706b4f4ffb2e2f29067c2a1aaae6fd7b4c3532c327bc554d6605ae619e8" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-detached.cleanup.txt", + "bytes": 65, + "sha256": "39de94162b371b6e4d294fe6274ea718179af3afcfcc23326e359d4d962a4e08" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-detached.inspect.json", + "bytes": 8366, + "sha256": "a2458706b4f4ffb2e2f29067c2a1aaae6fd7b4c3532c327bc554d6605ae619e8" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-detached.json", + "bytes": 4293, + "sha256": "54771c7825e3067422cedc9df3b9dd76fdb92d90ba3fdd45533ea94719c3015f" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-detached.release", + "bytes": 31, + "sha256": "1f720fe3cfb345b4a77488bba20acd8def9d3d9c1a281029604f3904b8a01053" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-detached.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-detached.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-detached.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-direct.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-direct.cleanup-before.json", + "bytes": 8355, + "sha256": "d3a256b6c5bdbd85c60d425b477bf8fccb7454ffe50e810b7bea0bca886f0ae6" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-direct.cleanup.txt", + "bytes": 65, + "sha256": "d0df829902865561bd3cdcdfd995a38b7b1c12bf0b24e5ac919acd36c7b9123e" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-direct.inspect.json", + "bytes": 8355, + "sha256": "9b6704c37d9b1a3794aad5ced7f366bd15b109451ab01a4444b3a622c1a4d0dc" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-direct.json", + "bytes": 4001, + "sha256": "732e116346044eb03ccb82751b83d8bfa9f88056d243b094791e77113145641d" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-direct.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-direct.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-direct.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-fork-exec.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-fork-exec.cleanup-before.json", + "bytes": 8373, + "sha256": "3af70627f56dd6a82aa83b7f19e874be1e6fdb2db45cba7caa56029609092886" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-fork-exec.cleanup.txt", + "bytes": 65, + "sha256": "d16cf028e56fcdb8b411e313b69c7afaada8e0644d7ee7b1783cdeb53c4cae8c" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-fork-exec.inspect.json", + "bytes": 8373, + "sha256": "3af70627f56dd6a82aa83b7f19e874be1e6fdb2db45cba7caa56029609092886" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-fork-exec.json", + "bytes": 4415, + "sha256": "ed02f5ab74a56e51ef8e93397b6b6dc8e80a3700166def28bcd915eca71f2d90" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-fork-exec.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-fork-exec.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-fork-exec.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-load.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-load.cleanup-before.json", + "bytes": 8343, + "sha256": "cc115eb13ccac85fd53e6821fd413188d2dc46180dcc4b51f0ecf42c5790cb6c" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-load.cleanup.txt", + "bytes": 65, + "sha256": "3052d99fa67dea6fac6742cb2d6aaed334a0748dd71cd160c07e25e7cda98b34" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-load.inspect.json", + "bytes": 8343, + "sha256": "cc115eb13ccac85fd53e6821fd413188d2dc46180dcc4b51f0ecf42c5790cb6c" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-load.json", + "bytes": 2723, + "sha256": "cd5c2d4686e687758945daec40f44890eebcba9542fc5128f2e1a54893782604" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-load.ready.json", + "bytes": 759, + "sha256": "5e0a660b2a590c77cac0c8406d54da869608fb4d91b8aa36430949b560733f07" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-load.release", + "bytes": 31, + "sha256": "1f720fe3cfb345b4a77488bba20acd8def9d3d9c1a281029604f3904b8a01053" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-load.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-load.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-load.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-observer.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-observer.cleanup-before.json", + "bytes": 8366, + "sha256": "b6e9fabd7647a008df18f9f1bb1bb56caaa64b5c29750a1d1dcacd95f8638efa" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-observer.cleanup.txt", + "bytes": 65, + "sha256": "00bbec30bf96076606278258c34efdfdc39be9613973037fe5efc28c0a5b896c" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-observer.inspect.json", + "bytes": 8366, + "sha256": "b6e9fabd7647a008df18f9f1bb1bb56caaa64b5c29750a1d1dcacd95f8638efa" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-observer.json", + "bytes": 3549, + "sha256": "5fce963125e8b92e0c9230b67145709e659a223d343c334fc2a6baf33c0ab453" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-observer.ready.json", + "bytes": 727, + "sha256": "ae248f4bcadb617659214efdde3450e68e88cb8a2429d2bb4bbd209d2fc5f44f" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-observer.release", + "bytes": 31, + "sha256": "1f720fe3cfb345b4a77488bba20acd8def9d3d9c1a281029604f3904b8a01053" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-observer.sampled.json", + "bytes": 727, + "sha256": "e108d0638fd956215ca76111b565492328bc4141a67aa90303208134d3ca55cd" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-observer.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-observer.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-observer.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/optimized-sibling-host.json", + "bytes": 1051, + "sha256": "8bd79d7e70b5f040346d52533bb1428260fb09d82db24bb621837604a3cb0889" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-detached.child.json", + "bytes": 934, + "sha256": "ca7c1a9cc3c406e539a484e4584f5877a439b3f59926ece7cce39985d5c3292b" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-detached.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-detached.cleanup-before.json", + "bytes": 8337, + "sha256": "3bbdb2eaf395279365a6fa95b43be2e73791594db553f5cbd899c24a08b781b7" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-detached.cleanup.txt", + "bytes": 65, + "sha256": "1bda561c0296d9a9362838943ef1e01d9232a3e40f4e57265391ea084b0a89ee" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-detached.inspect.json", + "bytes": 8337, + "sha256": "3bbdb2eaf395279365a6fa95b43be2e73791594db553f5cbd899c24a08b781b7" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-detached.json", + "bytes": 4295, + "sha256": "c2d47597770a38baa011bd9e3e6c60ce08923ac3c341c78a101faba00da3c720" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-detached.release", + "bytes": 31, + "sha256": "1f720fe3cfb345b4a77488bba20acd8def9d3d9c1a281029604f3904b8a01053" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-detached.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-detached.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-detached.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-direct.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-direct.cleanup-before.json", + "bytes": 8324, + "sha256": "aa5803c335e511ed0f0d861414c472b8d9ec07bf8e9f63571fc8a047e84e4d20" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-direct.cleanup.txt", + "bytes": 65, + "sha256": "4f48dfb57fb9706e8f9638d1ac14e3f22a1d53dea6233e5e092e96c34a92e963" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-direct.inspect.json", + "bytes": 8324, + "sha256": "aa5803c335e511ed0f0d861414c472b8d9ec07bf8e9f63571fc8a047e84e4d20" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-direct.json", + "bytes": 4003, + "sha256": "b6925b62c4c22ca120cb6930aed4576c6b4a68df67a35cac2e3ce86f0f9ac286" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-direct.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-direct.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-direct.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-fork-exec.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-fork-exec.cleanup-before.json", + "bytes": 8343, + "sha256": "1edf9e7876855dc4f8d61f9218546af4fb66756e51eb7b34a57da03e30e88a76" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-fork-exec.cleanup.txt", + "bytes": 65, + "sha256": "bc3d9058ff3bbdd8f1c98e763f34db47ab6ce668219b3cccfc4a61b53b7686ab" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-fork-exec.inspect.json", + "bytes": 8343, + "sha256": "1edf9e7876855dc4f8d61f9218546af4fb66756e51eb7b34a57da03e30e88a76" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-fork-exec.json", + "bytes": 4417, + "sha256": "a292016a46451f2a68c5b0407130ecf55e3953c260d514ca97301132ee5d52ad" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-fork-exec.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-fork-exec.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-fork-exec.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-load.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-load.cleanup-before.json", + "bytes": 8311, + "sha256": "e62a0955f278b0020ead077ad8b3ed00ab0f82dffae2e372f33fab8d9397ce9c" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-load.cleanup.txt", + "bytes": 65, + "sha256": "aa529c98d08be5251c677a70423031088450128e9b9989367fe39121be933f20" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-load.inspect.json", + "bytes": 8311, + "sha256": "7b3473565d43909f8858b06642b5b3cd6e6f5b4d267e5e4c9e737b4a1ce7998e" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-load.json", + "bytes": 2724, + "sha256": "b5e14b9527565dd3806060d95b92f4390d20babb16910fae87bf3e8b992f0fd8" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-load.ready.json", + "bytes": 759, + "sha256": "c0d6d38fca2bec1b6658587f22c5e10091314c372af6a0902ce7bb905c9ac077" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-load.release", + "bytes": 31, + "sha256": "1f720fe3cfb345b4a77488bba20acd8def9d3d9c1a281029604f3904b8a01053" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-load.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-load.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-load.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-observer.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-observer.cleanup-before.json", + "bytes": 8336, + "sha256": "2c81a04d565db5875ad4739b61abff3792b01024c651a8d87daf4e8cea0ee05f" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-observer.cleanup.txt", + "bytes": 65, + "sha256": "5822c7c1f6551dd6f08f3da8ce9fd89637f3cb1a35dc43534cff83a85d176559" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-observer.inspect.json", + "bytes": 8336, + "sha256": "b8cdef31b346eb722df5f3d0113ac858b247548b751399a5a4166f241a7a1f22" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-observer.json", + "bytes": 3550, + "sha256": "6ca0badb43d5471c5047269dae7ad69d825c2fca028b487dbcf99f73556c8bbf" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-observer.ready.json", + "bytes": 727, + "sha256": "6fa4358d548e30bccb3dc295c676ac587a722c03ea6caebf12588e2d8e1cf10f" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-observer.release", + "bytes": 31, + "sha256": "1f720fe3cfb345b4a77488bba20acd8def9d3d9c1a281029604f3904b8a01053" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-observer.sampled.json", + "bytes": 727, + "sha256": "bee9331e3a55be6fbbbbb5e2eded71f1bf60553329ee3122eeead2428b457070" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-observer.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-observer.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-observer.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39447776437/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39447776437-1/ordinary-sibling-host.json", + "bytes": 1051, + "sha256": "ae653214534072d4c3dd6b8e5cf9cc35c45638e90aa16f67be8058ca1916a3c0" + } + ], + "actual_Crystal_compilations": 0, + "actual_Grant_cells": 0, + "compiler_rss_accepted": false, + "complete_Grant_build_accepted": false, + "installed_SDK_accepted": false, + "clean_device_installation_accepted": false, + "remaining_build_provider_gates": [ + "shared and migrated charge boundaries", + "compiler-process RSS qualification", + "complete real build window and behavior" + ] +} diff --git a/tools/whole_build_memory/evidence/linux-descendants-39447776437.github-artifact.json b/tools/whole_build_memory/evidence/linux-descendants-39447776437.github-artifact.json new file mode 100644 index 0000000..dd78538 --- /dev/null +++ b/tools/whole_build_memory/evidence/linux-descendants-39447776437.github-artifact.json @@ -0,0 +1 @@ +{"total_count":1,"artifacts":[{"id":12276662830,"node_id":"MDg6QXJ0aWZhY3QxMjI3NjY2MjgzMA==","name":"linux-kernel-budget-39447776437-1","size_in_bytes":146765,"url":"https://api.github.com/repos/amberframework/memory_budget/actions/artifacts/12276662830","archive_download_url":"https://api.github.com/repos/amberframework/memory_budget/actions/artifacts/12276662830/zip","expired":false,"digest":"sha256:5bbdcbb53413e7f95fb67f310802a925cb767d2b06ea451dc409704fae059b4d","created_at":"2026-10-20T15:22:58Z","updated_at":"2026-10-20T15:22:58Z","expires_at":"2026-11-03T15:22:56Z","workflow_run":{"id":39447776437,"repository_id":1424629640,"head_repository_id":1424629640,"head_branch":"feature/linux-kernel-budget-controls","head_sha":"b2da5a87af39cbb198d315512d60a4f7e7fc0431"}}]} \ No newline at end of file diff --git a/tools/whole_build_memory/evidence/linux-descendants-39447776437.zip b/tools/whole_build_memory/evidence/linux-descendants-39447776437.zip new file mode 100644 index 0000000..0cd537c Binary files /dev/null and b/tools/whole_build_memory/evidence/linux-descendants-39447776437.zip differ diff --git a/tools/whole_build_memory/evidence/linux-rss-39449551836-attempt-1-oom-marker-refusal.zip b/tools/whole_build_memory/evidence/linux-rss-39449551836-attempt-1-oom-marker-refusal.zip new file mode 100644 index 0000000..532a128 Binary files /dev/null and b/tools/whole_build_memory/evidence/linux-rss-39449551836-attempt-1-oom-marker-refusal.zip differ diff --git a/tools/whole_build_memory/evidence/linux-rss-39449551836-attempt-1.refusal.json b/tools/whole_build_memory/evidence/linux-rss-39449551836-attempt-1.refusal.json new file mode 100644 index 0000000..b7bba90 --- /dev/null +++ b/tools/whole_build_memory/evidence/linux-rss-39449551836-attempt-1.refusal.json @@ -0,0 +1,312 @@ +{ + "passed": false, + "source_commit": "3ea3bfcc55e1e520ee25d69000ea5e8d17d4a62a", + "run_id": 39449551836, + "attempt": 1, + "reason": "Real over-limit process exited 137; Docker OOMKilled was false in both terminal and cleanup observations. Existing exact OOM gate correctly refused.", + "ordinary_tests": 58, + "optimized_tests": 58, + "profile_tests": 9, + "RSS_stage_executed": false, + "actual_Grant_cells": 0, + "all_owned_returned": [ + { + "id": "138847c9712e29cd8616632d9eb6142d390ffc1ae74668258c1ecc2264d694e1", + "case": "/atlas-install-39449551836-1-oom", + "state": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 137, + "Error": "", + "StartedAt": "2026-10-20T15:34:02.814097183Z", + "FinishedAt": "2026-10-20T15:34:03.189917213Z" + }, + "removed_and_absent": true + }, + { + "id": "5907a01803cb9c59e2b089b0d46382dcdb2c12b8256a33f86d6723893fbfb45e", + "case": "/atlas-install-39449551836-1-optimized", + "state": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-20T15:34:01.771658794Z", + "FinishedAt": "2026-10-20T15:34:02.699348476Z" + }, + "removed_and_absent": true + }, + { + "id": "6a92efc4e67e3094e3199e21005cc730c272b543b0ab3769a5541c2c9f294925", + "case": "/atlas-install-39449551836-1-terminal-reader", + "state": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 1, + "Error": "", + "StartedAt": "2026-10-20T15:34:03.770888144Z", + "FinishedAt": "2026-10-20T15:34:04.128246372Z" + }, + "removed_and_absent": true + }, + { + "id": "d8076a80563347b9f2d3d094b42104c4817f9cb9d1b21d74238b5378d6db5320", + "case": "/atlas-install-39449551836-1-ordinary", + "state": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-20T15:34:00.681296506Z", + "FinishedAt": "2026-10-20T15:34:01.646042949Z" + }, + "removed_and_absent": true + }, + { + "id": "f6096d139d134327e78f45c1505860346e7818cd2eed6969ef8fbf57d5dfe842", + "case": "/atlas-install-39449551836-1-uncapped", + "state": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 2, + "Error": "", + "StartedAt": "2026-10-20T15:34:03.306358688Z", + "FinishedAt": "2026-10-20T15:34:03.66370995Z" + }, + "removed_and_absent": true + } + ], + "archive_sha256": "e3600ec03e73ffb8eaeec868628fd70b85ec38e610bf9420b36e0fc5b850843f", + "raw_files": [ + { + "path": "failed-rss-prerequisite-39449551836/_temp/atlas-linux-runner.json", + "bytes": 3165, + "sha256": "1fc62417fdfa37c71e6a09bb201bca76eed668767057dd7cbbc70fe9dc732310" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/138847c9712e29cd8616632d9eb6142d390ffc1ae74668258c1ecc2264d694e1.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/138847c9712e29cd8616632d9eb6142d390ffc1ae74668258c1ecc2264d694e1.cleanup-before.json", + "bytes": 10032, + "sha256": "b51cc45b9742bd90ae9b5b1eb5e80d35b59fc47ffaff862c8cff523297040aa2" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/138847c9712e29cd8616632d9eb6142d390ffc1ae74668258c1ecc2264d694e1.cleanup.txt", + "bytes": 65, + "sha256": "dae98a3da1f7320a3cd158c751619f0e6b3136743d5627c8dcf338e0fccf9a2a" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/5907a01803cb9c59e2b089b0d46382dcdb2c12b8256a33f86d6723893fbfb45e.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/5907a01803cb9c59e2b089b0d46382dcdb2c12b8256a33f86d6723893fbfb45e.cleanup-before.json", + "bytes": 10090, + "sha256": "d802619c70f8f6222ddd9bc6b281fabf798530ca4a8acc0487b0bfadfac10ed7" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/5907a01803cb9c59e2b089b0d46382dcdb2c12b8256a33f86d6723893fbfb45e.cleanup.txt", + "bytes": 65, + "sha256": "eb936be3a725430b24d771a7053b6ae487e29756241f260d1a2024acf5c6fdd8" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/6a92efc4e67e3094e3199e21005cc730c272b543b0ab3769a5541c2c9f294925.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/6a92efc4e67e3094e3199e21005cc730c272b543b0ab3769a5541c2c9f294925.cleanup-before.json", + "bytes": 9695, + "sha256": "1df2d899c12125adff6f02c1b73af70127c425f1294948f5a5a8a12966d1a9a9" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/6a92efc4e67e3094e3199e21005cc730c272b543b0ab3769a5541c2c9f294925.cleanup.txt", + "bytes": 65, + "sha256": "8e49d1c64a90eb7423cb2dab9dc4f95b64aa109c2fff7073c3e782f46839fa66" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/d8076a80563347b9f2d3d094b42104c4817f9cb9d1b21d74238b5378d6db5320.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/d8076a80563347b9f2d3d094b42104c4817f9cb9d1b21d74238b5378d6db5320.cleanup-before.json", + "bytes": 10047, + "sha256": "18af50b8e020a111a3ff46bb0b79bcf5ddfc9df45f169d5ecb5ec740eb9fb4a4" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/d8076a80563347b9f2d3d094b42104c4817f9cb9d1b21d74238b5378d6db5320.cleanup.txt", + "bytes": 65, + "sha256": "32b25ae496c8ea7de58ae31c0090413ae0119b8ac7b1ae114d0afea545994bfd" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/docker-version.txt", + "bytes": 769, + "sha256": "8402d8b7679b4087fa4fb62264e49054f974146c5d134195d8b7a341747ab4ed" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/f6096d139d134327e78f45c1505860346e7818cd2eed6969ef8fbf57d5dfe842.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/f6096d139d134327e78f45c1505860346e7818cd2eed6969ef8fbf57d5dfe842.cleanup-before.json", + "bytes": 10042, + "sha256": "71ae45814f3f1cf734140b2ae8a83dc4f0b868d345cb7aeb734b639c289dac63" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/f6096d139d134327e78f45c1505860346e7818cd2eed6969ef8fbf57d5dfe842.cleanup.txt", + "bytes": 65, + "sha256": "beba10c418f87e9d6fecf90a7173f5f459aa948c3db0d1b0397caa9cf9b47769" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/image-inspect.json", + "bytes": 2761, + "sha256": "d87bcbfd7ce0611ced8a14703751a47a41ec7a419535f0628ede60ab4f201150" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/oom.client-exit.txt", + "bytes": 4, + "sha256": "e3b9c2844b5a5c2677b3a2279db2ec8487491dd9a23d6b22fac153391b3bb63c" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/oom.inspect.json", + "bytes": 10032, + "sha256": "572f6aa301ba39fa7c198c124d5e62f4942f744f9f687350afbf24638aeaa3bc" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/oom.json", + "bytes": 1119, + "sha256": "46f1f8a9bc696cd3621f9d5924ee1915dbcd90ecf7e812849681b38160526d9a" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/oom.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/oom.stdout.txt", + "bytes": 25, + "sha256": "f3543810a54f40b085722baba561f6fc9f617643baeb8def6b5ff20ec3906fbe" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/optimized.client-exit.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/optimized.inspect.json", + "bytes": 10090, + "sha256": "d802619c70f8f6222ddd9bc6b281fabf798530ca4a8acc0487b0bfadfac10ed7" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/optimized.json", + "bytes": 10596, + "sha256": "50964cbf2010e2a2ce20b7cdafe651b01b550fa5cfb430f5f0b858d3bca73201" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/optimized.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/optimized.stdout.txt", + "bytes": 120, + "sha256": "48682fb7a0ad60b153234896eecbdac0ab3e4e8d6219fc9b05800530a8cec2df" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/ordinary.client-exit.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/ordinary.inspect.json", + "bytes": 10047, + "sha256": "18af50b8e020a111a3ff46bb0b79bcf5ddfc9df45f169d5ecb5ec740eb9fb4a4" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/ordinary.json", + "bytes": 10597, + "sha256": "db5342a46cb494a81e0f6edda9d4d3b7513f0c3f1d42c82ad27cbe373df83ee2" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/ordinary.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/ordinary.stdout.txt", + "bytes": 121, + "sha256": "b845d0f25f5cb004e5d049eabbf9d0d8b8bc6601db21cbdd9101007e19b3b19c" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/terminal-reader.inspect.json", + "bytes": 9695, + "sha256": "d76f02e25e9ac80fe81981493b457f6ee161e694da002bfca020c1ee0f9d83d9" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/terminal-reader.stderr.txt", + "bytes": 631, + "sha256": "fe1990792b72646941c4e8dfe589f7363f912d6228882aebab6f08a45af107c8" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/terminal-reader.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/uncapped.client-exit.txt", + "bytes": 2, + "sha256": "53c234e5e8472b6ac51c1ae1cab3fe06fad053beb8ebfd8977b010655bfdd3c3" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/uncapped.inspect.json", + "bytes": 10042, + "sha256": "71ae45814f3f1cf734140b2ae8a83dc4f0b868d345cb7aeb734b639c289dac63" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/uncapped.json", + "bytes": 766, + "sha256": "fdc0d3fdd22bd24a2c093a524d9faf69c3813d1560d6ba962b2491268d85bd5a" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/uncapped.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "failed-rss-prerequisite-39449551836/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-1/uncapped.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + ] +} diff --git a/tools/whole_build_memory/evidence/linux-rss-39449551836-attempt-2.acceptance.json b/tools/whole_build_memory/evidence/linux-rss-39449551836-attempt-2.acceptance.json new file mode 100644 index 0000000..aa90db2 --- /dev/null +++ b/tools/whole_build_memory/evidence/linux-rss-39449551836-attempt-2.acceptance.json @@ -0,0 +1,1315 @@ +{ + "passed": true, + "observed_at": "2026-10-20T15:38:34.835804+00:00", + "scope": "Linux self/largest-waited-child RSS contrasted with overlapping private cgroup charges and inherited descendant/sibling controls", + "source_commit": "3ea3bfcc55e1e520ee25d69000ea5e8d17d4a62a", + "run_attempt": 2, + "source_manifest_sha256": "a2b816772ffc66ed8bebbb405c52f54434baa663a5d6afae63e87252da1b287c", + "provider_manifest_sha256": "15e27eea749e5d08f7d41256515b078f256c89fed5c49647c09dc99b99406eae", + "workflow_url": "https://github.com/amberframework/memory_budget/actions/runs/39449551836/attempts/2", + "pull_request": "https://github.com/amberframework/memory_budget/pull/2", + "artifact_id": 12277666488, + "archive_sha256": "4ff7637e68a81fa5ed218733a14238219b9b9908a23cdddc4a836136da7999cf", + "archive_published_digest": "sha256:4ff7637e68a81fa5ed218733a14238219b9b9908a23cdddc4a836136da7999cf", + "accepted_probe_cases": 12, + "changed_actual_result_controls": { + "passed": true, + "controls": [ + { + "mode": "ordinary", + "case": "lost_retired_peak", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "Positive current and peak memory must fit the strict byte budget" + }, + { + "mode": "ordinary", + "case": "changed_exec_birth", + "changed_actual_file": "ordinary-fork-exec.json", + "rejected": true, + "reason": "The same forked process must exec and be reaped by the actual launcher" + }, + { + "mode": "ordinary", + "case": "lost_adoption", + "changed_actual_file": "ordinary-detached.json", + "rejected": true, + "reason": "Detached process/session identity, adoption, mode and normal join required" + }, + { + "mode": "ordinary", + "case": "omitted_live_orphan", + "changed_actual_file": "ordinary-detached.json", + "rejected": true, + "reason": "The detached worker must be observed after its launcher retires" + }, + { + "mode": "ordinary", + "case": "mixed_sibling_charge", + "changed_actual_file": "ordinary-observer.json", + "rejected": true, + "reason": "Sibling private allocation must remain outside the observer budget" + }, + { + "mode": "ordinary", + "case": "same_host_cgroup", + "changed_actual_file": "ordinary-sibling-host.json", + "rejected": true, + "reason": "Actual host sibling hierarchy required" + }, + { + "mode": "ordinary", + "case": "missing_kernel_events", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "Complete typed pressure and OOM event counters are required" + }, + { + "mode": "ordinary", + "case": "changed_command", + "changed_actual_file": "ordinary-direct.inspect.json", + "rejected": true, + "reason": "Exact distinct image, command, mode and environment required" + }, + { + "mode": "ordinary", + "case": "omitted_direct_parent", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "ordinary", + "case": "omitted_fork_parents", + "changed_actual_file": "ordinary-fork-exec.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "ordinary", + "case": "omitted_detached_parents", + "changed_actual_file": "ordinary-detached.json", + "rejected": true, + "reason": "Every live supervisor, launcher and worker must appear inside the measured window" + }, + { + "mode": "ordinary", + "case": "allocation_outside_window", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "ordinary", + "case": "lost_waited_rss_peak", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "The waited-child maximum must retain the real worker RSS high-water mark" + }, + { + "mode": "ordinary", + "case": "boolean_self_rss", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "Typed Linux maximum RSS counters in KiB are required" + }, + { + "mode": "ordinary", + "case": "rss_bytes_used_as_kib", + "changed_actual_file": "ordinary-rss-overlap.json", + "rejected": true, + "reason": "Largest waited-child RSS and simultaneous whole-group charge must remain distinct" + }, + { + "mode": "ordinary", + "case": "summed_rss_used_as_largest", + "changed_actual_file": "ordinary-rss-overlap.json", + "rejected": true, + "reason": "Largest waited-child RSS and simultaneous whole-group charge must remain distinct" + }, + { + "mode": "ordinary", + "case": "overlap_omitted_worker", + "changed_actual_file": "ordinary-rss-overlap.json", + "rejected": true, + "reason": "Both consumed private allocations must be live in the same measured window" + }, + { + "mode": "optimized", + "case": "lost_retired_peak", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "The final kernel peak must retain the retired private allocation" + }, + { + "mode": "optimized", + "case": "changed_exec_birth", + "changed_actual_file": "optimized-fork-exec.json", + "rejected": true, + "reason": "The same forked process must exec and be reaped by the actual launcher" + }, + { + "mode": "optimized", + "case": "lost_adoption", + "changed_actual_file": "optimized-detached.json", + "rejected": true, + "reason": "Detached process/session identity, adoption, mode and normal join required" + }, + { + "mode": "optimized", + "case": "omitted_live_orphan", + "changed_actual_file": "optimized-detached.json", + "rejected": true, + "reason": "The detached worker must be observed after its launcher retires" + }, + { + "mode": "optimized", + "case": "mixed_sibling_charge", + "changed_actual_file": "optimized-observer.json", + "rejected": true, + "reason": "Sibling private allocation must remain outside the observer budget" + }, + { + "mode": "optimized", + "case": "same_host_cgroup", + "changed_actual_file": "optimized-sibling-host.json", + "rejected": true, + "reason": "Actual host sibling hierarchy required" + }, + { + "mode": "optimized", + "case": "missing_kernel_events", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "Complete typed pressure and OOM event counters are required" + }, + { + "mode": "optimized", + "case": "changed_command", + "changed_actual_file": "optimized-direct.inspect.json", + "rejected": true, + "reason": "Exact distinct image, command, mode and environment required" + }, + { + "mode": "optimized", + "case": "omitted_direct_parent", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "optimized", + "case": "omitted_fork_parents", + "changed_actual_file": "optimized-fork-exec.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "optimized", + "case": "omitted_detached_parents", + "changed_actual_file": "optimized-detached.json", + "rejected": true, + "reason": "Every live supervisor, launcher and worker must appear inside the measured window" + }, + { + "mode": "optimized", + "case": "allocation_outside_window", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "optimized", + "case": "lost_waited_rss_peak", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "The waited-child maximum must retain the real worker RSS high-water mark" + }, + { + "mode": "optimized", + "case": "boolean_self_rss", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "Typed Linux maximum RSS counters in KiB are required" + }, + { + "mode": "optimized", + "case": "rss_bytes_used_as_kib", + "changed_actual_file": "optimized-rss-overlap.json", + "rejected": true, + "reason": "Largest waited-child RSS and simultaneous whole-group charge must remain distinct" + }, + { + "mode": "optimized", + "case": "summed_rss_used_as_largest", + "changed_actual_file": "optimized-rss-overlap.json", + "rejected": true, + "reason": "Largest waited-child RSS and simultaneous whole-group charge must remain distinct" + }, + { + "mode": "optimized", + "case": "overlap_omitted_worker", + "changed_actual_file": "optimized-rss-overlap.json", + "rejected": true, + "reason": "Both consumed private allocations must be live in the same measured window" + } + ], + "restored_actual_accepted": true + }, + "preserved_cohorts": [ + { + "mode": "ordinary", + "tests": 58 + }, + { + "mode": "optimized", + "tests": 58 + } + ], + "profile_admission_cases": 9, + "measurements": [ + { + "case": "optimized-detached", + "before_current_bytes": 17784832, + "after_current_bytes": 17862656, + "retained_charged_peak_bytes": 110305280, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 26910720, + "after_largest_waited_child_rss_bytes": 88014848, + "held_individual_rss_bytes": [] + }, + { + "case": "optimized-direct", + "before_current_bytes": 17457152, + "after_current_bytes": 17743872, + "retained_charged_peak_bytes": 101339136, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 27123712, + "after_largest_waited_child_rss_bytes": 93872128, + "held_individual_rss_bytes": [] + }, + { + "case": "optimized-fork-exec", + "before_current_bytes": 16801792, + "after_current_bytes": 17412096, + "retained_charged_peak_bytes": 116256768, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 27021312, + "after_largest_waited_child_rss_bytes": 93212672, + "held_individual_rss_bytes": [] + }, + { + "case": "optimized-load", + "before_current_bytes": 17465344, + "after_current_bytes": 17969152, + "retained_charged_peak_bytes": 219308032, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 228270080, + "after_largest_waited_child_rss_bytes": 0, + "held_individual_rss_bytes": [] + }, + { + "case": "optimized-observer", + "before_current_bytes": 17543168, + "after_current_bytes": 17571840, + "retained_charged_peak_bytes": 18087936, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 26963968, + "after_largest_waited_child_rss_bytes": 0, + "held_individual_rss_bytes": [] + }, + { + "case": "optimized-rss-overlap", + "before_current_bytes": 18001920, + "after_current_bytes": 17879040, + "retained_charged_peak_bytes": 185597952, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 27013120, + "after_largest_waited_child_rss_bytes": 93970432, + "held_individual_rss_bytes": [ + 93782016, + 93970432 + ] + }, + { + "case": "ordinary-detached", + "before_current_bytes": 17575936, + "after_current_bytes": 17838080, + "retained_charged_peak_bytes": 110313472, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 26976256, + "after_largest_waited_child_rss_bytes": 87949312, + "held_individual_rss_bytes": [] + }, + { + "case": "ordinary-direct", + "before_current_bytes": 17289216, + "after_current_bytes": 17862656, + "retained_charged_peak_bytes": 101642240, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 27054080, + "after_largest_waited_child_rss_bytes": 93872128, + "held_individual_rss_bytes": [] + }, + { + "case": "ordinary-fork-exec", + "before_current_bytes": 17539072, + "after_current_bytes": 17960960, + "retained_charged_peak_bytes": 118145024, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 26947584, + "after_largest_waited_child_rss_bytes": 93741056, + "held_individual_rss_bytes": [] + }, + { + "case": "ordinary-load", + "before_current_bytes": 17600512, + "after_current_bytes": 17842176, + "retained_charged_peak_bytes": 219181056, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 228233216, + "after_largest_waited_child_rss_bytes": 0, + "held_individual_rss_bytes": [] + }, + { + "case": "ordinary-observer", + "before_current_bytes": 17539072, + "after_current_bytes": 17526784, + "retained_charged_peak_bytes": 17825792, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 26816512, + "after_largest_waited_child_rss_bytes": 0, + "held_individual_rss_bytes": [] + }, + { + "case": "ordinary-rss-overlap", + "before_current_bytes": 17698816, + "after_current_bytes": 18030592, + "retained_charged_peak_bytes": 185487360, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 27144192, + "after_largest_waited_child_rss_bytes": 94117888, + "held_individual_rss_bytes": [ + 93851648, + 93974528 + ] + } + ], + "all_owned_containers_removed": [ + "0612fba6c5250fa5e44808ec1da252942a530b991f21ff0a8b4600c56fb1cf7f", + "0bf0a142efb01742b56387f26fc0790fb5af5ee59c49ab829065abde332049bc", + "295e2691b9c83200fd662035a89005c25c3a7ef7b9d7eb7ad8f77e211514b881", + "3cf15c93e09477df416bd11ac78f46da25bf310bee51b958c5a24e5ef193970d", + "45b81194de489b1a4c9c489c74ed87a74e78ae26dd9cbd710aa7a056e6c858c6", + "522be44c1750ace95b26b1d62d1a350c534d9ec33f6988dd048047f530954965", + "5cca2de58d8d88ae7818c7fe6d71a856f0952d4bd511acb20a2d8ce43d9cfdec", + "75e0333cfde3c5e2c16affe36fad7fae2480e3cc444f44250e67ac772dc941e2", + "8541342d964b16c0619ea217a17ca1f6b00671dd864227127fed7f76e85c9152", + "965f2c1d6c1f1fad01748de8eeb9ca2422dd5598fe1336ff42a6e6fca2d45b5e", + "b2650f9b616596a58afdeb53a2d358b3c156f9915354cca2bf6d01ba0d0a079c", + "c6fd287c922f69ec575723ddab7f668dbf30b0473dd6d03289d04e7395738732", + "c881c1a7e620825a15de221014f38974cfc13c9665bd93937ed5f5699b68130c", + "d18c4a0c8e13dc79feb659e33038c9e7f56fc10bcd7f810c1c29d990e8ba3d3d", + "d2b14706fdcc7c2b625d15f0c7a40c9bc66d0fbbd6fef86a58f1e401eb44ecfe", + "d4677e7c0948a79cb11aba1823b862a8733b4d0c2d7dad9458fbfe88a72cdb45", + "d97c27694c3f3fd245408392a6b772742016d38ff6f3ffab526b3b94133badaa" + ], + "original_reader_gap": { + "path": "DESCENDANT_MEMBERSHIP_SENSITIVITY_AUDIT.json", + "sha256": "2ce22c4bfee61bf30551967e45a74ad168bc7f720591af084d545226031dd611", + "cases": 6 + }, + "first_attempt_refusal": { + "path": "RSS_PREREQUISITE_OOM_MARKER_REFUSAL.json", + "sha256": "2875eb4369bc0b0f47bb8cfdf7a037ab76d225d2407881072e47169932ca2ffd", + "archive_sha256": "e3600ec03e73ffb8eaeec868628fd70b85ec38e610bf9420b36e0fc5b850843f", + "all_owned_containers_removed": 5, + "identical_observed_profile": true, + "rss_stage_executed": false + }, + "raw_files": [ + { + "path": "rss-39449551836-attempt-2/_temp/atlas-linux-runner.json", + "bytes": 3164, + "sha256": "0f455643708d2bb033591841088444d32262ec7f77499fb6b5c942552f57ceb7" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/5cca2de58d8d88ae7818c7fe6d71a856f0952d4bd511acb20a2d8ce43d9cfdec.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/5cca2de58d8d88ae7818c7fe6d71a856f0952d4bd511acb20a2d8ce43d9cfdec.cleanup-before.json", + "bytes": 10047, + "sha256": "094cfe10a0ecb5a38ca2543fd18a1992f30fc19a72ac73f4fcf42030cc90d0b5" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/5cca2de58d8d88ae7818c7fe6d71a856f0952d4bd511acb20a2d8ce43d9cfdec.cleanup.txt", + "bytes": 65, + "sha256": "b7f97514d8a2bbce4b417ff37e554d955ce35d5fa3eb0e84608b495a4e55ca6e" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/965f2c1d6c1f1fad01748de8eeb9ca2422dd5598fe1336ff42a6e6fca2d45b5e.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/965f2c1d6c1f1fad01748de8eeb9ca2422dd5598fe1336ff42a6e6fca2d45b5e.cleanup-before.json", + "bytes": 10041, + "sha256": "134a597951121c50ede724bcbac33320999e430f3eca465adfee4f88bad4843b" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/965f2c1d6c1f1fad01748de8eeb9ca2422dd5598fe1336ff42a6e6fca2d45b5e.cleanup.txt", + "bytes": 65, + "sha256": "5b76d40f860f4d3d296ff3400e3755fce7bc327d2eb933a7a676b6befa96969c" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/TERMINAL_ACCEPTANCE.json", + "bytes": 979, + "sha256": "1ab25af61db2af5be48e41d77a2bb4ef812af7653d6538aa68bee3cd0c9621e2" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/c6fd287c922f69ec575723ddab7f668dbf30b0473dd6d03289d04e7395738732.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/c6fd287c922f69ec575723ddab7f668dbf30b0473dd6d03289d04e7395738732.cleanup-before.json", + "bytes": 10089, + "sha256": "04d1697d2533041bb56838f3906c6cee7f9673f321418f0310eab8b33a2766cf" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/c6fd287c922f69ec575723ddab7f668dbf30b0473dd6d03289d04e7395738732.cleanup.txt", + "bytes": 65, + "sha256": "4b2e6912361316d5035718e09b7cd398a51c200b2fc3f88a71bcf6ee86974f2c" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/d18c4a0c8e13dc79feb659e33038c9e7f56fc10bcd7f810c1c29d990e8ba3d3d.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/d18c4a0c8e13dc79feb659e33038c9e7f56fc10bcd7f810c1c29d990e8ba3d3d.cleanup-before.json", + "bytes": 9695, + "sha256": "a194e746222d8a9d03fb4a794adffdaf0a7abd7c74a1468d2d612d267efef46f" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/d18c4a0c8e13dc79feb659e33038c9e7f56fc10bcd7f810c1c29d990e8ba3d3d.cleanup.txt", + "bytes": 65, + "sha256": "85781cb6a932c291614d14bc45df6fdda8b421d889b8bd5f1a5c0e8b4b4c9293" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/d2b14706fdcc7c2b625d15f0c7a40c9bc66d0fbbd6fef86a58f1e401eb44ecfe.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/d2b14706fdcc7c2b625d15f0c7a40c9bc66d0fbbd6fef86a58f1e401eb44ecfe.cleanup-before.json", + "bytes": 10031, + "sha256": "4410af23c8414f6a47aa91b7ef2f5e1fb2502fdd14b2eb1c757d3a350ec94d21" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/d2b14706fdcc7c2b625d15f0c7a40c9bc66d0fbbd6fef86a58f1e401eb44ecfe.cleanup.txt", + "bytes": 65, + "sha256": "ad978c788163096615c58fcfe33e01670025459b52979a78cef9ad8fee5d09cc" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/docker-version.txt", + "bytes": 769, + "sha256": "8402d8b7679b4087fa4fb62264e49054f974146c5d134195d8b7a341747ab4ed" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/image-inspect.json", + "bytes": 2761, + "sha256": "f2714d0fbe7c83698cd1100df723fa005845a6a1bb71cb35e35edb8b394442a3" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/oom.client-exit.txt", + "bytes": 4, + "sha256": "e3b9c2844b5a5c2677b3a2279db2ec8487491dd9a23d6b22fac153391b3bb63c" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/oom.inspect.json", + "bytes": 10031, + "sha256": "3512d9197a568efe45aa558bb11d060ebcea0c0da8cd7fe63e6bf46f121ba14e" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/oom.json", + "bytes": 1119, + "sha256": "d55b006f19faee91b1ac01a090836eccef4d4003c58a81d3ded72516a649937e" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/oom.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/oom.stdout.txt", + "bytes": 25, + "sha256": "f3543810a54f40b085722baba561f6fc9f617643baeb8def6b5ff20ec3906fbe" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/optimized.client-exit.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/optimized.inspect.json", + "bytes": 10089, + "sha256": "9de0fb253df670dedf26cbbcfb5ad3507eb9a01cfb774ffe22332618bb91ecd4" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/optimized.json", + "bytes": 10596, + "sha256": "f63761601642949b8884aad9ae702324e1b4977fa6f886b50d5a0924c6e45a4c" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/optimized.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/optimized.stdout.txt", + "bytes": 120, + "sha256": "48682fb7a0ad60b153234896eecbdac0ab3e4e8d6219fc9b05800530a8cec2df" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/ordinary.client-exit.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/ordinary.inspect.json", + "bytes": 10047, + "sha256": "094cfe10a0ecb5a38ca2543fd18a1992f30fc19a72ac73f4fcf42030cc90d0b5" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/ordinary.json", + "bytes": 10597, + "sha256": "0b5db75c4cb53aa569f2fd4453ceeae802286b6804acfedc26182349e67bbda3" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/ordinary.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/ordinary.stdout.txt", + "bytes": 121, + "sha256": "b845d0f25f5cb004e5d049eabbf9d0d8b8bc6601db21cbdd9101007e19b3b19c" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/terminal-reader.inspect.json", + "bytes": 9695, + "sha256": "a194e746222d8a9d03fb4a794adffdaf0a7abd7c74a1468d2d612d267efef46f" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/terminal-reader.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/terminal-reader.stdout.txt", + "bytes": 821, + "sha256": "83a2b6f9d5695d720f96ee9fa4ae812be0e36ce22f61b910e7531b1617622302" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/uncapped.client-exit.txt", + "bytes": 2, + "sha256": "53c234e5e8472b6ac51c1ae1cab3fe06fad053beb8ebfd8977b010655bfdd3c3" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/uncapped.inspect.json", + "bytes": 10041, + "sha256": "134a597951121c50ede724bcbac33320999e430f3eca465adfee4f88bad4843b" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/uncapped.json", + "bytes": 766, + "sha256": "999e454ac13b39d06b6d16acf653de618b74e63b3aa55fb9ed60ea5ad23c62d2" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/uncapped.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39449551836-2/uncapped.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/HOST_RESULT.json", + "bytes": 13923, + "sha256": "fc4ca4934b0f5626c236f4451fe5d6872853f1f2f0a5753f409853cd484ba291" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/image-inspect.json", + "bytes": 2403, + "sha256": "05f160105b788cb6c5de8bf17f866a2791fb980c398fb32f6253a1c426475d72" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-detached.child.json", + "bytes": 1033, + "sha256": "162acbeeff065a63783a3221d2a351f9ee4a129dc6fe0c2454e687402dfade4e" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-detached.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-detached.cleanup-before.json", + "bytes": 8367, + "sha256": "88b625f3a21fb5de28679e352617dfdad7a18ee2714d23efd64815b6f5c3abd9" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-detached.cleanup.txt", + "bytes": 65, + "sha256": "4a00ccdf446357fc100a43ada8b26c085620478153e1936a595dd075aaee021e" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-detached.inspect.json", + "bytes": 8367, + "sha256": "88b625f3a21fb5de28679e352617dfdad7a18ee2714d23efd64815b6f5c3abd9" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-detached.json", + "bytes": 4713, + "sha256": "b49981aaab5242ae31508801c5570ae9c57a0104e6a5062a3b5a52c6a8ecc40f" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-detached.release", + "bytes": 31, + "sha256": "b949cb06de5e7d5f4fc97c2867af7958d56dfc81b3e3b966415f0f25309ced11" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-detached.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-detached.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-detached.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-direct.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-direct.cleanup-before.json", + "bytes": 8355, + "sha256": "234d9603bc7a5812f3fee91cf424dd8604697fadf7cbbc4397375d2e09b809bc" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-direct.cleanup.txt", + "bytes": 65, + "sha256": "bc5d899bf24f23b25a11f0aed976248fabbae215a67b9d6ca651a076d4290483" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-direct.inspect.json", + "bytes": 8355, + "sha256": "234d9603bc7a5812f3fee91cf424dd8604697fadf7cbbc4397375d2e09b809bc" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-direct.json", + "bytes": 4429, + "sha256": "5aed823b9153e4faf08b6b8c37560494808fa49527f7cf1ecbf9b0931cf30e59" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-direct.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-direct.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-direct.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-fork-exec.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-fork-exec.cleanup-before.json", + "bytes": 8373, + "sha256": "3c4d072b5ca961aa9a7b8419a2be25660df96837de6f44f544c7b283961d2a16" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-fork-exec.cleanup.txt", + "bytes": 65, + "sha256": "6b3603ec8aa6b917933e71af4d42d2c2bc6225b14941f70700ee9bad557a32f5" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-fork-exec.inspect.json", + "bytes": 8373, + "sha256": "ab25d2a31c86855cf6627530ff14537eeafd3e2a73edcbacfb35ee87886dcffc" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-fork-exec.json", + "bytes": 4843, + "sha256": "262625f47d404ded4f665d8c801e4e903d2e6978ef37b847087ab2470170e677" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-fork-exec.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-fork-exec.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-fork-exec.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-load.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-load.cleanup-before.json", + "bytes": 8343, + "sha256": "f5c22ad972a794d4ec8571e7b595c1ebfc8aab6a9531646c0a232ef6e3d563ba" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-load.cleanup.txt", + "bytes": 65, + "sha256": "7211eaeafd572b81020fc336c5a3fea8c32272aac898d74a4d063d7c4ad04827" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-load.inspect.json", + "bytes": 8343, + "sha256": "f5c22ad972a794d4ec8571e7b595c1ebfc8aab6a9531646c0a232ef6e3d563ba" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-load.json", + "bytes": 3025, + "sha256": "1873d816a24eb98f1eb52a48fd10c75fb7acbc44f3f77970c571afe21b360c3f" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-load.ready.json", + "bytes": 860, + "sha256": "be13538964f5599bf751f5d90df8f25b5bf951d3b72607e96d86a8ab258a45f4" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-load.release", + "bytes": 31, + "sha256": "b949cb06de5e7d5f4fc97c2867af7958d56dfc81b3e3b966415f0f25309ced11" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-load.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-load.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-load.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-observer.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-observer.cleanup-before.json", + "bytes": 8367, + "sha256": "5f16f17637faa2d4b4bcce1d7a94c133cdef1f617f1754775233087f83ff6cbc" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-observer.cleanup.txt", + "bytes": 65, + "sha256": "da95d6fb4068ac61240887d85527835906bcbfef4eec7629bd964b8efa56f925" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-observer.inspect.json", + "bytes": 8367, + "sha256": "2c90f2d2a2b9cba6b3be0df032502bf9ca10f70bef0b083fbd8194f84f66f425" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-observer.json", + "bytes": 3956, + "sha256": "addbe82a82a9dbb2fc8c4edf02548f1382fc970d0fa2196e6c7714c19fa4e9e8" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-observer.ready.json", + "bytes": 827, + "sha256": "bb0620ab29d9c7eb59c29bca84a7216d4ec887f2560c9fe691abc5925e222d82" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-observer.release", + "bytes": 31, + "sha256": "b949cb06de5e7d5f4fc97c2867af7958d56dfc81b3e3b966415f0f25309ced11" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-observer.sampled.json", + "bytes": 827, + "sha256": "ee8a82fbf25aa75931c62841c5d6bd2433879db3405fa8fc86a4a8cf5ffad31e" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-observer.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-observer.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-observer.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-rss-overlap.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-rss-overlap.cleanup-before.json", + "bytes": 8385, + "sha256": "9f822d51c9fb911c09280bb87b8f299264251b4e4b731eb321781f788f2fc28a" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-rss-overlap.cleanup.txt", + "bytes": 65, + "sha256": "72926007b972f7667879d3178be5762acf56ac994dc87ee5c58138dd79819254" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-rss-overlap.inspect.json", + "bytes": 8385, + "sha256": "835b462cf4a843e7da055d265a0bc8f75b8b387b6d4b98405d1603e10bfecc99" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-rss-overlap.json", + "bytes": 7845, + "sha256": "034f4f4ac967c304ab4b1c1f96467a93d8dde3e83d93eaf90687cc58c080e666" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-rss-overlap.overlap.release", + "bytes": 31, + "sha256": "b949cb06de5e7d5f4fc97c2867af7958d56dfc81b3e3b966415f0f25309ced11" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-rss-overlap.rss-7.ready.json", + "bytes": 844, + "sha256": "02e1caa3afb969af7708a4a739d5ca864c6ff2fbf1b57e995af053bdee4e80f2" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-rss-overlap.rss-8.ready.json", + "bytes": 844, + "sha256": "4d7c44e8630c8ff0ea447ef860ba783f8d98242804d2cda11f07641927a0bcd5" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-rss-overlap.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-rss-overlap.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-rss-overlap.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/optimized-sibling-host.json", + "bytes": 1051, + "sha256": "6e5cebae11f7d657b679e91921596c01a5b8d8e20629efce46b5c50be06e1554" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-detached.child.json", + "bytes": 1034, + "sha256": "0fcf4d90a3c92a21e2d83114baaeff71605d3d0a84139f506cbd477bd1ecc64f" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-detached.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-detached.cleanup-before.json", + "bytes": 8337, + "sha256": "9916dc88f5cb278bd86967479f85e23dbb1a93f02a7931cd0c3666bd80adef87" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-detached.cleanup.txt", + "bytes": 65, + "sha256": "c393849c923056798be974f7ab774ebdd9c8edaf37ca2602d3ffa0ec6ced3220" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-detached.inspect.json", + "bytes": 8337, + "sha256": "9916dc88f5cb278bd86967479f85e23dbb1a93f02a7931cd0c3666bd80adef87" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-detached.json", + "bytes": 4715, + "sha256": "c2d1d0e7fdca2e5d66a74b918fc76d968fc9dbf0d076f24f19d1a3ed09d13c0e" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-detached.release", + "bytes": 31, + "sha256": "b949cb06de5e7d5f4fc97c2867af7958d56dfc81b3e3b966415f0f25309ced11" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-detached.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-detached.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-detached.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-direct.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-direct.cleanup-before.json", + "bytes": 8325, + "sha256": "b42ee66f733aa6742b277986ea076523bd7c8c364b3493961302797d1080f376" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-direct.cleanup.txt", + "bytes": 65, + "sha256": "3a6258c00b17d4b946b0eea78eb43709a5cd12b655ec1ef4630758fbd2126b8e" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-direct.inspect.json", + "bytes": 8325, + "sha256": "1183695ad7b09f5cc7387658de3588be58d0fb8356313e215bf721824790ba93" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-direct.json", + "bytes": 4431, + "sha256": "aa088dac27ee2cd62881a8fe2061d2f94f93eed8bab423a7e6358a207aa3a778" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-direct.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-direct.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-direct.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-fork-exec.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-fork-exec.cleanup-before.json", + "bytes": 8343, + "sha256": "deaff54175b26a4e3fb524880ba93a6921b152d23c430fc39d7ea16acd828fd3" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-fork-exec.cleanup.txt", + "bytes": 65, + "sha256": "d5817a985d639cae0020746a524371471e8992cca6ce210992d871a8bf03db00" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-fork-exec.inspect.json", + "bytes": 8343, + "sha256": "33694cc74d13b9d40935c189fa9332b16e8aa6cfb9b9666fa25be90c08c49aa9" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-fork-exec.json", + "bytes": 4845, + "sha256": "87ceabe2d8555e7893f13a846e3f0695ab7a6f671e5eb2bd1e49dcf07f63252c" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-fork-exec.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-fork-exec.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-fork-exec.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-load.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-load.cleanup-before.json", + "bytes": 8313, + "sha256": "eb32e67df0c456975eb885732fddd0e24d8fcd878751a2a0113da5d578ecc36e" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-load.cleanup.txt", + "bytes": 65, + "sha256": "a61bfa59fdfaa00cdb8b0f8ea3ce6e7f431d1e596303d7af43dcae8bb4731f97" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-load.inspect.json", + "bytes": 8313, + "sha256": "eb32e67df0c456975eb885732fddd0e24d8fcd878751a2a0113da5d578ecc36e" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-load.json", + "bytes": 3026, + "sha256": "bc9ddd7914f4ed4207bc37ea350cf0b43bd84e0ebc426b16d728eef1a802a802" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-load.ready.json", + "bytes": 860, + "sha256": "e646318be3c1905cb97de1d071a827d3cac186fdd84710715d0845c701fb2844" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-load.release", + "bytes": 31, + "sha256": "b949cb06de5e7d5f4fc97c2867af7958d56dfc81b3e3b966415f0f25309ced11" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-load.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-load.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-load.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-observer.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-observer.cleanup-before.json", + "bytes": 8337, + "sha256": "5a18c614efe92e69201ba8722e726ef4fbf8ee16443d4bfa64c8a71ff5dda1dc" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-observer.cleanup.txt", + "bytes": 65, + "sha256": "52857067af723bff91231155a1343e762fb7fa3e7988a564ae4e8189ee4a06c8" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-observer.inspect.json", + "bytes": 8337, + "sha256": "15b93ae5edb3b521d74bc20b90162d99701c28e128910b9d2f88c05930e82574" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-observer.json", + "bytes": 3957, + "sha256": "f78468ba95498345d04bfa99a853a8bc0935da0392d4c53af7715274b8d751bb" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-observer.ready.json", + "bytes": 827, + "sha256": "82afb80241f7d5f347df092f31823da31869048507a4b9803d67f2ffdf3cfa62" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-observer.release", + "bytes": 31, + "sha256": "b949cb06de5e7d5f4fc97c2867af7958d56dfc81b3e3b966415f0f25309ced11" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-observer.sampled.json", + "bytes": 827, + "sha256": "721ae31e4e088d2b954de4f85f13d1cec6e7c54005e940975b0a744795a9ccc9" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-observer.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-observer.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-observer.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-rss-overlap.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-rss-overlap.cleanup-before.json", + "bytes": 8355, + "sha256": "bfb8628d10db03f904efc266ad0f07b152dbc7d0318c23ec3b42048066085f33" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-rss-overlap.cleanup.txt", + "bytes": 65, + "sha256": "d980b9008fe0ac8396618cdcc6e3fb8f2a6c43fb38576d102343ecdc333fc780" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-rss-overlap.inspect.json", + "bytes": 8355, + "sha256": "bfb8628d10db03f904efc266ad0f07b152dbc7d0318c23ec3b42048066085f33" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-rss-overlap.json", + "bytes": 7848, + "sha256": "75483284e3f8ffca5a284aed176a1b69c943a54de3cf631cfb998f44d09a41f0" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-rss-overlap.overlap.release", + "bytes": 31, + "sha256": "b949cb06de5e7d5f4fc97c2867af7958d56dfc81b3e3b966415f0f25309ced11" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-rss-overlap.rss-7.ready.json", + "bytes": 844, + "sha256": "936812762e9dee57d1a0fbc3464930db2aff8242ad6bf39a13e228c2d6c00c22" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-rss-overlap.rss-8.ready.json", + "bytes": 844, + "sha256": "8cb2924341d9902e76a3749a629f9ba8633d3e526787878f8ca19018f9c666e9" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-rss-overlap.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-rss-overlap.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-rss-overlap.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "rss-39449551836-attempt-2/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39449551836-2/ordinary-sibling-host.json", + "bytes": 1051, + "sha256": "e0ce85b9d2a460f94feb2ffa3849ae043dd9050b260e6c3f1d754a572127f13d" + } + ], + "actual_Crystal_compilations": 0, + "actual_Grant_cells": 0, + "rss_protocol_accepted": true, + "rss_scope": "self-and-largest-waited-child-high-water-kib-v1", + "compiler_rss_accepted": false, + "complete_Grant_build_accepted": false, + "installed_SDK_accepted": false, + "clean_device_installation_accepted": false, + "remaining_build_provider_gates": [ + "shared and migrated charge boundaries", + "actual compiler RSS under the qualified protocol", + "complete real build window and behavior" + ] +} diff --git a/tools/whole_build_memory/evidence/linux-rss-39449551836-attempt-2.zip b/tools/whole_build_memory/evidence/linux-rss-39449551836-attempt-2.zip new file mode 100644 index 0000000..7972934 Binary files /dev/null and b/tools/whole_build_memory/evidence/linux-rss-39449551836-attempt-2.zip differ diff --git a/tools/whole_build_memory/evidence/linux-rss-39449551836.github-artifacts.json b/tools/whole_build_memory/evidence/linux-rss-39449551836.github-artifacts.json new file mode 100644 index 0000000..f7a539d --- /dev/null +++ b/tools/whole_build_memory/evidence/linux-rss-39449551836.github-artifacts.json @@ -0,0 +1 @@ +{"total_count":2,"artifacts":[{"id":12277666488,"node_id":"MDg6QXJ0aWZhY3QxMjI3NzY2NjQ4OA==","name":"linux-kernel-budget-39449551836-2","size_in_bytes":169372,"url":"https://api.github.com/repos/amberframework/memory_budget/actions/artifacts/12277666488","archive_download_url":"https://api.github.com/repos/amberframework/memory_budget/actions/artifacts/12277666488/zip","expired":false,"digest":"sha256:4ff7637e68a81fa5ed218733a14238219b9b9908a23cdddc4a836136da7999cf","created_at":"2026-10-20T15:36:51Z","updated_at":"2026-10-20T15:36:51Z","expires_at":"2026-11-03T15:36:50Z","workflow_run":{"id":39449551836,"repository_id":1424629640,"head_repository_id":1424629640,"head_branch":"feature/linux-kernel-budget-controls","head_sha":"3ea3bfcc55e1e520ee25d69000ea5e8d17d4a62a"}},{"id":12276479816,"node_id":"MDg6QXJ0aWZhY3QxMjI3NjQ3OTgxNg==","name":"linux-kernel-budget-39449551836-1","size_in_bytes":49299,"url":"https://api.github.com/repos/amberframework/memory_budget/actions/artifacts/12276479816","archive_download_url":"https://api.github.com/repos/amberframework/memory_budget/actions/artifacts/12276479816/zip","expired":false,"digest":"sha256:e3600ec03e73ffb8eaeec868628fd70b85ec38e610bf9420b36e0fc5b850843f","created_at":"2026-10-20T15:34:05Z","updated_at":"2026-10-20T15:34:05Z","expires_at":"2026-11-03T15:34:04Z","workflow_run":{"id":39449551836,"repository_id":1424629640,"head_repository_id":1424629640,"head_branch":"feature/linux-kernel-budget-controls","head_sha":"3ea3bfcc55e1e520ee25d69000ea5e8d17d4a62a"}}]} \ No newline at end of file diff --git a/tools/whole_build_memory/evidence/linux-rss-controlled-repeat.json b/tools/whole_build_memory/evidence/linux-rss-controlled-repeat.json new file mode 100644 index 0000000..21d9868 --- /dev/null +++ b/tools/whole_build_memory/evidence/linux-rss-controlled-repeat.json @@ -0,0 +1,10 @@ +{ + "run": 39449551836, + "source": "3ea3bfcc55e1e520ee25d69000ea5e8d17d4a62a", + "first_attempt_terminal": true, + "repeat_count": 1, + "same_source_and_oom_predicate": true, + "reason": "Characterize the new missing Docker OOM marker while preserving the failed first attempt and requiring all original gates. A successful repeat earns its own execution scope and preserves the intermittency evidence.", + "first_failed_receipt_sha256": "2875eb4369bc0b0f47bb8cfdf7a037ab76d225d2407881072e47169932ca2ffd", + "actual_Grant_cells": 0 +} diff --git a/tools/whole_build_memory/evidence/linux-shared-39451872353.acceptance.json b/tools/whole_build_memory/evidence/linux-shared-39451872353.acceptance.json new file mode 100644 index 0000000..389526c --- /dev/null +++ b/tools/whole_build_memory/evidence/linux-shared-39451872353.acceptance.json @@ -0,0 +1,1766 @@ +{ + "passed": true, + "observed_at": "2026-10-20T15:51:30.040404+00:00", + "scope": "Linux first-touch shared-file charge, live resident-page contrast, read-only cgroup mutation refusal and inherited process/RSS controls", + "source_commit": "c33b03334b49c46e810f7d196428020b848777bd", + "source_manifest_sha256": "233f9658ccd015e2c9e7c268723963ed3713dbb2fc4a552f65d2b52a13288cfd", + "provider_manifest_sha256": "15e27eea749e5d08f7d41256515b078f256c89fed5c49647c09dc99b99406eae", + "workflow_url": "https://github.com/amberframework/memory_budget/actions/runs/39451872353", + "pull_request": "https://github.com/amberframework/memory_budget/pull/2", + "artifact_id": 12279316928, + "archive_sha256": "19c4b36d2d60f3c988226f58597e7f1aa8f91a4e6cf09807a725051bc9903bdc", + "archive_published_digest": "sha256:19c4b36d2d60f3c988226f58597e7f1aa8f91a4e6cf09807a725051bc9903bdc", + "accepted_probe_cases": 16, + "changed_actual_result_controls": { + "passed": true, + "controls": [ + { + "mode": "ordinary", + "case": "lost_retired_peak", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "The final kernel peak must retain the retired private allocation" + }, + { + "mode": "ordinary", + "case": "changed_exec_birth", + "changed_actual_file": "ordinary-fork-exec.json", + "rejected": true, + "reason": "The same forked process must exec and be reaped by the actual launcher" + }, + { + "mode": "ordinary", + "case": "lost_adoption", + "changed_actual_file": "ordinary-detached.json", + "rejected": true, + "reason": "Detached process/session identity, adoption, mode and normal join required" + }, + { + "mode": "ordinary", + "case": "omitted_live_orphan", + "changed_actual_file": "ordinary-detached.json", + "rejected": true, + "reason": "The detached worker must be observed after its launcher retires" + }, + { + "mode": "ordinary", + "case": "mixed_sibling_charge", + "changed_actual_file": "ordinary-observer.json", + "rejected": true, + "reason": "Sibling private allocation must remain outside the observer budget" + }, + { + "mode": "ordinary", + "case": "same_host_cgroup", + "changed_actual_file": "ordinary-sibling-host.json", + "rejected": true, + "reason": "Actual host sibling hierarchy required" + }, + { + "mode": "ordinary", + "case": "missing_kernel_events", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "Complete typed pressure and OOM event counters are required" + }, + { + "mode": "ordinary", + "case": "changed_command", + "changed_actual_file": "ordinary-direct.inspect.json", + "rejected": true, + "reason": "Exact distinct image, command, mode and environment required" + }, + { + "mode": "ordinary", + "case": "omitted_direct_parent", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "ordinary", + "case": "omitted_fork_parents", + "changed_actual_file": "ordinary-fork-exec.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "ordinary", + "case": "omitted_detached_parents", + "changed_actual_file": "ordinary-detached.json", + "rejected": true, + "reason": "Every live supervisor, launcher and worker must appear inside the measured window" + }, + { + "mode": "ordinary", + "case": "allocation_outside_window", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "ordinary", + "case": "lost_waited_rss_peak", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "The waited-child maximum must retain the real worker RSS high-water mark" + }, + { + "mode": "ordinary", + "case": "boolean_self_rss", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "Typed Linux maximum RSS counters in KiB are required" + }, + { + "mode": "ordinary", + "case": "rss_bytes_used_as_kib", + "changed_actual_file": "ordinary-rss-overlap.json", + "rejected": true, + "reason": "Largest waited-child RSS and simultaneous whole-group charge must remain distinct" + }, + { + "mode": "ordinary", + "case": "summed_rss_used_as_largest", + "changed_actual_file": "ordinary-rss-overlap.json", + "rejected": true, + "reason": "Largest waited-child RSS and simultaneous whole-group charge must remain distinct" + }, + { + "mode": "ordinary", + "case": "overlap_omitted_worker", + "changed_actual_file": "ordinary-rss-overlap.json", + "rejected": true, + "reason": "Both consumed private allocations must be live in the same measured window" + }, + { + "mode": "ordinary", + "case": "changed_shared_inode", + "changed_actual_file": "ordinary-shared-observer.json", + "rejected": true, + "reason": "Independent host and both live consumers must bind the same shared inode and charge window" + }, + { + "mode": "ordinary", + "case": "changed_shared_content", + "changed_actual_file": "ordinary-shared-observer.json", + "rejected": true, + "reason": "The complete shared inode and content signature must match" + }, + { + "mode": "ordinary", + "case": "lost_shared_writer_charge", + "changed_actual_file": "ordinary-shared-load.json", + "rejected": true, + "reason": "The writer must retain the first-touch charge while the shared reader is live" + }, + { + "mode": "ordinary", + "case": "shared_reader_charged_as_private", + "changed_actual_file": "ordinary-shared-observer.json", + "rejected": true, + "reason": "The shared reader RSS must rise while its own cgroup charge remains separate" + }, + { + "mode": "ordinary", + "case": "lost_shared_reader_rss", + "changed_actual_file": "ordinary-shared-observer.json", + "rejected": true, + "reason": "The complete shared-page consumer must preserve its owner, consumption, RSS and window" + }, + { + "mode": "ordinary", + "case": "wrong_shared_page_checksum", + "changed_actual_file": "ordinary-shared-observer.json", + "rejected": true, + "reason": "The complete shared-page consumer must preserve its owner, consumption, RSS and window" + }, + { + "mode": "ordinary", + "case": "lost_retained_shared_charge", + "changed_actual_file": "ordinary-shared-load.json", + "rejected": true, + "reason": "The writer must retain the first-touch charge while the shared reader is live" + }, + { + "mode": "ordinary", + "case": "writable_cgroup_admission", + "changed_actual_file": "ordinary-direct.json", + "rejected": true, + "reason": "Exact source, runtime, case and qualification scope required" + }, + { + "mode": "optimized", + "case": "lost_retired_peak", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "Positive current and peak memory must fit the strict byte budget" + }, + { + "mode": "optimized", + "case": "changed_exec_birth", + "changed_actual_file": "optimized-fork-exec.json", + "rejected": true, + "reason": "The same forked process must exec and be reaped by the actual launcher" + }, + { + "mode": "optimized", + "case": "lost_adoption", + "changed_actual_file": "optimized-detached.json", + "rejected": true, + "reason": "Detached process/session identity, adoption, mode and normal join required" + }, + { + "mode": "optimized", + "case": "omitted_live_orphan", + "changed_actual_file": "optimized-detached.json", + "rejected": true, + "reason": "The detached worker must be observed after its launcher retires" + }, + { + "mode": "optimized", + "case": "mixed_sibling_charge", + "changed_actual_file": "optimized-observer.json", + "rejected": true, + "reason": "Sibling private allocation must remain outside the observer budget" + }, + { + "mode": "optimized", + "case": "same_host_cgroup", + "changed_actual_file": "optimized-sibling-host.json", + "rejected": true, + "reason": "Actual host sibling hierarchy required" + }, + { + "mode": "optimized", + "case": "missing_kernel_events", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "Complete typed pressure and OOM event counters are required" + }, + { + "mode": "optimized", + "case": "changed_command", + "changed_actual_file": "optimized-direct.inspect.json", + "rejected": true, + "reason": "Exact distinct image, command, mode and environment required" + }, + { + "mode": "optimized", + "case": "omitted_direct_parent", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "optimized", + "case": "omitted_fork_parents", + "changed_actual_file": "optimized-fork-exec.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "optimized", + "case": "omitted_detached_parents", + "changed_actual_file": "optimized-detached.json", + "rejected": true, + "reason": "Every live supervisor, launcher and worker must appear inside the measured window" + }, + { + "mode": "optimized", + "case": "allocation_outside_window", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "Worker entry must bind the same live owner, roster and measured window" + }, + { + "mode": "optimized", + "case": "lost_waited_rss_peak", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "The waited-child maximum must retain the real worker RSS high-water mark" + }, + { + "mode": "optimized", + "case": "boolean_self_rss", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "Typed Linux maximum RSS counters in KiB are required" + }, + { + "mode": "optimized", + "case": "rss_bytes_used_as_kib", + "changed_actual_file": "optimized-rss-overlap.json", + "rejected": true, + "reason": "Largest waited-child RSS and simultaneous whole-group charge must remain distinct" + }, + { + "mode": "optimized", + "case": "summed_rss_used_as_largest", + "changed_actual_file": "optimized-rss-overlap.json", + "rejected": true, + "reason": "Largest waited-child RSS and simultaneous whole-group charge must remain distinct" + }, + { + "mode": "optimized", + "case": "overlap_omitted_worker", + "changed_actual_file": "optimized-rss-overlap.json", + "rejected": true, + "reason": "Both consumed private allocations must be live in the same measured window" + }, + { + "mode": "optimized", + "case": "changed_shared_inode", + "changed_actual_file": "optimized-shared-observer.json", + "rejected": true, + "reason": "Independent host and both live consumers must bind the same shared inode and charge window" + }, + { + "mode": "optimized", + "case": "changed_shared_content", + "changed_actual_file": "optimized-shared-observer.json", + "rejected": true, + "reason": "The complete shared inode and content signature must match" + }, + { + "mode": "optimized", + "case": "lost_shared_writer_charge", + "changed_actual_file": "optimized-shared-load.json", + "rejected": true, + "reason": "The writer must retain the first-touch charge while the shared reader is live" + }, + { + "mode": "optimized", + "case": "shared_reader_charged_as_private", + "changed_actual_file": "optimized-shared-observer.json", + "rejected": true, + "reason": "The shared reader RSS must rise while its own cgroup charge remains separate" + }, + { + "mode": "optimized", + "case": "lost_shared_reader_rss", + "changed_actual_file": "optimized-shared-observer.json", + "rejected": true, + "reason": "The complete shared-page consumer must preserve its owner, consumption, RSS and window" + }, + { + "mode": "optimized", + "case": "wrong_shared_page_checksum", + "changed_actual_file": "optimized-shared-observer.json", + "rejected": true, + "reason": "The complete shared-page consumer must preserve its owner, consumption, RSS and window" + }, + { + "mode": "optimized", + "case": "lost_retained_shared_charge", + "changed_actual_file": "optimized-shared-load.json", + "rejected": true, + "reason": "The writer must retain the first-touch charge while the shared reader is live" + }, + { + "mode": "optimized", + "case": "writable_cgroup_admission", + "changed_actual_file": "optimized-direct.json", + "rejected": true, + "reason": "Exact source, runtime, case and qualification scope required" + } + ], + "restored_actual_accepted": true + }, + "preserved_cohorts": [ + { + "mode": "ordinary", + "tests": 58 + }, + { + "mode": "optimized", + "tests": 58 + } + ], + "profile_admission_cases": 9, + "measurements": [ + { + "case": "optimized-detached", + "before_current_bytes": 18300928, + "after_current_bytes": 18087936, + "retained_charged_peak_bytes": 111157248, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 27373568, + "after_largest_waited_child_rss_bytes": 88236032, + "shared_hot_current_bytes": null, + "cgroup_write_refusal_errno": 13 + }, + { + "case": "optimized-direct", + "before_current_bytes": 17813504, + "after_current_bytes": 18235392, + "retained_charged_peak_bytes": 102223872, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 27721728, + "after_largest_waited_child_rss_bytes": 94388224, + "shared_hot_current_bytes": null, + "cgroup_write_refusal_errno": 13 + }, + { + "case": "optimized-fork-exec", + "before_current_bytes": 17760256, + "after_current_bytes": 18247680, + "retained_charged_peak_bytes": 119304192, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 27279360, + "after_largest_waited_child_rss_bytes": 94552064, + "shared_hot_current_bytes": null, + "cgroup_write_refusal_errno": 13 + }, + { + "case": "optimized-load", + "before_current_bytes": 18116608, + "after_current_bytes": 18096128, + "retained_charged_peak_bytes": 219697152, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 228536320, + "after_largest_waited_child_rss_bytes": 0, + "shared_hot_current_bytes": 219697152, + "cgroup_write_refusal_errno": 13 + }, + { + "case": "optimized-observer", + "before_current_bytes": 18210816, + "after_current_bytes": 17784832, + "retained_charged_peak_bytes": 18493440, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 27148288, + "after_largest_waited_child_rss_bytes": 0, + "shared_hot_current_bytes": 17977344, + "cgroup_write_refusal_errno": 13 + }, + { + "case": "optimized-rss-overlap", + "before_current_bytes": 17965056, + "after_current_bytes": 18362368, + "retained_charged_peak_bytes": 186679296, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 27267072, + "after_largest_waited_child_rss_bytes": 94650368, + "shared_hot_current_bytes": 186671104, + "cgroup_write_refusal_errno": 13 + }, + { + "case": "optimized-shared-load", + "before_current_bytes": 17977344, + "after_current_bytes": 121499648, + "retained_charged_peak_bytes": 121778176, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 128008192, + "after_largest_waited_child_rss_bytes": 0, + "shared_hot_current_bytes": 121778176, + "cgroup_write_refusal_errno": 13 + }, + { + "case": "optimized-shared-observer", + "before_current_bytes": 17862656, + "after_current_bytes": 17895424, + "retained_charged_peak_bytes": 18145280, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 128118784, + "after_largest_waited_child_rss_bytes": 0, + "shared_hot_current_bytes": 17903616, + "cgroup_write_refusal_errno": 13 + }, + { + "case": "ordinary-detached", + "before_current_bytes": 17731584, + "after_current_bytes": 17817600, + "retained_charged_peak_bytes": 110874624, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 27439104, + "after_largest_waited_child_rss_bytes": 88354816, + "shared_hot_current_bytes": null, + "cgroup_write_refusal_errno": 13 + }, + { + "case": "ordinary-direct", + "before_current_bytes": 17764352, + "after_current_bytes": 17809408, + "retained_charged_peak_bytes": 101994496, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 27189248, + "after_largest_waited_child_rss_bytes": 94384128, + "shared_hot_current_bytes": null, + "cgroup_write_refusal_errno": 13 + }, + { + "case": "ordinary-fork-exec", + "before_current_bytes": 18006016, + "after_current_bytes": 18358272, + "retained_charged_peak_bytes": 119132160, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 27115520, + "after_largest_waited_child_rss_bytes": 93941760, + "shared_hot_current_bytes": null, + "cgroup_write_refusal_errno": 13 + }, + { + "case": "ordinary-load", + "before_current_bytes": 18001920, + "after_current_bytes": 18137088, + "retained_charged_peak_bytes": 219582464, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 228270080, + "after_largest_waited_child_rss_bytes": 0, + "shared_hot_current_bytes": 219582464, + "cgroup_write_refusal_errno": 13 + }, + { + "case": "ordinary-observer", + "before_current_bytes": 18018304, + "after_current_bytes": 17870848, + "retained_charged_peak_bytes": 18300928, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 27267072, + "after_largest_waited_child_rss_bytes": 0, + "shared_hot_current_bytes": 17829888, + "cgroup_write_refusal_errno": 13 + }, + { + "case": "ordinary-rss-overlap", + "before_current_bytes": 17903616, + "after_current_bytes": 18276352, + "retained_charged_peak_bytes": 185192448, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 27291648, + "after_largest_waited_child_rss_bytes": 93937664, + "shared_hot_current_bytes": 185184256, + "cgroup_write_refusal_errno": 13 + }, + { + "case": "ordinary-shared-load", + "before_current_bytes": 17907712, + "after_current_bytes": 121479168, + "retained_charged_peak_bytes": 121704448, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 128004096, + "after_largest_waited_child_rss_bytes": 0, + "shared_hot_current_bytes": 121704448, + "cgroup_write_refusal_errno": 13 + }, + { + "case": "ordinary-shared-observer", + "before_current_bytes": 17797120, + "after_current_bytes": 17895424, + "retained_charged_peak_bytes": 18079744, + "before_members": [ + 1 + ], + "after_members": [ + 1 + ], + "after_self_peak_rss_bytes": 127991808, + "after_largest_waited_child_rss_bytes": 0, + "shared_hot_current_bytes": 17899520, + "cgroup_write_refusal_errno": 13 + } + ], + "all_owned_containers_removed": [ + "04800520fcf510708e73a24ce220a1ed6fd98bbba227ee04ac0f7b733953a6a5", + "148a6eab43814812f14a2fdf3942dc8dfec1b7a47ffce44a8a523cff858f8098", + "184be73b2ee71690e9a729ff62fea50eac40c298927ec8ee1e849c1685304a74", + "3e748906f50880af239095dc46cb5a34d9560f9178ce04c530de2a3cd0089090", + "3f0381003d90569763c513563ff18bc43cab750420b69e21660d23572f89b3d5", + "3f958801e26175e4b73b1c31a173ff46f2aa95b07f94d73e5dda9f158a47dfcc", + "3fbbcf718a77c114ef18fd1059de6fe685ef1e2a53bb5e53c5355fded19f6c03", + "5574f5bc3c0653ae1f6022a8291d1b7082969f4a1e4580cd08af56b59214e1fb", + "6c000cd329143dffc2a1349cddbd500b3d0996bde1157b4d4b8da1b8dfc7a47b", + "7a4811e60a43d0795d7360495581148bcef92042d8f0bc950159238e4c6ca821", + "82ad06aa423c383b5d8d6ccf3f3414bacfebdf37e44daac1566136b93ac86616", + "84112ae14416c2d580c1dd16bf63bfaa040738380b6c135f2f4ef6a9504a2ab6", + "9013274985b24d01b82ff6660f30b1c964f72c35b03fe7db6d7c12ca42e769d2", + "94fd089072cbb9e3078b95ce21b0a0c5c0ca85f961357e2a3443423a840c57a8", + "96c9e91196b2ea5baea948bdae4f35a163fe2d28d132b7eee4e7002323a61c6f", + "a0328538c39d0609eca63d7a08e8d10dfd827760aa2ddfc3fef197977a16082d", + "b8e8864879cb646aaae664eda0cf5ada968092f4e4f96655742954e0e45285d4", + "ba3965fa1f5ad165852564d3f33bb05dc8a306bc8e4c5da442ccb3ecdb8c0582", + "e3ccaf659e29576065777ca3a05bec50d885ec87e2c6ed8ec9455030fc0ee9f0", + "e8c584bbad14079a6a91a28343255685ff0576663c935c9664d1a92607557c77", + "f25d194071fceeccaab60212b52d3eb5347d4784d0a4ddd875c46bf230e56e8f" + ], + "shared_data_files_returned": [ + { + "path": "ordinary-shared-pages.bin", + "initially_absent": true, + "removed": true, + "identity": { + "device": 2049, + "inode": 4511547, + "bytes": 100663296, + "uid": 501, + "mode": 420, + "sha256": "d92c54f3d4db530e7adf33c09d74feac0520db69b0bba8189b98a4dc3a59438e" + }, + "expected_signature": true + }, + { + "path": "optimized-shared-pages.bin", + "initially_absent": true, + "removed": true, + "identity": { + "device": 2049, + "inode": 4511927, + "bytes": 100663296, + "uid": 501, + "mode": 420, + "sha256": "d92c54f3d4db530e7adf33c09d74feac0520db69b0bba8189b98a4dc3a59438e" + }, + "expected_signature": true + } + ], + "original_reader_gap": { + "path": "DESCENDANT_MEMBERSHIP_SENSITIVITY_AUDIT.json", + "sha256": "2ce22c4bfee61bf30551967e45a74ad168bc7f720591af084d545226031dd611", + "cases": 6 + }, + "raw_files": [ + { + "path": "descendants-39451872353/_temp/atlas-linux-runner.json", + "bytes": 3165, + "sha256": "190b5c03861529ff934ee0a24a67c1d1475db17a1b6042bffbb7c52f11b086a3" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/3e748906f50880af239095dc46cb5a34d9560f9178ce04c530de2a3cd0089090.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/3e748906f50880af239095dc46cb5a34d9560f9178ce04c530de2a3cd0089090.cleanup-before.json", + "bytes": 10031, + "sha256": "a445f41319a7b166db2f547f8a966cc4bc3291c55826d3b69c02ce7620fd1896" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/3e748906f50880af239095dc46cb5a34d9560f9178ce04c530de2a3cd0089090.cleanup.txt", + "bytes": 65, + "sha256": "586463134ad3ed18e5bdb0e9420202eacfb4124e124821db3216d615c4577065" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/5574f5bc3c0653ae1f6022a8291d1b7082969f4a1e4580cd08af56b59214e1fb.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/5574f5bc3c0653ae1f6022a8291d1b7082969f4a1e4580cd08af56b59214e1fb.cleanup-before.json", + "bytes": 10043, + "sha256": "2810a7207b92e8eb600b14c024cbced75155eb78612d98556a1e5cf8ccce6808" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/5574f5bc3c0653ae1f6022a8291d1b7082969f4a1e4580cd08af56b59214e1fb.cleanup.txt", + "bytes": 65, + "sha256": "e6a1c569fda647aa74835bcb3edcafa1d53157be9d9aea5e4534ef645c2da659" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/82ad06aa423c383b5d8d6ccf3f3414bacfebdf37e44daac1566136b93ac86616.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/82ad06aa423c383b5d8d6ccf3f3414bacfebdf37e44daac1566136b93ac86616.cleanup-before.json", + "bytes": 10090, + "sha256": "1cc80f1cb542ede80d6a790974ac4d8eb10241aeeb89caa233a459a6fa5aa461" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/82ad06aa423c383b5d8d6ccf3f3414bacfebdf37e44daac1566136b93ac86616.cleanup.txt", + "bytes": 65, + "sha256": "2d2fe022176af9d277fded0109986ef3bf47e1ab7a6dcdf033b7dc5fee8c918a" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/TERMINAL_ACCEPTANCE.json", + "bytes": 979, + "sha256": "9169d0843950c419da0833286f9640b068a93e52d5735ced7cd03b64cf0933bf" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/ba3965fa1f5ad165852564d3f33bb05dc8a306bc8e4c5da442ccb3ecdb8c0582.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/ba3965fa1f5ad165852564d3f33bb05dc8a306bc8e4c5da442ccb3ecdb8c0582.cleanup-before.json", + "bytes": 10047, + "sha256": "145bd950017d5ae41563f910ce58f9373fc16123e451e1272762f73cc10e77d3" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/ba3965fa1f5ad165852564d3f33bb05dc8a306bc8e4c5da442ccb3ecdb8c0582.cleanup.txt", + "bytes": 65, + "sha256": "cbc2b73f66a7c94046359fe738f3ca64a214ae0bfb578a789e66fa00a7466d56" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/docker-version.txt", + "bytes": 769, + "sha256": "8402d8b7679b4087fa4fb62264e49054f974146c5d134195d8b7a341747ab4ed" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/e3ccaf659e29576065777ca3a05bec50d885ec87e2c6ed8ec9455030fc0ee9f0.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/e3ccaf659e29576065777ca3a05bec50d885ec87e2c6ed8ec9455030fc0ee9f0.cleanup-before.json", + "bytes": 9695, + "sha256": "9c98a8519ebd65e5b2c3cba0ab13ef20c5b3bbdaf9e2d241e9a8e702614afd94" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/e3ccaf659e29576065777ca3a05bec50d885ec87e2c6ed8ec9455030fc0ee9f0.cleanup.txt", + "bytes": 65, + "sha256": "40000dc6d51de60493732a5a25ce0ded047304172dc4b4419df745d392efd6df" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/image-inspect.json", + "bytes": 2761, + "sha256": "6ac97ded3aafd19566a89ede3161ff023064e48897ca9b9b54fcd5c3a3c39d70" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/oom.client-exit.txt", + "bytes": 4, + "sha256": "e3b9c2844b5a5c2677b3a2279db2ec8487491dd9a23d6b22fac153391b3bb63c" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/oom.inspect.json", + "bytes": 10031, + "sha256": "a445f41319a7b166db2f547f8a966cc4bc3291c55826d3b69c02ce7620fd1896" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/oom.json", + "bytes": 1119, + "sha256": "e496035bea59d54d3eac89d90b76bae46959e4bbc8f524551f6297b911d7f6ae" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/oom.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/oom.stdout.txt", + "bytes": 25, + "sha256": "f3543810a54f40b085722baba561f6fc9f617643baeb8def6b5ff20ec3906fbe" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/optimized.client-exit.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/optimized.inspect.json", + "bytes": 10090, + "sha256": "1cc80f1cb542ede80d6a790974ac4d8eb10241aeeb89caa233a459a6fa5aa461" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/optimized.json", + "bytes": 10596, + "sha256": "62bccc79ad24455b06879338c6be2bcb2f2e38a0a32cbfa69ac09d7a4d873e2e" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/optimized.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/optimized.stdout.txt", + "bytes": 120, + "sha256": "48682fb7a0ad60b153234896eecbdac0ab3e4e8d6219fc9b05800530a8cec2df" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/ordinary.client-exit.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/ordinary.inspect.json", + "bytes": 10047, + "sha256": "145bd950017d5ae41563f910ce58f9373fc16123e451e1272762f73cc10e77d3" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/ordinary.json", + "bytes": 10597, + "sha256": "18a5ee39c35e4de757dd6bb9b1a7c74b3dfdfb9ea3be4ac2b746de0e3ee9f14e" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/ordinary.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/ordinary.stdout.txt", + "bytes": 121, + "sha256": "b845d0f25f5cb004e5d049eabbf9d0d8b8bc6601db21cbdd9101007e19b3b19c" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/terminal-reader.inspect.json", + "bytes": 9695, + "sha256": "9c98a8519ebd65e5b2c3cba0ab13ef20c5b3bbdaf9e2d241e9a8e702614afd94" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/terminal-reader.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/terminal-reader.stdout.txt", + "bytes": 821, + "sha256": "c77bdea9262ce19dfb0e83dcbe7c95d886d056a969052d48a56c886205e4f33b" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/uncapped.client-exit.txt", + "bytes": 2, + "sha256": "53c234e5e8472b6ac51c1ae1cab3fe06fad053beb8ebfd8977b010655bfdd3c3" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/uncapped.inspect.json", + "bytes": 10043, + "sha256": "2810a7207b92e8eb600b14c024cbced75155eb78612d98556a1e5cf8ccce6808" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/uncapped.json", + "bytes": 766, + "sha256": "6860affc926118d09c62f89fdb6cd326a520b9f353edb7f4ae5d6184db64e5d2" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/uncapped.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/installation_provenance/ci-evidence-39451872353-1/uncapped.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/HOST_RESULT.json", + "bytes": 20810, + "sha256": "c5fd1b817a7deccf1685b78bc0f7085e76124a7bb0314f8d2817bacd650e5ec4" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/image-inspect.json", + "bytes": 2403, + "sha256": "5002c2551efeb7650fa8fe66fce7acc6b3d9ac5d90b299eea41fff2a8fbac725" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-detached.child.json", + "bytes": 1036, + "sha256": "ae95c2e487e84ee0e0bdb505282b3b3f13f976eafe5b71aeb13b2e107a57fccf" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-detached.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-detached.cleanup-before.json", + "bytes": 8367, + "sha256": "e363794f5fa77bfc2886c849ac060cd6860e7d98398c3c5c6b23be80aeab5c19" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-detached.cleanup.txt", + "bytes": 65, + "sha256": "ea1196e9a4d805b62138c79c4d2f3bd90874d69b11e18865b96de85aa359dcb8" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-detached.inspect.json", + "bytes": 8367, + "sha256": "3522f2866e77b09569c250def41373a70106c73836e7a56c7bec574b2d2f5c50" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-detached.json", + "bytes": 4760, + "sha256": "887dc8c55ddc77bbd90ca2c8040746791b93b3281d500eb62d2ee4182f2b9ece" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-detached.release", + "bytes": 31, + "sha256": "c59e49a4a08fe924cd5ef0fb9e4b1948e3e580ae33aaa5a3e6e43b1ea51c082b" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-detached.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-detached.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-detached.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-direct.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-direct.cleanup-before.json", + "bytes": 8354, + "sha256": "231b056c80440a975aaba937299fe7148aed76cdf67163b162973214b1d79f3e" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-direct.cleanup.txt", + "bytes": 65, + "sha256": "e78c5159d0eb4420fc2a66854be9cffe03dc3ded863ab75aec80e5e422808f33" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-direct.inspect.json", + "bytes": 8354, + "sha256": "231b056c80440a975aaba937299fe7148aed76cdf67163b162973214b1d79f3e" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-direct.json", + "bytes": 4473, + "sha256": "14a7fe7c75ac91c663c366262871e1cda8c49cb0aab3f7d601639dec6043de03" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-direct.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-direct.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-direct.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-fork-exec.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-fork-exec.cleanup-before.json", + "bytes": 8372, + "sha256": "ba46fcd8abe129ffd353129f4c43d30684f23fac5265d1c23ef3c52dbd3f6be1" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-fork-exec.cleanup.txt", + "bytes": 65, + "sha256": "5ac1258d1dcfc41d3ed5af42a5a4c91a1d892d6fb48d1dc03c59d7e078fe632d" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-fork-exec.inspect.json", + "bytes": 8372, + "sha256": "ba46fcd8abe129ffd353129f4c43d30684f23fac5265d1c23ef3c52dbd3f6be1" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-fork-exec.json", + "bytes": 4889, + "sha256": "b15799bca017c99ed7fd7fbbc2e914e5eb8712d3357e80c96b87e484924a79db" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-fork-exec.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-fork-exec.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-fork-exec.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-load.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-load.cleanup-before.json", + "bytes": 8343, + "sha256": "44563a8f32e63a41779d6839f6d01caae65358ce7d3fef62ec38f987d6d4f026" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-load.cleanup.txt", + "bytes": 65, + "sha256": "8d8b6292bd78e66f76fd99cd35b352e01fad9f505f70d03ac95b0f09cad926f5" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-load.inspect.json", + "bytes": 8343, + "sha256": "44563a8f32e63a41779d6839f6d01caae65358ce7d3fef62ec38f987d6d4f026" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-load.json", + "bytes": 3067, + "sha256": "d5c17c94bfa5310acc9cce7e5357aab6f56c211c4e1f6b04be23f3e16918507b" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-load.ready.json", + "bytes": 862, + "sha256": "c8fbb5bbcda37889df96c970491eea3b90afd7ea7380bae136471da442b8e9be" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-load.release", + "bytes": 31, + "sha256": "c59e49a4a08fe924cd5ef0fb9e4b1948e3e580ae33aaa5a3e6e43b1ea51c082b" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-load.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-load.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-load.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-observer.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-observer.cleanup-before.json", + "bytes": 8367, + "sha256": "849c01833b07ece528a8ad510937e03404d4aa3673c610bcc0a668058f8e7cf7" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-observer.cleanup.txt", + "bytes": 65, + "sha256": "0fb8569c7a1865c64f532e681f8c8f890a41d80adb934baa49eaeee49fb87619" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-observer.inspect.json", + "bytes": 8367, + "sha256": "849c01833b07ece528a8ad510937e03404d4aa3673c610bcc0a668058f8e7cf7" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-observer.json", + "bytes": 4000, + "sha256": "ddb7b7051772446bd8c5a1da63ff348b21db054b0c7ef4d2cc0c6b6bd2278fdc" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-observer.ready.json", + "bytes": 829, + "sha256": "f0d25edc882cb6f8984d83bcdc7cce60dc32e4719ead69c41576611f9c73432a" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-observer.release", + "bytes": 31, + "sha256": "c59e49a4a08fe924cd5ef0fb9e4b1948e3e580ae33aaa5a3e6e43b1ea51c082b" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-observer.sampled.json", + "bytes": 829, + "sha256": "b881fb6fe0a45d5204fc3dced8b4e1f23143f0477a4195d53c367b9e31bd1e42" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-observer.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-observer.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-observer.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-rss-overlap.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-rss-overlap.cleanup-before.json", + "bytes": 8385, + "sha256": "709896c824eb07cb3dc4447802532042d27012401ced16efa80975c3d2602c1f" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-rss-overlap.cleanup.txt", + "bytes": 65, + "sha256": "f39259b535255584812f4bbaad4255bd98ca2c2e76029f839831930d5ccc1119" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-rss-overlap.inspect.json", + "bytes": 8385, + "sha256": "709896c824eb07cb3dc4447802532042d27012401ced16efa80975c3d2602c1f" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-rss-overlap.json", + "bytes": 7895, + "sha256": "6085ba22a2f5a121e8c103269497b62c9cc75386967eb9e1d8925bcebdc4ce11" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-rss-overlap.overlap.release", + "bytes": 31, + "sha256": "c59e49a4a08fe924cd5ef0fb9e4b1948e3e580ae33aaa5a3e6e43b1ea51c082b" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-rss-overlap.rss-7.ready.json", + "bytes": 846, + "sha256": "b4a546ac2ecd607f038eb1aa49136d3a3f58074d861d70a5b390eeeea3667c68" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-rss-overlap.rss-8.ready.json", + "bytes": 846, + "sha256": "5e86843bdfc4631e7dd63c90f950d9f0d0b6487da37525e203de317e5722cb92" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-rss-overlap.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-rss-overlap.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-rss-overlap.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-file-host.json", + "bytes": 172, + "sha256": "bb5a2ab05c72ccea3aac6f59a215eed431c04546f7553217d9c419803e9edd45" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-load.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-load.cleanup-before.json", + "bytes": 8384, + "sha256": "81d2a5567ca183d2a38500aae7965f3e02abeb287ef503fe5f98d3114b6d43c1" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-load.cleanup.txt", + "bytes": 65, + "sha256": "53703b6c484b92062fee427d454e055ccd37a26f8fce71d7cb7bf0be22d24c0a" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-load.inspect.json", + "bytes": 8384, + "sha256": "81d2a5567ca183d2a38500aae7965f3e02abeb287ef503fe5f98d3114b6d43c1" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-load.json", + "bytes": 4096, + "sha256": "4f64faf677afb4452f981b974deda2a25f707550380a072586f058cbce55e5ea" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-load.ready.json", + "bytes": 1052, + "sha256": "302d8dd3c67188c83901a8269577a1b14ef72ee76ec3982c5b4fb4006c7c7006" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-load.release", + "bytes": 31, + "sha256": "c59e49a4a08fe924cd5ef0fb9e4b1948e3e580ae33aaa5a3e6e43b1ea51c082b" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-load.retained.json", + "bytes": 1031, + "sha256": "874ebcd98cec533b2b28138627e43d31a099282071a0e25800dd0ae5ef7be1e6" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-load.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-load.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-load.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-observer.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-observer.cleanup-before.json", + "bytes": 8409, + "sha256": "cf98ddd0798d6b2d6fea434f12c3b5a712a0b3054eef36c471a46a0e0f22e8cf" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-observer.cleanup.txt", + "bytes": 65, + "sha256": "b14676d90654abe766ba0632abdc8a92e0399c2f98dd0ab90e05986e0cb13d72" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-observer.inspect.json", + "bytes": 8409, + "sha256": "cf98ddd0798d6b2d6fea434f12c3b5a712a0b3054eef36c471a46a0e0f22e8cf" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-observer.json", + "bytes": 4437, + "sha256": "be67c0bde90df77ed25cb329fb9b1ebb50dfa05ccf36110e19e3df7fdf3348fa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-observer.ready.json", + "bytes": 829, + "sha256": "c02654610d83f97c62a9930eee755f0d0fdeb40101207cfca2ddead0cf5f6c4d" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-observer.release", + "bytes": 31, + "sha256": "c59e49a4a08fe924cd5ef0fb9e4b1948e3e580ae33aaa5a3e6e43b1ea51c082b" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-observer.sampled.json", + "bytes": 1053, + "sha256": "7a59546eeb74c1d376dae4b7aa6c9d6ceb4890d1d2b1c04326e70b18282d6def" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-observer.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-observer.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-observer.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-shared-sibling-host.json", + "bytes": 1053, + "sha256": "cdf7ae6fe3a59462898ba6ad5c53febac23f65d0b77137cccda0b8beb5f19c36" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/optimized-sibling-host.json", + "bytes": 1053, + "sha256": "0f0ec10e87754c4c2466225cd0618c3b1ad465d06f6534563c1608306303bcd2" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-detached.child.json", + "bytes": 1037, + "sha256": "d8fe6f4f8e9bf96efaaee1efa4ecf73c0c06b971e1c1eebc3179b2b4cec98ddd" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-detached.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-detached.cleanup-before.json", + "bytes": 8337, + "sha256": "61fee5b4a9f740dfedb14c40fde5842c69ca54e82b9b647e150362f167ec4a5d" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-detached.cleanup.txt", + "bytes": 65, + "sha256": "500d4a48240e1385e3b1e3574401055a7c3f5410b20c7cf8e8c2cf825c42f403" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-detached.inspect.json", + "bytes": 8337, + "sha256": "61fee5b4a9f740dfedb14c40fde5842c69ca54e82b9b647e150362f167ec4a5d" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-detached.json", + "bytes": 4762, + "sha256": "dea1fa5edd15fcd5c2d5e7e26538b918499fa3b54900d58302b660c42bd6008f" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-detached.release", + "bytes": 31, + "sha256": "c59e49a4a08fe924cd5ef0fb9e4b1948e3e580ae33aaa5a3e6e43b1ea51c082b" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-detached.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-detached.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-detached.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-direct.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-direct.cleanup-before.json", + "bytes": 8325, + "sha256": "dcfe40902a3b9d1cc86fa338bcd01afc8faa90e21d7b9b64e1e9985ebe07c1be" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-direct.cleanup.txt", + "bytes": 65, + "sha256": "f8736dded32a2e316a375489a69ae89726eae8c3948c3fb8ccbf69b8fdf0b746" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-direct.inspect.json", + "bytes": 8325, + "sha256": "dcfe40902a3b9d1cc86fa338bcd01afc8faa90e21d7b9b64e1e9985ebe07c1be" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-direct.json", + "bytes": 4475, + "sha256": "0d69618d946a583469128944bbbbff605ff58ba8e06d55d0d79944dad7acc946" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-direct.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-direct.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-direct.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-fork-exec.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-fork-exec.cleanup-before.json", + "bytes": 8343, + "sha256": "52c628e475c4394a7d6bb7672683a35b3caa1597b0041e78b967d0c2b319c9f4" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-fork-exec.cleanup.txt", + "bytes": 65, + "sha256": "29bf9603d90f6d9082c1f63c9837e812fb7b8479c01fde995e0d057a7b54b4f6" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-fork-exec.inspect.json", + "bytes": 8343, + "sha256": "52c628e475c4394a7d6bb7672683a35b3caa1597b0041e78b967d0c2b319c9f4" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-fork-exec.json", + "bytes": 4891, + "sha256": "bd86f92662ff317dc30ef4bb70b3bb51e90a2913179983f20dd25ded142cff19" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-fork-exec.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-fork-exec.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-fork-exec.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-load.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-load.cleanup-before.json", + "bytes": 8313, + "sha256": "d0bf3ee0b6c797261c1ae980c294927f37e00278c8bbbcb2667af547aa20013b" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-load.cleanup.txt", + "bytes": 65, + "sha256": "9d792d3ee7d74ae5f70721f60000a85614c4439286d28ffc82be05cc005ce54b" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-load.inspect.json", + "bytes": 8313, + "sha256": "f5892d9cce271e78da5ec1ce72910cebd9f945526fbb9030322525b1a3d2cc69" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-load.json", + "bytes": 3068, + "sha256": "c4a55145b95f3920f25875c28da18af32593aa05358ee369d61addc1d4f299d1" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-load.ready.json", + "bytes": 862, + "sha256": "ffaff33f934b8732501fa2855d6c72bebea2df17b6c69e87cdfb297fd4ce4689" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-load.release", + "bytes": 31, + "sha256": "c59e49a4a08fe924cd5ef0fb9e4b1948e3e580ae33aaa5a3e6e43b1ea51c082b" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-load.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-load.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-load.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-observer.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-observer.cleanup-before.json", + "bytes": 8336, + "sha256": "79bde228973815b82113fdd2dab38e3c10fb2ae38ae3123d2945c9865c80d001" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-observer.cleanup.txt", + "bytes": 65, + "sha256": "016e60c0fcadccdc771c8835f3a99aa4c9f6c547c0356de89de8dc4d77d20546" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-observer.inspect.json", + "bytes": 8336, + "sha256": "79bde228973815b82113fdd2dab38e3c10fb2ae38ae3123d2945c9865c80d001" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-observer.json", + "bytes": 4001, + "sha256": "5d02aa53c19274399314a0d7e10d739b1cd306c07587c4104d858c0f1cce5f5d" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-observer.ready.json", + "bytes": 829, + "sha256": "24aa48a6f71f93e7c86606bb4cf7e4db8a4e9974eed9173825e88f06841da257" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-observer.release", + "bytes": 31, + "sha256": "c59e49a4a08fe924cd5ef0fb9e4b1948e3e580ae33aaa5a3e6e43b1ea51c082b" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-observer.sampled.json", + "bytes": 829, + "sha256": "a9106b8c0c959691142e7cbc8355a3abf8bcb4976a11d96930fb1b3e69353f7d" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-observer.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-observer.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-observer.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-rss-overlap.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-rss-overlap.cleanup-before.json", + "bytes": 8355, + "sha256": "14ced004703a76b8bddbc13861ba236d1312655de02e19d6d65e3ee69312bba5" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-rss-overlap.cleanup.txt", + "bytes": 65, + "sha256": "e3d6441057083885dfb79dd40f23d094e67673b273bafab6d392e784d57b3322" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-rss-overlap.inspect.json", + "bytes": 8355, + "sha256": "14ced004703a76b8bddbc13861ba236d1312655de02e19d6d65e3ee69312bba5" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-rss-overlap.json", + "bytes": 7898, + "sha256": "d5d31e061465f1660bc13cc5a6e18994bcfbc1bedeb8f4d6fd67322c01029f09" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-rss-overlap.overlap.release", + "bytes": 31, + "sha256": "c59e49a4a08fe924cd5ef0fb9e4b1948e3e580ae33aaa5a3e6e43b1ea51c082b" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-rss-overlap.rss-7.ready.json", + "bytes": 846, + "sha256": "071afc6de2b280cce1146616eeb65f8ed9870ce97030323ed51a989c42bee33a" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-rss-overlap.rss-8.ready.json", + "bytes": 846, + "sha256": "0b43c5830d806c52393b09b4c9c0250d6baca5516e9f1d8d576d70e952a0a85c" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-rss-overlap.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-rss-overlap.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-rss-overlap.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-file-host.json", + "bytes": 172, + "sha256": "d0c43b95479964322a4e368b265f311acb8a7bf84e935e40ae30655582e4a986" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-load.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-load.cleanup-before.json", + "bytes": 8354, + "sha256": "3f957ff826095540f4c24b364dd03a440281f6b06f63c4008704dda070b6477d" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-load.cleanup.txt", + "bytes": 65, + "sha256": "c4bec9a0f89dc98ca18ca2838990a4c0c84e7ff7c57bd41c9cc5aab869a04f75" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-load.inspect.json", + "bytes": 8354, + "sha256": "3f957ff826095540f4c24b364dd03a440281f6b06f63c4008704dda070b6477d" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-load.json", + "bytes": 4097, + "sha256": "5b9aef2d2a84900121debc3a06602098f4c7f325bf8efd511eed00cd52786f8a" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-load.ready.json", + "bytes": 1052, + "sha256": "9b5c396f4116bbd7d77955bcbfc662a780c34597a0be08a871f2d7011936ff9a" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-load.release", + "bytes": 31, + "sha256": "c59e49a4a08fe924cd5ef0fb9e4b1948e3e580ae33aaa5a3e6e43b1ea51c082b" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-load.retained.json", + "bytes": 1031, + "sha256": "3bc90940691a1d8b3b4dd2f49fd8160d0acb0a5c430eac25d2ebb0b5afc99f5c" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-load.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-load.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-load.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-observer.cleanup-after.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-observer.cleanup-before.json", + "bytes": 8379, + "sha256": "cef838b83726606869f0fb112c29ea5fcc61145713ed27c368841a5eaad26eb9" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-observer.cleanup.txt", + "bytes": 65, + "sha256": "e4fe367361a6e404c40defbc263a6dcd698835361d88e84926b921388cb22800" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-observer.inspect.json", + "bytes": 8379, + "sha256": "cef838b83726606869f0fb112c29ea5fcc61145713ed27c368841a5eaad26eb9" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-observer.json", + "bytes": 4438, + "sha256": "02199edbedb61bc869e2bc6f0a7d4e3a125a740d23a7678a9d6458fd6a71b9cf" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-observer.ready.json", + "bytes": 829, + "sha256": "bdad53d13c9b4bf3855b0de3b83bd43a18f9995dcff4372b9c22f3934f1d1971" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-observer.release", + "bytes": 31, + "sha256": "c59e49a4a08fe924cd5ef0fb9e4b1948e3e580ae33aaa5a3e6e43b1ea51c082b" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-observer.sampled.json", + "bytes": 1053, + "sha256": "fa658b3e2374934aa39fd480b14481aad51fac06fcd0022e24bc44493dcfe93c" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-observer.stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-observer.stdout.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-observer.wait.txt", + "bytes": 2, + "sha256": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-shared-sibling-host.json", + "bytes": 1053, + "sha256": "8625f98590fd5627c034ecfc273f7e48c59e0c7051f0b1e86c065d50b5a2c05e" + }, + { + "path": "descendants-39451872353/memory_budget/memory_budget/tools/whole_build_memory/ci-evidence-39451872353-1/ordinary-sibling-host.json", + "bytes": 1053, + "sha256": "d7b54a00b6335cf0edb4991e6b7ceaef0fce2edc545de78d6f99e2d95eb71689" + } + ], + "actual_Crystal_compilations": 0, + "actual_Grant_cells": 0, + "rss_protocol_accepted": true, + "rss_scope": "self-and-largest-waited-child-high-water-kib-v1", + "shared_charge_protocol_accepted": true, + "cgroup_write_fence_accepted": true, + "actual_process_migration_accepted": false, + "compiler_rss_accepted": false, + "complete_Grant_build_accepted": false, + "installed_SDK_accepted": false, + "clean_device_installation_accepted": false, + "remaining_build_provider_gates": [ + "actual process migration charge behavior", + "actual compiler RSS under the qualified protocol", + "complete real build window and behavior", + "operational Docker OOM marker reliability" + ] +} diff --git a/tools/whole_build_memory/evidence/linux-shared-39451872353.github-artifact.json b/tools/whole_build_memory/evidence/linux-shared-39451872353.github-artifact.json new file mode 100644 index 0000000..19f0177 --- /dev/null +++ b/tools/whole_build_memory/evidence/linux-shared-39451872353.github-artifact.json @@ -0,0 +1 @@ +{"total_count":1,"artifacts":[{"id":12279316928,"node_id":"MDg6QXJ0aWZhY3QxMjI3OTMxNjkyOA==","name":"linux-kernel-budget-39451872353-1","size_in_bytes":214487,"url":"https://api.github.com/repos/amberframework/memory_budget/actions/artifacts/12279316928","archive_download_url":"https://api.github.com/repos/amberframework/memory_budget/actions/artifacts/12279316928/zip","expired":false,"digest":"sha256:19c4b36d2d60f3c988226f58597e7f1aa8f91a4e6cf09807a725051bc9903bdc","created_at":"2026-10-20T15:49:23Z","updated_at":"2026-10-20T15:49:23Z","expires_at":"2026-11-03T15:49:22Z","workflow_run":{"id":39451872353,"repository_id":1424629640,"head_repository_id":1424629640,"head_branch":"feature/linux-kernel-budget-controls","head_sha":"c33b03334b49c46e810f7d196428020b848777bd"}}]} \ No newline at end of file diff --git a/tools/whole_build_memory/evidence/linux-shared-39451872353.zip b/tools/whole_build_memory/evidence/linux-shared-39451872353.zip new file mode 100644 index 0000000..33817b9 Binary files /dev/null and b/tools/whole_build_memory/evidence/linux-shared-39451872353.zip differ diff --git a/tools/whole_build_memory/probe.py b/tools/whole_build_memory/probe.py new file mode 100644 index 0000000..6a93ad4 --- /dev/null +++ b/tools/whole_build_memory/probe.py @@ -0,0 +1,434 @@ +"""Exercise descendant peak retention and separate sibling memory charges.""" +from pathlib import Path +from functools import lru_cache +import argparse +import errno +import hashlib +import json +import mmap +import os +import re +import resource +import signal +import stat +import subprocess +import sys +import time + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +PROVIDER = ROOT / 'tools/installation_provenance' +PROVIDER_PINS = '15e27eea749e5d08f7d41256515b078f256c89fed5c49647c09dc99b99406eae' +STRICT_BYTES = 512 * 2**20 +CHILD_BYTES = 64 * 2**20 +SIBLING_BYTES = 192 * 2**20 +SHARED_BYTES = 96 * 2**20 + + +def need(value, message): + if not value: + raise RuntimeError(message) + + +def digest(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def verify_sources(expected): + manifest = HERE / 'SOURCE_PINS.json' + need(digest(manifest) == expected, 'Exact descendant source manifest required') + value = json.loads(manifest.read_bytes()) + need(value['format'] == 'atlas-whole-build-probe-sources-v1' + and {item['path'] for item in value['files']} == {'probe.py', 'run_host.py', 'verify_results.py'} + and len(value['files']) == 3, 'Complete unique probe source roster required') + for row in value['files']: + path = HERE / row['path'] + need(path.resolve() == path and stat.S_ISREG(path.lstat().st_mode) + and stat.S_IMODE(path.stat().st_mode) == row['mode'] + and path.stat().st_size == row['bytes'] <= 2**20 and digest(path) == row['sha256'], + 'Every reviewed probe source must retain its identity') + need(digest(PROVIDER / 'SOURCE_PINS.json') == PROVIDER_PINS, 'Exact qualified cgroup provider required') + packet = json.loads((PROVIDER / 'SOURCE_PINS.json').read_bytes()) + need(len(packet['files']) == 7, 'Complete provider source roster required') + for row in packet['files']: + path = PROVIDER / row['path'] + need(path.resolve() == path and stat.S_ISREG(path.lstat().st_mode) + and stat.S_IMODE(path.stat().st_mode) == row['mode'] + and path.stat().st_size == row['bytes'] and digest(path) == row['sha256'], + 'Every provider source must retain its reviewed bytes') + sys.path.insert(0, str(PROVIDER)) + import cgroup_budget + return cgroup_budget + + +def save(path, value): + raw = (json.dumps(value, indent=2) + '\n').encode() + need(len(raw) <= 128 * 1024 and path.parent.resolve() == path.parent and not path.exists(), + 'Fresh bounded physical evidence output required') + temporary = path.with_name(path.name + '.tmp-' + str(os.getpid())) + with temporary.open('xb') as stream: + stream.write(raw) + stream.flush() + os.fsync(stream.fileno()) + temporary.replace(path) + + +def marker(output, suffix): + return output.with_name(output.stem + suffix) + + +def wait_file(path, seconds=20): + deadline = time.monotonic() + seconds + while not path.exists(): + need(time.monotonic() < deadline, 'Bounded rendezvous deadline reached: ' + path.name) + time.sleep(.02) + need(path.resolve() == path and stat.S_ISREG(path.lstat().st_mode) + and path.stat().st_size <= 128 * 1024, 'Physical bounded rendezvous file required') + return path + + +def process_identity(budget, pid=None): + pid = os.getpid() if pid is None else pid + need(type(pid) is int and pid > 0, 'Positive process identity required') + raw = budget.read_small(Path('/proc') / str(pid) / 'stat', 16384) + fields = raw.rsplit(')', 1)[1].split() + need(len(fields) >= 20, 'Complete kernel process identity required') + return {'pid': pid, 'ppid': int(fields[1]), 'pgid': int(fields[2]), + 'sid': int(fields[3]), 'start_ticks': int(fields[19])} + + +def context(budget, provider): + identity = process_identity(budget) + group = Path('/sys/fs/cgroup').stat() + membership = budget.read_small(Path('/proc') / str(os.getpid()) / 'cgroup') + members = [int(value) for value in budget.read_small('/sys/fs/cgroup/cgroup.procs', 16384).splitlines()] + need(0 < len(members) <= 64 and len(set(members)) == len(members) + and all(value > 0 for value in members), 'Stable finite live cgroup membership required') + return {'identity': identity, 'cgroup_key': {'device': group.st_dev, 'inode': group.st_ino}, + 'membership': membership, 'members': sorted(members), + 'self_peak_rss_kib': resource.getrusage(resource.RUSAGE_SELF).ru_maxrss, + 'waited_children_peak_rss_kib': resource.getrusage(resource.RUSAGE_CHILDREN).ru_maxrss, + 'snapshot': budget.asdict(provider.snapshot()), 'monotonic_ns': time.monotonic_ns()} + + +def alone(budget, provider): + deadline = time.monotonic() + 3 + while True: + value = context(budget, provider) + if value['members'] == [os.getpid()] and value['snapshot']['pids_current'] == 1: + return value + need(time.monotonic() < deadline, 'Every owned worker must retire before the final window') + time.sleep(.02) + + +def allocation(size, page_size): + value = bytearray(size) + for offset in range(0, size, page_size): + value[offset] = 1 + need(sum(value[offset] for offset in range(0, size, page_size)) == size // page_size, + 'Every declared allocation page must be touched and consumed') + return value + + +def command(args, worker): + flags = ['-I', '-S', '-B'] + (['-O'] if not __debug__ else []) + return [sys.executable] + flags + [str(Path(__file__).resolve()), '--case', args.case, + '--worker', worker, '--output', args.output, '--pins-sha256', args.pins_sha256, + '--token', args.token] + + +def worker(args, budget, provider): + output = Path(args.output) + if args.worker in ('allocate', 'hold'): + before = context(budget, provider) + value = allocation(CHILD_BYTES, provider.limits.page_size) + hot = context(budget, provider) + if args.worker == 'hold': + save(marker(output, '.rss-' + str(os.getpid()) + '.ready.json'), {'hot': hot}) + need(json.loads(wait_file(marker(output, '.overlap.release')).read_bytes()) == {'token': args.token}, + 'Exact overlapping-worker release token required') + print(json.dumps({'stage': 'allocation', 'before': before, 'hot': hot, 'optimized_python': not __debug__, + 'allocation_bytes': len(value), 'touched_pages': len(value) // provider.limits.page_size}), flush=True) + return + if args.worker == 'fork-exec': + identity = process_identity(budget) + child = os.fork() + if child == 0: + print(json.dumps({'stage': 'before-exec', 'identity': process_identity(budget)}), flush=True) + os.execv(sys.executable, command(args, 'allocate')) + waited, status = os.waitpid(child, 0) + need(waited == child and os.waitstatus_to_exitcode(status) == 0, 'The forked/exec worker must complete') + print(json.dumps({'stage': 'joined', 'launcher': identity, 'child_pid': child, 'exit_code': 0}), flush=True) + return + need(args.worker == 'detach', 'A supported worker mode is required') + launcher = process_identity(budget) + child = os.fork() + if child == 0: + os.setsid() + with open('/dev/null', 'wb') as sink: + os.dup2(sink.fileno(), 1) + os.dup2(sink.fileno(), 2) + value = allocation(CHILD_BYTES, provider.limits.page_size) + save(marker(output, '.child.json'), {'launcher': launcher, 'hot': context(budget, provider), 'optimized_python': not __debug__, + 'allocation_bytes': len(value), 'touched_pages': len(value) // provider.limits.page_size}) + release = wait_file(marker(output, '.release')) + need(json.loads(release.read_bytes()) == {'token': args.token}, 'Exact detached-worker release token required') + os._exit(0) + wait_file(marker(output, '.child.json')) + print(json.dumps({'stage': 'detached', 'launcher': launcher, 'child_pid': child}), flush=True) + + +def run_child(args, budget, provider): + before = alone(budget, provider) + selected = 'allocate' if args.case == 'direct' else 'fork-exec' if args.case == 'fork-exec' else 'detach' + child = subprocess.Popen(command(args, selected), stdin=subprocess.DEVNULL, + stdout=subprocess.PIPE, stderr=subprocess.PIPE) + try: + stdout, stderr = child.communicate(timeout=20) + except BaseException: + child.kill() + child.wait(timeout=3) + raise + need(child.returncode == 0 and not stderr and len(stdout) <= 128 * 1024, 'The exact worker must finish normally') + rows = [json.loads(line) for line in stdout.splitlines()] + detached = None + if args.case == 'detached': + need(len(rows) == 1 and rows[0]['stage'] == 'detached', 'One exact detached launcher result required') + pid = rows[0]['child_pid'] + detached = json.loads(wait_file(marker(Path(args.output), '.child.json')).read_bytes()) + observed = context(budget, provider) + identity = process_identity(budget, pid) + need(pid in observed['members'] and identity['ppid'] == os.getpid() + and identity['pgid'] == identity['sid'] == pid + and identity['start_ticks'] == detached['hot']['identity']['start_ticks'], + 'The adopted detached worker must remain in the complete cgroup window') + save(marker(Path(args.output), '.release'), {'token': args.token}) + deadline = time.monotonic() + 3 + while True: + waited, status = os.waitpid(pid, os.WNOHANG) + if waited: + need(waited == pid and os.waitstatus_to_exitcode(status) == 0, 'The adopted worker must be reaped normally') + break + need(time.monotonic() < deadline, 'Bounded adopted-worker join required') + time.sleep(.02) + detached['observed_after_launcher_exit'] = observed + detached['adopted_identity'] = identity + detached['exit_code'] = 0 + after = alone(budget, provider) + budget.compare_snapshots(budget.Snapshot(**before['snapshot']), budget.Snapshot(**after['snapshot']), provider.limits) + need(after['snapshot']['memory_peak'] >= before['snapshot']['memory_peak'] + CHILD_BYTES // 2 + and after['snapshot']['memory_peak'] - after['snapshot']['memory_current'] >= CHILD_BYTES // 2, + 'The kernel must retain the retired private allocation peak') + return {'before': before, 'after': after, 'launcher_pid': child.pid, 'worker_exit_code': child.returncode, + 'worker_records': rows, 'detached': detached, 'parent_live_child_polls': 0 if args.case != 'detached' else 1} + + +def overlapping_rss(args, budget, provider): + before = alone(budget, provider) + children = [] + try: + for unused in range(2): + children.append(subprocess.Popen(command(args, 'hold'), stdin=subprocess.DEVNULL, + stdout=subprocess.PIPE, stderr=subprocess.PIPE)) + ready = [] + for child in children: + path = marker(Path(args.output), '.rss-' + str(child.pid) + '.ready.json') + ready.append(json.loads(wait_file(path).read_bytes())) + during = context(budget, provider) + need(during['members'] == sorted([os.getpid()] + [child.pid for child in children]) + and during['snapshot']['memory_current'] >= 2 * CHILD_BYTES, + 'Both private workers must overlap in the same complete charged window') + save(marker(Path(args.output), '.overlap.release'), {'token': args.token}) + rows = [] + for child in children: + stdout, stderr = child.communicate(timeout=10) + need(child.returncode == 0 and not stderr and len(stdout) <= 128 * 1024, + 'Both overlapping workers must complete normally') + records = [json.loads(line) for line in stdout.splitlines()] + need(len(records) == 1 and records[0]['hot'] == ready[len(rows)]['hot'], + 'The overlapping output must bind the held live observation') + rows.append({'pid': child.pid, 'exit_code': child.returncode, 'allocation': records[0]}) + return {'before': before, 'during': during, 'after': alone(budget, provider), 'workers': rows} + finally: + for child in children: + if child.poll() is None: + child.kill() + child.wait(timeout=3) + + +def sibling(args, budget, provider): + output = Path(args.output) + prefix = output.stem.rsplit('-', 1)[0] + before = alone(budget, provider) + if args.case == 'load': + value = allocation(SIBLING_BYTES, provider.limits.page_size) + hot = context(budget, provider) + save(marker(output, '.ready.json'), {'hot': hot, 'allocation_bytes': len(value)}) + need(json.loads(wait_file(marker(output, '.release')).read_bytes()) == {'token': args.token}, 'Exact sibling-load release token required') + size = len(value) + del value + after = alone(budget, provider) + return {'before': before, 'hot': hot, 'after': after, 'allocation_bytes': size} + need(args.case == 'observer', 'A supported sibling case is required') + save(marker(output, '.ready.json'), {'before': before}) + load = json.loads(wait_file(output.with_name(prefix + '-load.ready.json')).read_bytes()) + during = context(budget, provider) + need(during['cgroup_key'] != load['hot']['cgroup_key'], 'Separate sibling cgroup identities required') + need(during['snapshot']['memory_peak'] < SIBLING_BYTES // 2 + and load['hot']['snapshot']['memory_current'] >= SIBLING_BYTES, + 'The unrelated private load must remain outside the observer budget') + save(marker(output, '.sampled.json'), {'during': during}) + need(json.loads(wait_file(marker(output, '.release')).read_bytes()) == {'token': args.token}, 'Exact observer release token required') + return {'before': before, 'during': during, 'after': alone(budget, provider), 'sibling_hot': load} + + +@lru_cache(maxsize=1) +def shared_signature(): + value = hashlib.sha256() + page = b'\x01' + b'\x00' * 4095 + for unused in range(SHARED_BYTES // 4096): + value.update(page) + return value.hexdigest() + + +def shared_file_identity(path): + before = path.lstat() + need(path.resolve() == path and stat.S_ISREG(before.st_mode) and before.st_size == SHARED_BYTES + and before.st_uid == 501 and stat.S_IMODE(before.st_mode) == 0o644 and before.st_nlink == 1, + 'One exact physical shared file with its expected owner, size and mode is required') + signature = hashlib.sha256() + descriptor = os.open(str(path), os.O_RDONLY | os.O_NOFOLLOW) + with os.fdopen(descriptor, 'rb') as stream: + opened = os.fstat(stream.fileno()) + need((opened.st_dev, opened.st_ino) == (before.st_dev, before.st_ino), 'The opened shared inode must remain exact') + while True: + block = stream.read(65536) + if not block: + break + signature.update(block) + after = path.lstat() + need((after.st_dev, after.st_ino, after.st_size, after.st_mtime_ns) == + (before.st_dev, before.st_ino, before.st_size, before.st_mtime_ns), 'The complete shared file must remain stable') + return {'device': before.st_dev, 'inode': before.st_ino, 'bytes': before.st_size, + 'uid': before.st_uid, 'mode': stat.S_IMODE(before.st_mode), 'sha256': signature.hexdigest()} + + +def shared_pages(args, budget, provider): + output = Path(args.output) + prefix = output.stem.rsplit('-shared-', 1)[0] + path = output.with_name(prefix + '-shared-pages.bin') + before = alone(budget, provider) + if args.case == 'shared-load': + descriptor = os.open(str(path), os.O_CREAT | os.O_EXCL | os.O_RDWR | os.O_NOFOLLOW, 0o644) + with os.fdopen(descriptor, 'r+b') as stream: + stream.truncate(SHARED_BYTES) + with mmap.mmap(stream.fileno(), SHARED_BYTES, access=mmap.ACCESS_WRITE) as pages: + for offset in range(0, SHARED_BYTES, 4096): + pages[offset] = 1 + pages.flush() + checksum = sum(pages[offset] for offset in range(0, SHARED_BYTES, 4096)) + need(checksum == SHARED_BYTES // 4096, 'Every shared writer page must be consumed') + file = shared_file_identity(path) + need(file['sha256'] == shared_signature(), 'The complete writer content signature must match') + hot = context(budget, provider) + save(marker(output, '.ready.json'), {'hot': hot, 'file': file, 'page_checksum': checksum}) + wait_file(output.with_name(prefix + '-shared-observer.sampled.json')) + retained = context(budget, provider) + save(marker(output, '.retained.json'), {'retained': retained, 'file': shared_file_identity(path)}) + need(json.loads(wait_file(marker(output, '.release')).read_bytes()) == {'token': args.token}, + 'Exact shared writer release token required') + return {'before': before, 'hot': hot, 'retained': retained, 'after': alone(budget, provider), + 'file': file, 'page_checksum': checksum} + need(args.case == 'shared-observer', 'A supported shared-page role is required') + save(marker(output, '.ready.json'), {'before': before}) + writer = json.loads(wait_file(output.with_name(prefix + '-shared-load.ready.json')).read_bytes()) + file = shared_file_identity(path) + need(file == writer['file'] and file['sha256'] == shared_signature(), 'Both processes must open the same complete shared file') + with path.open('rb') as stream: + with mmap.mmap(stream.fileno(), SHARED_BYTES, access=mmap.ACCESS_READ) as pages: + checksum = sum(pages[offset] for offset in range(0, SHARED_BYTES, 4096)) + need(checksum == SHARED_BYTES // 4096, 'Every shared reader page must be consumed') + during = context(budget, provider) + save(marker(output, '.sampled.json'), {'during': during, 'file': file, 'page_checksum': checksum}) + need(json.loads(wait_file(marker(output, '.release')).read_bytes()) == {'token': args.token}, + 'Exact shared reader release token required') + return {'before': before, 'during': during, 'after': alone(budget, provider), + 'file': file, 'page_checksum': checksum, 'writer_hot': writer} + + +def cgroup_write_refusal(): + try: + descriptor = os.open('/sys/fs/cgroup/cgroup.procs', os.O_WRONLY | os.O_NOFOLLOW) + except OSError as error: + need(error.errno in (errno.EROFS, errno.EACCES, errno.EPERM), 'The cgroup write must refuse at its permission boundary') + return error.errno + os.close(descriptor) + raise RuntimeError('The read-only cgroup must refuse a mutation handle') + + +def host_identity(args, budget): + pid = args.host_pid + identity = process_identity(budget, pid) + membership = budget.read_small(Path('/proc') / str(pid) / 'cgroup') + need(membership.startswith('0::/') and membership.endswith('\n') and membership.count('\n') == 1, + 'One complete host cgroup membership required') + path = Path(membership[3:].strip()) + need(path.name == 'docker-' + args.container_id + '.scope', 'The host path must bind the exact Docker identity') + key = (Path('/sys/fs/cgroup') / str(path).lstrip('/')).stat() + need(process_identity(budget, pid) == identity, 'The live host process identity must remain stable') + print(json.dumps({'container_id': args.container_id, 'identity': identity, 'membership': membership, + 'cgroup_path': str(path), 'cgroup_key': {'device': key.st_dev, 'inode': key.st_ino}})) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--case', choices=('direct', 'fork-exec', 'detached', 'rss-overlap', 'observer', 'load', + 'shared-observer', 'shared-load')) + parser.add_argument('--worker', choices=('allocate', 'hold', 'fork-exec', 'detach')) + parser.add_argument('--output') + parser.add_argument('--token') + parser.add_argument('--pins-sha256', required=True) + parser.add_argument('--host-pid', type=int) + parser.add_argument('--container-id') + args = parser.parse_args() + budget = verify_sources(args.pins_sha256) + if args.host_pid: + need(os.geteuid() == 0 and re.fullmatch('[0-9a-f]{64}', args.container_id or '') is not None, + 'Read-only host identity needs its exact owned container and metadata access') + host_identity(args, budget) + return + need(args.case and args.output and re.fullmatch('[0-9]+-[0-9]+', args.token or '') is not None, + 'A complete source-bound probe identity is required') + need(Path(args.output).parent == Path('/evidence') and os.getuid() == 501, + 'The fixed non-root owned evidence perimeter is required') + provider = budget.CurrentCgroup(budget.Limits(STRICT_BYTES, os.sysconf('SC_PAGE_SIZE'))) + if args.worker: + worker(args, budget, provider) + return + need(os.getpid() == 1, 'The dedicated supervisor must own its PID namespace') + report = {'format': 'atlas-build-descendant-probe-v1', 'case': args.case, 'passed': False, + 'token': args.token, 'optimized_python': not __debug__, 'source_pins_sha256': args.pins_sha256, + 'provider_pins_sha256': PROVIDER_PINS, 'runtime_sha256': digest(Path(sys.executable).resolve()), + 'cgroup_write_refusal_errno': cgroup_write_refusal(), + 'compiler_rss_accepted': False, 'complete_Grant_build_accepted': False, 'actual_Grant_cells': 0} + try: + if args.case == 'rss-overlap': + result = overlapping_rss(args, budget, provider) + elif args.case in ('shared-observer', 'shared-load'): + result = shared_pages(args, budget, provider) + elif args.case in ('direct', 'fork-exec', 'detached'): + result = run_child(args, budget, provider) + else: + result = sibling(args, budget, provider) + report.update(result) + verify_sources(args.pins_sha256) + report['passed'] = True + except BaseException as error: + report['error'] = {'type': type(error).__name__, 'message': str(error)} + raise + finally: + save(Path(args.output), report) + + +if __name__ == '__main__': + main() diff --git a/tools/whole_build_memory/run_host.py b/tools/whole_build_memory/run_host.py new file mode 100644 index 0000000..b600cac --- /dev/null +++ b/tools/whole_build_memory/run_host.py @@ -0,0 +1,211 @@ +"""Run fresh source-bound descendant/sibling containers and return every owner.""" +from pathlib import Path +import argparse +import hashlib +import json +import os +import re +import subprocess +import sys +import time + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +IMAGE = 'python:3.12.10-slim@sha256:fd95fa221297a88e1cf49c55ec1828edd7c5a428187e67b5d1805692d11588db' + + +def need(value, message): + if not value: + raise RuntimeError(message) + + +def digest(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--pins-sha256', required=True) + parser.add_argument('--runner-metadata', required=True) + args = parser.parse_args() + manifest = HERE / 'SOURCE_PINS.json' + need(digest(manifest) == args.pins_sha256, 'Exact reviewed whole-build probe sources required') + rows = json.loads(manifest.read_bytes())['files'] + row = next(item for item in rows if item['path'] == 'probe.py') + need(digest(HERE / 'probe.py') == row['sha256'], 'Exact source admission helper required') + sys.path.insert(0, str(HERE)) + import probe + budget = probe.verify_sources(args.pins_sha256) + metadata = json.loads(Path(args.runner_metadata).read_bytes()) + need(metadata['admitted'] is True, 'The actual hosted runner must already be admitted') + profile = metadata['profile'] + need(digest(Path(sys.executable).resolve()) == profile['python_sha256'] + and digest(Path('/usr/bin/docker')) == profile['docker_cli_sha256'] + and digest(Path('/usr/bin/sudo')) == profile['sudo_sha256'], 'Actual host tools must retain reviewed identities') + runner_source = ROOT / 'tools/installation_provenance/record_linux_runner.py' + need(digest(runner_source) == metadata['collector']['sha256'], 'Exact actual profile matcher required') + sys.path.insert(0, str(runner_source.parent)) + import record_linux_runner + record_linux_runner.reviewed_profile(json.loads((runner_source.parent / 'runner_profile.json').read_bytes()), profile) + token = os.environ['GITHUB_RUN_ID'] + '-' + os.environ['GITHUB_RUN_ATTEMPT'] + need(re.fullmatch('[0-9]+-[0-9]+', token) is not None, 'Exact hosted run/attempt identity required') + evidence = HERE / ('ci-evidence-' + token) + evidence.mkdir(mode=0o777) + evidence.chmod(0o777) + config = evidence / 'docker-config' + config.mkdir(mode=0o700) + docker = ['/usr/bin/docker', '--host', 'unix:///var/run/docker.sock', '--config', str(config)] + environment = {'PATH': '/usr/bin:/bin', 'LC_ALL': 'C'} + owners = [] + data_files = [] + report = {'format': 'atlas-build-descendant-host-result-v1', 'passed': False, + 'source_pins_sha256': args.pins_sha256, 'token': token, 'owners': owners, + 'data_files': data_files, + 'actual_Grant_cells': 0} + + def call(command, seconds=30, check=True): + result = subprocess.run(command, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, + stderr=subprocess.PIPE, timeout=seconds, env=environment) + need(len(result.stdout) <= 2**20 and len(result.stderr) <= 2**20, 'Bounded complete tool output required') + if check: + need(result.returncode == 0, 'Tool failed: ' + ' '.join(command[:4]) + ': ' + result.stderr.decode(errors='replace')) + return result + + def inspect(owner): + value = json.loads(call(docker + ['inspect', owner['name']]).stdout) + need(len(value) == 1 and value[0]['Config']['Labels'].get('org.amberframework.atlas.run') == token, + 'Every mutation must bind the exact owned run label') + if owner.get('id'): + need(value[0]['Id'] == owner['id'], 'Actual container identity must remain stable') + else: + owner['id'] = value[0]['Id'] + return value + + def create(mode, case): + selected = mode + '-' + case + name = 'atlas-build-' + token + '-' + selected + need(call(docker + ['ps', '--all', '--quiet', '--no-trunc', '--filter', 'name=^/' + name + '$']).stdout == b'', + 'A fresh exact owned container name is required') + owner = {'name': name, 'case': case, 'mode': mode, 'selected': selected, 'id': None, 'removed': False} + owners.append(owner) + flags = ['python3', '-I', '-S', '-B'] + (['-O'] if mode == 'optimized' else []) + command = docker + ['create', '--name', name, '--label', 'org.amberframework.atlas.run=' + token, + '--label', 'org.amberframework.atlas.probe=' + selected, '--network', 'none', '--cpus', '1', + '--memory', '536866816', '--memory-swap', '536866816', '--pids-limit', '64', + '--cgroupns', 'private', '--read-only', '--cap-drop', 'ALL', '--security-opt', 'no-new-privileges', + '--user', '501:501', '--mount', 'type=bind,src=' + str(ROOT) + ',dst=/workspace,readonly', + '--mount', 'type=bind,src=' + str(evidence) + ',dst=/evidence', IMAGE] + flags + [ + '/workspace/tools/whole_build_memory/probe.py', '--case', case, + '--output', '/evidence/' + selected + '.json', '--token', token, '--pins-sha256', args.pins_sha256] + result = call(command) + identity = result.stdout.decode().strip() + need(re.fullmatch('[0-9a-f]{64}', identity) is not None, 'Complete actual Docker identity required') + owner['id'] = identity + return owner + + def finish(owner): + result = call(docker + ['wait', owner['id']], seconds=35) + (evidence / (owner['selected'] + '.wait.txt')).write_bytes(result.stdout) + value = inspect(owner) + (evidence / (owner['selected'] + '.inspect.json')).write_text(json.dumps(value, indent=2) + '\n') + logs = call(docker + ['logs', owner['id']], check=False) + (evidence / (owner['selected'] + '.stdout.txt')).write_bytes(logs.stdout) + (evidence / (owner['selected'] + '.stderr.txt')).write_bytes(logs.stderr) + need(result.stdout == b'0\n', 'Every normal probe must complete with its actual zero exit') + + def ready(path): + deadline = time.monotonic() + 25 + while not path.is_file(): + need(time.monotonic() < deadline, 'Bounded source-owned rendezvous required: ' + path.name) + time.sleep(.02) + + def run_pair(mode, shared=False): + prefix = 'shared-' if shared else '' + if shared: + path = evidence / (mode + '-shared-pages.bin') + need(not path.exists() and not path.is_symlink(), 'A fresh shared-page inode path is required') + data_files.append({'path': path.name, 'initially_absent': True, 'removed': False}) + observer, load = create(mode, prefix + 'observer'), create(mode, prefix + 'load') + call(docker + ['start', observer['id']]) + ready(evidence / (observer['selected'] + '.ready.json')) + call(docker + ['start', load['id']]) + ready(evidence / (observer['selected'] + '.sampled.json')) + if shared: + ready(evidence / (load['selected'] + '.retained.json')) + info = probe.shared_file_identity(path) + need(info['sha256'] == probe.shared_signature(), 'The complete live shared file must retain its expected signature') + probe.save(evidence / (mode + '-shared-file-host.json'), info) + host_rows = [] + for owner in (observer, load): + current = inspect(owner)[0] + need(current['State']['Running'] is True and current['State']['Pid'] > 0, + 'Both sibling probes must be alive at the host identity checkpoint') + command = ['/usr/bin/sudo', '--non-interactive', '/usr/bin/python3', '-I', '-S', '-B', + str(HERE / 'probe.py'), '--pins-sha256', args.pins_sha256, '--host-pid', + str(current['State']['Pid']), '--container-id', owner['id']] + host_rows.append(json.loads(call(command).stdout)) + probe.save(evidence / (mode + '-' + prefix + 'sibling-host.json'), host_rows) + for owner in (observer, load): + probe.save(evidence / (owner['selected'] + '.release'), {'token': token}) + finish(observer) + finish(load) + + try: + need(call(docker + ['version', '--format', '{{.Server.Version}}']).stdout.decode().strip() + == profile['docker_server_version'], 'Actual Docker daemon version must retain its identity') + image = json.loads(call(docker + ['image', 'inspect', IMAGE]).stdout) + (evidence / 'image-inspect.json').write_text(json.dumps(image, indent=2) + '\n') + for mode in ('ordinary', 'optimized'): + for case in ('direct', 'fork-exec', 'detached', 'rss-overlap'): + owner = create(mode, case) + call(docker + ['start', owner['id']]) + finish(owner) + run_pair(mode) + run_pair(mode, shared=True) + probe.verify_sources(args.pins_sha256) + import verify_results + report['verification'] = verify_results.validate(evidence, args.pins_sha256, token) + report['sensitivity_controls'] = verify_results.sensitivity_controls(evidence, args.pins_sha256, token) + report['passed'] = True + except BaseException as error: + report['error'] = {'type': type(error).__name__, 'message': str(error)} + raise + finally: + errors = [] + for owner in owners: + try: + value = inspect(owner) + (evidence / (owner['selected'] + '.cleanup-before.json')).write_text(json.dumps(value, indent=2) + '\n') + result = call(docker + ['rm', '--force', owner['id']]) + need(result.stdout.decode().strip() == owner['id'], 'Exact owned removal identity required') + (evidence / (owner['selected'] + '.cleanup.txt')).write_bytes(result.stdout) + absent = call(docker + ['ps', '--all', '--no-trunc', '--filter', 'id=' + owner['id'], '--format', '{{.ID}}']).stdout + (evidence / (owner['selected'] + '.cleanup-after.txt')).write_bytes(absent) + need(absent == b'', 'Every owned container must read back absent') + owner['removed'] = True + except BaseException as error: + errors.append({'name': owner['name'], 'message': str(error)}) + for entry in data_files: + try: + path = evidence / entry['path'] + if path.exists(): + entry['identity'] = probe.shared_file_identity(path) + entry['expected_signature'] = entry['identity']['sha256'] == probe.shared_signature() + path.unlink() + entry['removed'] = not path.exists() and not path.is_symlink() + need(entry['removed'] and entry['expected_signature'], 'The exact shared-page file must verify and return absent') + else: + need(report['passed'] is False, 'A successful shared probe must preserve its complete file until cleanup') + entry['removed'] = not path.is_symlink() + except BaseException as error: + errors.append({'name': entry['path'], 'message': str(error)}) + report['cleanup_errors'] = errors + report['passed'] = report['passed'] and not errors and len(owners) == 16 and all(item['removed'] for item in owners) + report['passed'] = report['passed'] and len(data_files) == 2 and all(item['removed'] for item in data_files) + (evidence / 'HOST_RESULT.json').write_text(json.dumps(report, indent=2) + '\n') + need(report['passed'], 'Complete probe verification and exact container return required') + print(json.dumps({'passed': True, 'owned_containers_removed': len(owners), 'actual_Grant_cells': 0})) + + +if __name__ == '__main__': + main() diff --git a/tools/whole_build_memory/verify_results.py b/tools/whole_build_memory/verify_results.py new file mode 100644 index 0000000..002bcf0 --- /dev/null +++ b/tools/whole_build_memory/verify_results.py @@ -0,0 +1,375 @@ +"""Independently verify actual descendant, sibling, command and terminal evidence.""" +from pathlib import Path +import copy +import errno +import json +import re + +import probe + +CASES = ('direct', 'fork-exec', 'detached', 'rss-overlap', 'observer', 'load', 'shared-observer', 'shared-load') +IMAGE = 'python:3.12.10-slim@sha256:fd95fa221297a88e1cf49c55ec1828edd7c5a428187e67b5d1805692d11588db' +RUNTIME = '4dbf3143240288fb2170257ffaa7bd030cdda5d2703d1f5f30b627042267e2e3' + + +def need(value, message): + if not value: + raise RuntimeError(message) + + +def read(path): + need(path.is_file() and not path.is_symlink() and path.stat().st_size <= 2**20, + 'A bounded physical actual result is required') + return json.loads(path.read_bytes()) + + +def identity(value): + need(isinstance(value, dict) and set(value) == {'pid', 'ppid', 'pgid', 'sid', 'start_ticks'} + and all(type(item) is int and item >= 0 for item in value.values()) + and value['pid'] > 0 and value['start_ticks'] > 0, 'Complete typed kernel process identity required') + return value + + +def context(value, budget): + identity(value['identity']) + key = value['cgroup_key'] + need(set(key) == {'device', 'inode'} and all(type(item) is int and item > 0 for item in key.values()), + 'Complete typed physical cgroup identity required') + members = value['members'] + need(type(members) is list and 0 < len(members) <= 64 + and all(type(item) is int and item > 0 for item in members) + and sorted(set(members)) == members and value['identity']['pid'] in members, + 'A complete unique live process roster is required') + need(value['membership'] == '0::/\n' and type(value['monotonic_ns']) is int and value['monotonic_ns'] > 0, + 'The private cgroup membership and monotonic observation are required') + snapshot = budget.Snapshot(**value['snapshot']) + budget.verify_snapshot(snapshot, budget.Limits(probe.STRICT_BYTES, 4096)) + need(snapshot.pids_current >= len(members), 'Process slots must cover the live member roster') + need(type(value['self_peak_rss_kib']) is int and value['self_peak_rss_kib'] > 0 + and type(value['waited_children_peak_rss_kib']) is int and value['waited_children_peak_rss_kib'] >= 0, + 'Typed Linux maximum RSS counters in KiB are required') + return value + + +def validate_single(value, case, mode, pins, token, budget): + need(value['format'] == 'atlas-build-descendant-probe-v1' and value['case'] == case + and value['passed'] is True and value['token'] == token + and value['optimized_python'] is (mode == 'optimized') + and value['source_pins_sha256'] == pins and value['provider_pins_sha256'] == probe.PROVIDER_PINS + and value['runtime_sha256'] == RUNTIME and value['actual_Grant_cells'] == 0 + and type(value['cgroup_write_refusal_errno']) is int + and value['cgroup_write_refusal_errno'] in (errno.EROFS, errno.EACCES, errno.EPERM) + and value['compiler_rss_accepted'] is False and value['complete_Grant_build_accepted'] is False, + 'Exact source, runtime, case and qualification scope required') + before, after = context(value['before'], budget), context(value['after'], budget) + need(before['identity'] == after['identity'] and before['identity']['pid'] == 1 + and before['members'] == after['members'] == [1] + and before['snapshot']['pids_current'] == after['snapshot']['pids_current'] == 1 + and before['cgroup_key'] == after['cgroup_key'], 'One stable supervisor and complete worker retirement required') + budget.compare_snapshots(budget.Snapshot(**before['snapshot']), budget.Snapshot(**after['snapshot']), + budget.Limits(probe.STRICT_BYTES, 4096)) + need(after['monotonic_ns'] > before['monotonic_ns'], 'The final window must follow workload entry') + need(after['self_peak_rss_kib'] >= before['self_peak_rss_kib'] + and after['waited_children_peak_rss_kib'] >= before['waited_children_peak_rss_kib'], + 'Both lifetime maximum RSS counters must retain their high-water marks') + if case == 'rss-overlap': + validate_overlapping_rss(value, before, after, mode, budget) + return + if case in ('shared-observer', 'shared-load'): + validate_shared_pages(value, before, after, case, budget) + return + if case in ('observer', 'load'): + selected = 'during' if case == 'observer' else 'hot' + hot = context(value[selected], budget) + need(hot['cgroup_key'] == before['cgroup_key'] and hot['identity'] == before['identity'] + and hot['members'] == [1] and before['monotonic_ns'] <= hot['monotonic_ns'] <= after['monotonic_ns'], + 'The sibling sample must retain its exact owner and window') + need(after['snapshot']['memory_peak'] >= hot['snapshot']['memory_peak'], 'The sibling lifetime peak must persist') + if case == 'load': + need(value['allocation_bytes'] == probe.SIBLING_BYTES + and hot['snapshot']['memory_current'] >= probe.SIBLING_BYTES, + 'The real private sibling allocation must be observed') + else: + need(hot['snapshot']['memory_peak'] < probe.SIBLING_BYTES // 2, + 'Sibling private allocation must remain outside the observer budget') + return + need(value['worker_exit_code'] == 0 and type(value['launcher_pid']) is int and value['launcher_pid'] > 1, + 'An actual completed worker identity required') + rows = value['worker_records'] + if case == 'detached': + need(len(rows) == 1 and rows[0]['stage'] == 'detached', 'Exact detached launcher roster required') + detached = value['detached'] + hot = context(detached['hot'], budget) + launcher, adopted = identity(rows[0]['launcher']), identity(detached['adopted_identity']) + need(launcher['pid'] == value['launcher_pid'] and launcher['ppid'] == 1 + and rows[0]['child_pid'] == hot['identity']['pid'] == adopted['pid'] + and hot['identity']['ppid'] == launcher['pid'] and adopted['ppid'] == 1 + and adopted['pgid'] == adopted['sid'] == adopted['pid'] + and adopted['start_ticks'] == hot['identity']['start_ticks'] + and detached['exit_code'] == 0 and detached['optimized_python'] is (mode == 'optimized'), + 'Detached process/session identity, adoption, mode and normal join required') + observed = context(detached['observed_after_launcher_exit'], budget) + need(observed['members'] == sorted([1, adopted['pid']]) + and observed['identity'] == before['identity'] + and observed['cgroup_key'] == before['cgroup_key'] and value['parent_live_child_polls'] == 1 + and hot['monotonic_ns'] <= observed['monotonic_ns'] <= after['monotonic_ns'], + 'The detached worker must be observed after its launcher retires') + allocation = detached + else: + need(type(rows) is list and len(rows) == (1 if case == 'direct' else 3), 'Complete worker/exec record roster required') + stages = {row['stage']: row for row in rows} + need(len(stages) == len(rows) and set(stages) == ({'allocation'} if case == 'direct' + else {'before-exec', 'allocation', 'joined'}), 'Unique required worker stages must be present') + allocation = stages['allocation'] + hot = context(allocation['hot'], budget) + entry = context(allocation['before'], budget) + need(entry['identity'] == hot['identity'] and entry['cgroup_key'] == before['cgroup_key'] + and entry['members'] == hot['members'] + and before['monotonic_ns'] <= entry['monotonic_ns'] <= hot['monotonic_ns'], + 'Worker entry must bind the same live owner, roster and measured window') + need(allocation['optimized_python'] is (mode == 'optimized') and value['parent_live_child_polls'] == 0, + 'The transient worker must preserve mode while the parent samples entry and final state') + if case == 'direct': + need(hot['identity']['pid'] == value['launcher_pid'] and hot['identity']['ppid'] == 1, + 'The direct allocation must bind the actual child') + else: + previous, joined = identity(stages['before-exec']['identity']), stages['joined'] + launcher = identity(joined['launcher']) + need(previous == hot['identity'] and launcher['pid'] == value['launcher_pid'] + and launcher['ppid'] == 1 and previous['ppid'] == launcher['pid'] + and joined['child_pid'] == previous['pid'] and joined['exit_code'] == 0, + 'The same forked process must exec and be reaped by the actual launcher') + expected_members = sorted({1, value['launcher_pid'], hot['identity']['pid']}) + need(hot['members'] == expected_members + and before['monotonic_ns'] <= hot['monotonic_ns'] <= after['monotonic_ns'], + 'Every live supervisor, launcher and worker must appear inside the measured window') + need(hot['cgroup_key'] == before['cgroup_key'] and hot['membership'] == before['membership'] + and allocation['allocation_bytes'] == probe.CHILD_BYTES and allocation['touched_pages'] == probe.CHILD_BYTES // 4096 + and hot['snapshot']['memory_current'] >= probe.CHILD_BYTES, + 'Every declared private page must be consumed inside the same measured cgroup') + need(hot['self_peak_rss_kib'] * 1024 >= probe.CHILD_BYTES + and after['waited_children_peak_rss_kib'] >= hot['self_peak_rss_kib'], + 'The waited-child maximum must retain the real worker RSS high-water mark') + if case != 'detached': + need((hot['self_peak_rss_kib'] - entry['self_peak_rss_kib']) * 1024 >= probe.CHILD_BYTES // 2, + 'Known private allocation must raise the worker RSS high-water mark') + need(after['snapshot']['memory_peak'] >= hot['snapshot']['memory_peak'] + and after['snapshot']['memory_peak'] >= before['snapshot']['memory_peak'] + probe.CHILD_BYTES // 2 + and after['snapshot']['memory_peak'] - after['snapshot']['memory_current'] >= probe.CHILD_BYTES // 2, + 'The final kernel peak must retain the retired private allocation') + + +def validate_overlapping_rss(value, before, after, mode, budget): + workers = value['workers'] + need(type(workers) is list and len(workers) == 2 and len({row['pid'] for row in workers}) == 2, + 'Two distinct actual overlapping workers are required') + during = context(value['during'], budget) + members = sorted([1] + [row['pid'] for row in workers]) + need(during['identity'] == before['identity'] and during['cgroup_key'] == before['cgroup_key'] + and during['members'] == members and during['snapshot']['pids_current'] == 3 + and before['monotonic_ns'] < during['monotonic_ns'] < after['monotonic_ns'] + and during['snapshot']['memory_current'] >= 2 * probe.CHILD_BYTES, + 'Both consumed private allocations must be live in the same measured window') + peaks = [] + for row in workers: + allocation = row['allocation'] + entry, hot = context(allocation['before'], budget), context(allocation['hot'], budget) + need(row['exit_code'] == 0 and allocation['stage'] == 'allocation' + and allocation['optimized_python'] is (mode == 'optimized') + and allocation['allocation_bytes'] == probe.CHILD_BYTES + and allocation['touched_pages'] == probe.CHILD_BYTES // 4096, + 'Both exact workers must consume the known private allocation and finish normally') + need(entry['identity'] == hot['identity'] and hot['identity']['pid'] == row['pid'] + and hot['identity']['ppid'] == 1 and hot['cgroup_key'] == entry['cgroup_key'] == before['cgroup_key'] + and set(hot['members']) <= set(members) and {1, row['pid']} <= set(hot['members']) + and before['monotonic_ns'] < entry['monotonic_ns'] <= hot['monotonic_ns'] <= during['monotonic_ns'], + 'Each held worker must retain its birth, owner, membership and window') + need(hot['self_peak_rss_kib'] * 1024 >= probe.CHILD_BYTES + and (hot['self_peak_rss_kib'] - entry['self_peak_rss_kib']) * 1024 >= probe.CHILD_BYTES // 2, + 'Each held private allocation must raise its own RSS high-water mark') + peaks.append(hot['self_peak_rss_kib']) + largest = after['waited_children_peak_rss_kib'] + need(before['waited_children_peak_rss_kib'] == during['waited_children_peak_rss_kib'] == 0 + and max(peaks) <= largest and probe.CHILD_BYTES <= largest * 1024 < 2 * probe.CHILD_BYTES + and after['snapshot']['memory_peak'] >= during['snapshot']['memory_current'] + and after['snapshot']['memory_peak'] > largest * 1024, + 'Largest waited-child RSS and simultaneous whole-group charge must remain distinct') + + +def shared_file(value): + need(type(value) is dict and set(value) == {'device', 'inode', 'bytes', 'uid', 'mode', 'sha256'} + and all(type(value[key]) is int and value[key] > 0 for key in ('device', 'inode', 'bytes', 'uid', 'mode')) + and value['bytes'] == probe.SHARED_BYTES and value['uid'] == 501 and value['mode'] == 0o644 + and value['sha256'] == probe.shared_signature(), 'The complete shared inode and content signature must match') + + +def validate_shared_pages(value, before, after, case, budget): + hot = context(value['during' if case == 'shared-observer' else 'hot'], budget) + shared_file(value['file']) + need(value['page_checksum'] == probe.SHARED_BYTES // 4096 + and hot['identity'] == before['identity'] and hot['cgroup_key'] == before['cgroup_key'] + and hot['members'] == [1] and hot['snapshot']['pids_current'] == 1 + and before['monotonic_ns'] <= hot['monotonic_ns'] <= after['monotonic_ns'] + and hot['self_peak_rss_kib'] * 1024 >= probe.SHARED_BYTES + and after['self_peak_rss_kib'] >= hot['self_peak_rss_kib'] + and after['snapshot']['memory_peak'] >= hot['snapshot']['memory_peak'], + 'The complete shared-page consumer must preserve its owner, consumption, RSS and window') + if case == 'shared-load': + retained = context(value['retained'], budget) + need(retained['identity'] == before['identity'] and retained['cgroup_key'] == before['cgroup_key'] + and retained['members'] == [1] and retained['snapshot']['pids_current'] == 1 + and hot['monotonic_ns'] <= retained['monotonic_ns'] <= after['monotonic_ns'] + and hot['snapshot']['memory_current'] >= probe.SHARED_BYTES + and retained['snapshot']['memory_current'] >= probe.SHARED_BYTES + and after['snapshot']['memory_peak'] >= retained['snapshot']['memory_peak'], + 'The writer must retain the first-touch charge while the shared reader is live') + else: + need(hot['snapshot']['memory_current'] < probe.SHARED_BYTES // 2 + and after['snapshot']['memory_peak'] < probe.SHARED_BYTES // 2 + and (hot['self_peak_rss_kib'] - before['self_peak_rss_kib']) * 1024 >= probe.SHARED_BYTES // 2, + 'The shared reader RSS must rise while its own cgroup charge remains separate') + + +def validate_host_pair(evidence, results, mode, prefix, read_result): + host_rows = read_result(evidence / (mode + '-' + prefix + 'sibling-host.json')) + need(len(host_rows) == 2 and Path(host_rows[0]['cgroup_path']).parent == Path(host_rows[1]['cgroup_path']).parent + and host_rows[0]['cgroup_path'] != host_rows[1]['cgroup_path'], 'Actual host sibling hierarchy required') + for row, role in zip(host_rows, ('observer', 'load')): + case = mode + '-' + prefix + role + result = results[case] + container = read_result(evidence / (case + '.inspect.json'))[0] + identity(row['identity']) + need(row['container_id'] == container['Id'] + and Path(row['cgroup_path']).name == 'docker-' + container['Id'] + '.scope' + and row['membership'] == '0::' + row['cgroup_path'] + '\n' + and row['identity']['start_ticks'] == result['before']['identity']['start_ticks'] + and row['cgroup_key']['inode'] == result['before']['cgroup_key']['inode'], + 'Outer Docker/PID/cgroup identity must bind the inner owner') + + +def validate(evidence, pins, token, read_result=read): + budget = probe.verify_sources(pins) + image = read_result(evidence / 'image-inspect.json')[0] + need('python@sha256:' + IMAGE.split('@sha256:')[1] in image['RepoDigests'], 'Actual pinned image digest required') + identities = set() + results = {} + for mode in ('ordinary', 'optimized'): + for case in CASES: + selected = mode + '-' + case + value = read_result(evidence / (selected + '.json')) + validate_single(value, case, mode, pins, token, budget) + results[selected] = value + container = read_result(evidence / (selected + '.inspect.json'))[0] + flags = ['python3', '-I', '-S', '-B'] + (['-O'] if mode == 'optimized' else []) + expected = flags + ['/workspace/tools/whole_build_memory/probe.py', '--case', case, + '--output', '/evidence/' + selected + '.json', '--token', token, '--pins-sha256', pins] + state, host = container['State'], container['HostConfig'] + need(re.fullmatch('[0-9a-f]{64}', container['Id']) is not None + and container['Id'] not in identities and container['Image'] == image['Id'] + and container['Config']['Image'] == IMAGE and container['Config']['Cmd'] == expected + and container['Config']['Entrypoint'] is None and container['Config']['Env'] == image['Config']['Env'] + and container['Config']['User'] == '501:501', 'Exact distinct image, command, mode and environment required') + need(container['Config']['Labels'].get('org.amberframework.atlas.run') == token + and container['Config']['Labels'].get('org.amberframework.atlas.probe') == selected + and sorted((item['Destination'], item['RW']) for item in container['Mounts']) + == [('/evidence', True), ('/workspace', False)], 'Exact source/evidence mounts and owned labels required') + identities.add(container['Id']) + need(state['Status'] == 'exited' and state['Running'] is False and state['ExitCode'] == 0 + and state['OOMKilled'] is False and state['Error'] == '' + and host['Memory'] == host['MemorySwap'] == 536866816 and host['NanoCpus'] == 1_000_000_000 + and host['PidsLimit'] == 64 and host['NetworkMode'] == 'none' and host['ReadonlyRootfs'] is True + and host['CgroupnsMode'] == 'private' and host['Privileged'] is False and host['CapDrop'] == ['ALL'] + and host['SecurityOpt'] in (['no-new-privileges'], ['no-new-privileges=true']), + 'The complete capped nonprivileged case must retire normally') + observer, load = results[mode + '-observer'], results[mode + '-load'] + need(observer['sibling_hot'] == {'hot': load['hot'], 'allocation_bytes': probe.SIBLING_BYTES}, + 'The observer must sample the actual concurrent private load') + validate_host_pair(evidence, results, mode, '', read_result) + reader, writer = results[mode + '-shared-observer'], results[mode + '-shared-load'] + host_file = read_result(evidence / (mode + '-shared-file-host.json')) + shared_file(host_file) + need(reader['file'] == writer['file'] == host_file + and reader['writer_hot'] == {'hot': writer['hot'], 'file': writer['file'], 'page_checksum': writer['page_checksum']} + and reader['during']['monotonic_ns'] <= writer['retained']['monotonic_ns'] + and reader['during']['cgroup_key'] != writer['retained']['cgroup_key'], + 'Independent host and both live consumers must bind the same shared inode and charge window') + validate_host_pair(evidence, results, mode, 'shared-', read_result) + return {'passed': True, 'format': 'atlas-build-descendant-verdict-v1', + 'cases': sorted(results), 'distinct_container_ids': sorted(identities), + 'rss_protocol_accepted': True, 'rss_scope': 'self-and-largest-waited-child-high-water-kib-v1', + 'shared_charge_protocol_accepted': True, 'cgroup_write_fence_accepted': True, + 'actual_process_migration_accepted': False, + 'compiler_rss_accepted': False, 'complete_Grant_build_accepted': False, 'actual_Grant_cells': 0} + + +def sensitivity_controls(evidence, pins, token): + """Challenge the full validator with changed copies of actual observations.""" + validate(evidence, pins, token) + controls = [] + for mode in ('ordinary', 'optimized'): + direct = mode + '-direct.json' + fork = mode + '-fork-exec.json' + detached = mode + '-detached.json' + observer = mode + '-observer.json' + host = mode + '-sibling-host.json' + command = mode + '-direct.inspect.json' + overlap = mode + '-rss-overlap.json' + reader = mode + '-shared-observer.json' + writer = mode + '-shared-load.json' + changes = ( + ('lost_retired_peak', direct, lambda value: value['after']['snapshot'].update( + memory_peak=value['before']['snapshot']['memory_peak'])), + ('changed_exec_birth', fork, lambda value: value['worker_records'][0]['identity'].update( + start_ticks=value['worker_records'][0]['identity']['start_ticks'] + 1)), + ('lost_adoption', detached, lambda value: value['detached']['adopted_identity'].update( + ppid=value['launcher_pid'])), + ('omitted_live_orphan', detached, lambda value: value['detached']['observed_after_launcher_exit'].update( + members=[1])), + ('mixed_sibling_charge', observer, lambda value: ( + value['during']['snapshot'].update(memory_peak=probe.SIBLING_BYTES), + value['after']['snapshot'].update(memory_peak=probe.SIBLING_BYTES))), + ('same_host_cgroup', host, lambda value: value[1].update(cgroup_path=value[0]['cgroup_path'])), + ('missing_kernel_events', direct, lambda value: value['before']['snapshot'].update(memory_events={})), + ('changed_command', command, lambda value: value[0]['Config']['Cmd'].append('--changed-command')), + ('omitted_direct_parent', direct, lambda value: value['worker_records'][0]['hot'].update( + members=[value['worker_records'][0]['hot']['identity']['pid']])), + ('omitted_fork_parents', fork, lambda value: value['worker_records'][1]['hot'].update( + members=[value['worker_records'][1]['hot']['identity']['pid']])), + ('omitted_detached_parents', detached, lambda value: value['detached']['hot'].update( + members=[value['detached']['hot']['identity']['pid']])), + ('allocation_outside_window', direct, lambda value: value['worker_records'][0]['hot'].update( + monotonic_ns=value['before']['monotonic_ns'] - 1)), + ('lost_waited_rss_peak', direct, lambda value: value['after'].update(waited_children_peak_rss_kib=0)), + ('boolean_self_rss', direct, lambda value: value['worker_records'][0]['hot'].update(self_peak_rss_kib=True)), + ('rss_bytes_used_as_kib', overlap, lambda value: value['after'].update( + waited_children_peak_rss_kib=value['after']['waited_children_peak_rss_kib'] * 1024)), + ('summed_rss_used_as_largest', overlap, lambda value: value['after'].update( + waited_children_peak_rss_kib=sum(row['allocation']['hot']['self_peak_rss_kib'] for row in value['workers']))), + ('overlap_omitted_worker', overlap, lambda value: value['during'].update(members=[1, value['workers'][0]['pid']])), + ('changed_shared_inode', reader, lambda value: value['file'].update(inode=value['file']['inode'] + 1)), + ('changed_shared_content', reader, lambda value: value['file'].update(sha256='0' * 64)), + ('lost_shared_writer_charge', writer, lambda value: value['hot']['snapshot'].update(memory_current=1)), + ('shared_reader_charged_as_private', reader, lambda value: ( + value['during']['snapshot'].update(memory_current=probe.SHARED_BYTES, memory_peak=probe.SHARED_BYTES), + value['after']['snapshot'].update(memory_peak=probe.SHARED_BYTES))), + ('lost_shared_reader_rss', reader, lambda value: value['during'].update(self_peak_rss_kib=1)), + ('wrong_shared_page_checksum', reader, lambda value: value.update(page_checksum=value['page_checksum'] - 1)), + ('lost_retained_shared_charge', writer, lambda value: value['retained']['snapshot'].update(memory_current=1)), + ('writable_cgroup_admission', direct, lambda value: value.update(cgroup_write_refusal_errno=0)), + ) + for label, filename, change in changes: + changed = copy.deepcopy(read(evidence / filename)) + change(changed) + + def altered(path): + return copy.deepcopy(changed) if path.name == filename else read(path) + + try: + validate(evidence, pins, token, read_result=altered) + except (RuntimeError, KeyError, TypeError, ValueError) as error: + controls.append({'mode': mode, 'case': label, 'changed_actual_file': filename, + 'rejected': True, 'reason': str(error)}) + else: + raise RuntimeError('Changed actual evidence must be rejected: ' + mode + '/' + label) + restored = validate(evidence, pins, token) + return {'passed': True, 'controls': controls, 'restored_actual_accepted': restored['passed']}