681 lines
25 KiB
Bash
Executable File
681 lines
25 KiB
Bash
Executable File
#!/bin/sh
|
|
set -eu
|
|
|
|
: "${PRE15_DUT:?PRE15_DUT is required}"
|
|
: "${PRE15_ROOT:?PRE15_ROOT is required}"
|
|
: "${PRE15_CASE_TMP:?PRE15_CASE_TMP is required}"
|
|
: "${PRE15_RUN_DIR:?PRE15_RUN_DIR is required}"
|
|
: "${PRE15_LIB_DIR:?PRE15_LIB_DIR is required}"
|
|
. "$PRE15_LIB_DIR/runner.sh"
|
|
|
|
fixture_dir=$PRE15_DUT/tests/pre15/fixtures
|
|
spec=$fixture_dir/B27-stream-tail.json
|
|
generator=$fixture_dir/B27-stream-fixtures.py
|
|
probe=$fixture_dir/B27-stream-probe.c
|
|
compact_probe=$fixture_dir/B27-compact-finalization.c
|
|
kld_builder=$fixture_dir/B27-build-kld.sh
|
|
gate_script=$PRE15_DUT/tests/pre15/gates/P15-083.sh
|
|
gate_input=$PRE15_DUT/tests/pre15/gates/P15-083-input.json
|
|
artifacts=$PRE15_RUN_DIR/artifacts
|
|
gate_clone=$PRE15_CASE_TMP/gate-clone
|
|
gate_output=$PRE15_CASE_TMP/gate-output
|
|
first=$PRE15_CASE_TMP/fixtures-first
|
|
second=$PRE15_CASE_TMP/fixtures-second
|
|
|
|
for tool in cc cmp diff dump.erofs fsck.erofs git mkfs.erofs python3 sha256sum timeout; do
|
|
command -v "$tool" >/dev/null 2>&1 || \
|
|
pre15_infra_blocked "missing B27 host tool: $tool"
|
|
done
|
|
|
|
pre15_record_fixture b27-case "$PRE15_DUT/tests/pre15/cases/B27-stream-tail.sh"
|
|
pre15_record_fixture b27-spec "$spec"
|
|
pre15_record_fixture b27-generator "$generator"
|
|
pre15_record_fixture b27-probe "$probe"
|
|
pre15_record_fixture b27-compact-finalization "$compact_probe"
|
|
pre15_record_fixture b27-kld-builder "$kld_builder"
|
|
pre15_record_fixture b27-gate "$gate_script"
|
|
pre15_record_fixture b27-gate-input "$gate_input"
|
|
for source in decompressor_deflate.c decompressor_lzma.c decompressor_zstd.c \
|
|
decompressor.c zdata.c zmap.c compress.h; do
|
|
pre15_record_fixture "b27-$source" "$PRE15_DUT/src/$source"
|
|
done
|
|
mkdir -p "$artifacts"
|
|
|
|
if ! git clone -q --shared --no-checkout "$PRE15_ROOT" "$gate_clone" \
|
|
>"$artifacts/gate-clone.stdout" 2>"$artifacts/gate-clone.stderr" || \
|
|
! git -C "$gate_clone" checkout -q --detach \
|
|
338ba8daf81c1461b5d28ca9c5345686e4e0f2eb \
|
|
>"$artifacts/gate-checkout.stdout" 2>"$artifacts/gate-checkout.stderr"; then
|
|
pre15_runner_fail 'could not materialize the frozen P15-083 gate commit'
|
|
fi
|
|
frozen_gate=$gate_clone/repo-pre-15/tests/pre15/gates/P15-083.sh
|
|
if ! (umask 022 && timeout -k 10 240 "$frozen_gate" \
|
|
--base 68bbe94c44e35d53cec8ab55d007f40b01cf0502 \
|
|
--output "$gate_output") >"$artifacts/gate.stdout" \
|
|
2>"$artifacts/gate.stderr"; then
|
|
pre15_runner_fail 'frozen P15-083 gate replay failed'
|
|
fi
|
|
|
|
if ! (umask 022 && python3 -B "$generator" --spec "$spec" --output "$first") \
|
|
>"$artifacts/generate-first.json" 2>"$artifacts/generate-first.stderr"; then
|
|
pre15_runner_fail 'B27 first real EROFS fixture generation failed'
|
|
fi
|
|
if ! (umask 022 && python3 -B "$generator" --spec "$spec" --output "$second") \
|
|
>"$artifacts/generate-second.json" 2>"$artifacts/generate-second.stderr"; then
|
|
pre15_runner_fail 'B27 second real EROFS fixture generation failed'
|
|
fi
|
|
if ! diff -qr "$first" "$second" >"$artifacts/fixture-repeat.diff"; then
|
|
pre15_runner_fail 'B27 real EROFS fixtures are not byte reproducible'
|
|
fi
|
|
|
|
cp "$gate_output/result.json" "$artifacts/P15-083-result.json"
|
|
cp "$gate_output/codec-results.json" "$artifacts/P15-083-codec-results.json"
|
|
cp "$first/fixture-index.json" "$artifacts/B27-fixture-index.json"
|
|
|
|
if ! cc -std=c11 -Wall -Wextra -Werror "$compact_probe" \
|
|
-o "$PRE15_CASE_TMP/B27-compact-finalization" \
|
|
>"$artifacts/B27-compact-finalization-build.stdout" \
|
|
2>"$artifacts/B27-compact-finalization-build.stderr" || \
|
|
! "$PRE15_CASE_TMP/B27-compact-finalization" \
|
|
>"$artifacts/B27-compact-finalization.stdout" \
|
|
2>"$artifacts/B27-compact-finalization.stderr"; then
|
|
pre15_dut_fail 'B27 compact HEAD finalization regression failed'
|
|
fi
|
|
if ! python3 -B - "$PRE15_DUT/src/zmap.c" \
|
|
"$PRE15_DUT/src/decompressor_zstd.c" \
|
|
"$artifacts/B27-compact-finalization-source.json" <<'PY'
|
|
import json
|
|
from pathlib import Path
|
|
import sys
|
|
|
|
source = Path(sys.argv[1]).read_text(encoding="utf-8")
|
|
zstd = Path(sys.argv[2]).read_text(encoding="utf-8")
|
|
rejected = """\t\t\t\tif ((lo & Z_EROFS_LI_D0_CBLKCNT) != 0) {
|
|
\t\t\t\t\tif (i == 0) {
|
|
\t\t\t\t\t\terofs_put_metabuf(&buf);
|
|
\t\t\t\t\t\treturn (EINTEGRITY);
|
|
\t\t\t\t\t}
|
|
"""
|
|
accepted = """\t\t\t\tif ((lo & Z_EROFS_LI_D0_CBLKCNT) != 0) {
|
|
\t\t\t\t\t--i;
|
|
\t\t\t\t\tnblk += lo & ~Z_EROFS_LI_D0_CBLKCNT;
|
|
\t\t\t\t\tcontinue;
|
|
"""
|
|
if rejected in source or source.count(accepted) != 1:
|
|
raise SystemExit("B27 compact HEAD finalization source mismatch")
|
|
if zstd.count("\t.supports_subextent = 0,\n") != 1:
|
|
raise SystemExit("B27 Zstd ordinary subextent fallback is disabled")
|
|
Path(sys.argv[3]).write_text(json.dumps({
|
|
"cblkcnt_first_slot": "accepted",
|
|
"linux_completion_semantics": True,
|
|
"status": "PASS",
|
|
"zstd_ordinary_subextent": False,
|
|
"zstd_partial_reference_completion": True,
|
|
}, indent=2, sort_keys=True) + "\n", encoding="ascii")
|
|
PY
|
|
then
|
|
pre15_dut_fail 'B27 compact HEAD finalization source audit failed'
|
|
fi
|
|
|
|
if test "${PRE15_QEMU_TARGET_ONLY:-0}" = 1; then
|
|
pre15_target_reached
|
|
else
|
|
if ! python3 -B - "$PRE15_ROOT" "$PRE15_DUT" "$spec" \
|
|
"$gate_script" "$gate_input" "$gate_output/result.json" \
|
|
"$gate_output/codec-results.json" "$first/fixture-index.json" \
|
|
"$artifacts/B27-source-audit.json" "$PRE15_CASE_TMP/finish-harness.c" <<'PY'
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import json
|
|
from pathlib import Path
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
|
|
|
|
root = Path(sys.argv[1])
|
|
dut = Path(sys.argv[2])
|
|
spec = json.loads(Path(sys.argv[3]).read_text(encoding="ascii"))
|
|
gate_script = Path(sys.argv[4])
|
|
gate_input = Path(sys.argv[5])
|
|
result = json.loads(Path(sys.argv[6]).read_text(encoding="ascii"))
|
|
codec_results = json.loads(Path(sys.argv[7]).read_text(encoding="ascii"))
|
|
fixture_index = json.loads(Path(sys.argv[8]).read_text(encoding="ascii"))
|
|
report_path = Path(sys.argv[9])
|
|
harness_path = Path(sys.argv[10])
|
|
baseline = spec["baseline"]
|
|
implementation = "0eda2fcfc94aba1e51d3f9ee9885260969240de1"
|
|
runtime_base = "445da30f913dc292666f340588236498ea793db3"
|
|
|
|
|
|
def fail(message: str) -> None:
|
|
raise SystemExit(message)
|
|
|
|
|
|
def sha256(path: Path) -> str:
|
|
return hashlib.sha256(path.read_bytes()).hexdigest()
|
|
|
|
|
|
def committed(commit: str, name: str) -> str:
|
|
completed = subprocess.run(
|
|
["git", "-C", str(root), "show", f"{commit}:repo-pre-15/src/{name}"],
|
|
check=False,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
text=True,
|
|
)
|
|
if completed.returncode != 0:
|
|
fail(f"cannot read B27 source {commit}:{name}: {completed.stderr.strip()}")
|
|
return completed.stdout
|
|
|
|
|
|
def replace_once(source: str, old: str, new: str, label: str) -> str:
|
|
count = source.count(old)
|
|
if count != 1:
|
|
fail(f"{label}: expected one baseline occurrence, found {count}")
|
|
return source.replace(old, new, 1)
|
|
|
|
|
|
def extract_function(source: str, name: str) -> str:
|
|
match = re.search(r"^" + re.escape(name) + r"\s*\(", source, re.MULTILINE)
|
|
if match is None:
|
|
fail(f"missing function: {name}")
|
|
name_line = source.rfind("\n", 0, match.start()) + 1
|
|
start = source.rfind("\n", 0, name_line - 1) + 1
|
|
brace = source.find("{", match.end())
|
|
depth = 0
|
|
for index in range(brace, len(source)):
|
|
if source[index] == "{":
|
|
depth += 1
|
|
elif source[index] == "}":
|
|
depth -= 1
|
|
if depth == 0:
|
|
return source[start : index + 1]
|
|
fail(f"unterminated function: {name}")
|
|
|
|
|
|
if (
|
|
spec.get("schema") != 1
|
|
or spec.get("batch") != "B27"
|
|
or spec.get("candidate") != "P15-083"
|
|
or spec.get("test") != "TC176-stream-runtime"
|
|
):
|
|
fail("B27 fixture identity changed")
|
|
if sha256(gate_script) != spec["gate"]["script_sha256"]:
|
|
fail("tracked P15-083 gate script differs from G04 GO")
|
|
if sha256(gate_input) != spec["gate"]["input_sha256"]:
|
|
fail("tracked P15-083 gate input differs from G04 GO")
|
|
if not (
|
|
result.get("status") == "GO"
|
|
and result.get("b27") == "AUTHORIZED"
|
|
and result.get("cleanup") == "PASS"
|
|
and result.get("typed_errno") == "PASS"
|
|
and result.get("codecs") == {"deflate": "GO", "lzma": "GO", "zstd": "GO"}
|
|
):
|
|
fail("frozen P15-083 gate did not reproduce B27 authorization")
|
|
|
|
observed = {item["codec"]: item for item in codec_results}
|
|
if set(observed) != set(spec["codecs"]):
|
|
fail("G04 codec result set changed")
|
|
for codec, expected in spec["codecs"].items():
|
|
item = observed[codec]
|
|
gate = expected["gate"]
|
|
extent = expected["extent"]
|
|
if any(item["extent"][key] != extent[key] for key in (
|
|
"leading_zero_bytes", "logical_length", "logical_offset",
|
|
"physical_length", "physical_offset", "stream_bytes"
|
|
)):
|
|
fail(f"{codec} legal leading-padding extent changed")
|
|
checks = (
|
|
item["full"]["consumed"] == gate["full_consumed"],
|
|
item["full"]["policy_errno"] == 0,
|
|
item["partial"]["consumed"] == gate["partial_consumed"],
|
|
item["partial"]["requested_bytes"] == extent["partial_size"],
|
|
item["partial"]["policy_errno"] == 0,
|
|
item["partial"]["corrupt_policy_errno"] == 0,
|
|
item["tail"]["consumed"] == gate["tail_consumed"],
|
|
item["tail"]["policy_errno"] == 97,
|
|
item["tail"]["fsck"]["exit"] == gate["tail_fsck_exit"],
|
|
item["truncated"]["consumed"] == gate["truncated_consumed"],
|
|
item["truncated"]["policy_errno"] == 97,
|
|
item["corruption"]["full_errno"] == 97,
|
|
item["corruption"]["starts_at_stream_byte"] == expected["corruption_start"],
|
|
item["corruption"]["starts_after_partial_consumed"] is True,
|
|
)
|
|
if not all(checks):
|
|
fail(f"{codec} G04 completion/trailing/partial contract changed")
|
|
for phase in ("full", "partial", "tail", "truncated"):
|
|
if item[phase]["cleanup"] != 1 or item[phase]["guards"] != 1:
|
|
fail(f"{codec} {phase} oracle cleanup/guard failed")
|
|
|
|
if fixture_index.get("fixture_count") != 12 or fixture_index.get("status") != "READY":
|
|
fail("B27 runtime fixture matrix is incomplete")
|
|
classes = {(item["codec"], item["class"]) for item in fixture_index["fixtures"]}
|
|
if classes != {
|
|
(codec, kind)
|
|
for codec in spec["codecs"]
|
|
for kind in ("valid", "tail", "truncated", "corrupt")
|
|
}:
|
|
fail("B27 runtime fixture class set changed")
|
|
|
|
base = {
|
|
name: committed(baseline, name)
|
|
for name in (
|
|
"compress.h", "decompressor.c", "decompressor_deflate.c",
|
|
"decompressor_lzma.c", "decompressor_zstd.c", "zdata.c"
|
|
)
|
|
}
|
|
implemented = {name: committed(implementation, name) for name in base}
|
|
for name in ("compress.h", "decompressor.c", "zdata.c"):
|
|
if implemented[name] != base[name]:
|
|
fail(f"B27 changed excluded provider/GEOM/buffer-lifetime file: {name}")
|
|
|
|
deflate_helper = '''static int
|
|
z_erofs_deflate_finish(const struct z_erofs_decompress_req *rq, int ret,
|
|
uInt avail_in)
|
|
{
|
|
|
|
\tif (rq->partial_decoding)
|
|
\t\treturn (0);
|
|
\tif (ret != Z_STREAM_END || avail_in != 0)
|
|
\t\treturn (EINTEGRITY);
|
|
\treturn (0);
|
|
}
|
|
|
|
'''
|
|
expected = replace_once(
|
|
base["decompressor_deflate.c"],
|
|
"static int\nz_erofs_deflate_decompress",
|
|
deflate_helper + "static int\nz_erofs_deflate_decompress",
|
|
"Deflate completion helper",
|
|
)
|
|
expected = replace_once(
|
|
expected,
|
|
"\telse if (error == 0 && !rq->partial_decoding &&\n"
|
|
"\t (ret != Z_STREAM_END || strm.avail_in != 0))\n"
|
|
"\t\terror = EINTEGRITY;",
|
|
"\telse if (error == 0)\n"
|
|
"\t\terror = z_erofs_deflate_finish(rq, ret, strm.avail_in);",
|
|
"Deflate completion call",
|
|
)
|
|
if implemented["decompressor_deflate.c"] != expected:
|
|
fail("Deflate differs from the exact B27 transform")
|
|
|
|
lzma_helper = '''static int
|
|
z_erofs_lzma_finish(const struct z_erofs_decompress_req *rq, enum xz_ret ret,
|
|
size_t input_pos)
|
|
{
|
|
|
|
\tif (rq->partial_decoding &&
|
|
\t (ret == XZ_OK || ret == XZ_STREAM_END))
|
|
\t\treturn (0);
|
|
\tif (!rq->partial_decoding && ret == XZ_STREAM_END &&
|
|
\t input_pos == rq->inputsize)
|
|
\t\treturn (0);
|
|
\treturn (z_erofs_lzma_error(ret));
|
|
}
|
|
|
|
'''
|
|
expected = replace_once(
|
|
base["decompressor_lzma.c"],
|
|
"static int\nz_erofs_lzma_decompress",
|
|
lzma_helper + "static int\nz_erofs_lzma_decompress",
|
|
"LZMA completion helper",
|
|
)
|
|
expected = replace_once(
|
|
expected,
|
|
"\telse if (rq->partial_decoding &&\n"
|
|
"\t (ret == XZ_OK || ret == XZ_STREAM_END))\n"
|
|
"\t\terror = 0;\n"
|
|
"\telse if (!rq->partial_decoding && ret == XZ_STREAM_END &&\n"
|
|
"\t buffer.in_pos == rq->inputsize)\n"
|
|
"\t\terror = 0;\n"
|
|
"\telse\n"
|
|
"\t\terror = z_erofs_lzma_error(ret);",
|
|
"\telse\n"
|
|
"\t\terror = z_erofs_lzma_finish(rq, ret, buffer.in_pos);",
|
|
"LZMA completion call",
|
|
)
|
|
if implemented["decompressor_lzma.c"] != expected:
|
|
fail("LZMA differs from the exact B27 transform")
|
|
|
|
zstd_helper = '''static int
|
|
z_erofs_zstd_finish(const struct z_erofs_decompress_req *rq, size_t ret,
|
|
size_t input_pos, size_t input_size)
|
|
{
|
|
|
|
\tif (rq->partial_decoding)
|
|
\t\treturn (0);
|
|
\tif (ret != 0 || input_pos != input_size)
|
|
\t\treturn (EINTEGRITY);
|
|
\treturn (0);
|
|
}
|
|
|
|
'''
|
|
expected = replace_once(
|
|
base["decompressor_zstd.c"],
|
|
"static const ZSTD_customMem zstd_erofs_alloc = {\n"
|
|
"\t.customAlloc = zstd_alloc,\n"
|
|
"\t.customFree = zstd_free,\n"
|
|
"\t.opaque = M_EROFS,\n"
|
|
"};\n\n"
|
|
"static int\nz_erofs_zstd_decompress",
|
|
"static const ZSTD_customMem zstd_erofs_alloc = {\n"
|
|
"\t.customAlloc = zstd_alloc,\n"
|
|
"\t.customFree = zstd_free,\n"
|
|
"\t.opaque = M_EROFS,\n"
|
|
"};\n\n" + zstd_helper + "static int\nz_erofs_zstd_decompress",
|
|
"Zstd completion helper",
|
|
)
|
|
expected = replace_once(
|
|
expected,
|
|
"\telse if (error == 0 && !rq->partial_decoding &&\n"
|
|
"\t (ret != 0 || input.pos != input.size))\n"
|
|
"\t\terror = EINTEGRITY;",
|
|
"\telse if (error == 0)\n"
|
|
"\t\terror = z_erofs_zstd_finish(rq, ret, input.pos, input.size);",
|
|
"Zstd completion call",
|
|
)
|
|
if implemented["decompressor_zstd.c"] != expected:
|
|
fail("Zstd differs from the exact B27 transform")
|
|
|
|
runtime_names = (
|
|
"decompressor_deflate.c", "decompressor_lzma.c",
|
|
"decompressor_zstd.c", "zmap.c",
|
|
)
|
|
runtime_before = {name: committed(runtime_base, name) for name in runtime_names}
|
|
current = {
|
|
name: (dut / "src" / name).read_text(encoding="utf-8")
|
|
for name in runtime_names
|
|
}
|
|
if current["decompressor_deflate.c"] != runtime_before["decompressor_deflate.c"]:
|
|
fail("B27 remediation changed Deflate beyond the accepted implementation")
|
|
if current["decompressor_lzma.c"] != runtime_before["decompressor_lzma.c"]:
|
|
fail("B27 remediation changed LZMA beyond the accepted implementation")
|
|
if current["decompressor_zstd.c"] != runtime_before["decompressor_zstd.c"]:
|
|
fail("B27 remediation Zstd completion differs from the exact transform")
|
|
expected = replace_once(
|
|
runtime_before["zmap.c"],
|
|
"\t\t\t\t\tif (i == 0) {\n"
|
|
"\t\t\t\t\t\terofs_put_metabuf(&buf);\n"
|
|
"\t\t\t\t\t\treturn (EINTEGRITY);\n"
|
|
"\t\t\t\t\t}\n",
|
|
"",
|
|
"compact HEAD first-slot CBLKCNT completion",
|
|
)
|
|
if current["zmap.c"] != expected:
|
|
fail("B27 remediation compact HEAD completion differs from the exact transform")
|
|
|
|
changed_source = set(
|
|
subprocess.run(
|
|
["git", "-C", str(root), "diff", "--name-only", runtime_base, "--", "repo-pre-15/src"],
|
|
check=True,
|
|
text=True,
|
|
stdout=subprocess.PIPE,
|
|
).stdout.splitlines()
|
|
)
|
|
if changed_source != {
|
|
"repo-pre-15/src/zmap.c",
|
|
}:
|
|
fail(f"B27 source write set changed: {sorted(changed_source)}")
|
|
|
|
all_changed = set(
|
|
subprocess.run(
|
|
["git", "-C", str(root), "diff", "--name-only", runtime_base, "--", "repo-pre-15"],
|
|
check=True,
|
|
text=True,
|
|
stdout=subprocess.PIPE,
|
|
).stdout.splitlines()
|
|
)
|
|
all_changed.update(
|
|
subprocess.run(
|
|
["git", "-C", str(root), "ls-files", "--others", "--exclude-standard", "--", "repo-pre-15"],
|
|
check=True,
|
|
text=True,
|
|
stdout=subprocess.PIPE,
|
|
).stdout.splitlines()
|
|
)
|
|
expected_write_set = {
|
|
"repo-pre-15/src/zmap.c",
|
|
"repo-pre-15/tests/pre15/cases/B27-stream-tail.sh",
|
|
"repo-pre-15/tests/pre15/fixtures/B27-compact-finalization.c",
|
|
}
|
|
if all_changed != expected_write_set:
|
|
fail(f"B27 exact write set differs: {sorted(all_changed ^ expected_write_set)}")
|
|
|
|
joined = "\n".join(current.values())
|
|
if re.search(r"return\s*\(\s*-E[A-Z0-9_]+", joined):
|
|
fail("negative Linux errno entered B27")
|
|
if "ZSTD_getErrorCode" in current["decompressor_zstd.c"]:
|
|
fail("B27 expanded the optional Zstd provider ABI")
|
|
|
|
linux = {
|
|
codec: (root / f"src-linux/decompressor_{codec}.c").read_text(encoding="utf-8")
|
|
for codec in spec["codecs"]
|
|
}
|
|
for codec, marker in {
|
|
"deflate": "if (zerr == Z_STREAM_END && !rq->outputsize)",
|
|
"lzma": "xz_dec_microlzma_reset(strm->state, rq->inputsize, rq->outputsize",
|
|
"zstd": "zerr = zstd_decompress_stream(stream, &out_buf, &in_buf);",
|
|
}.items():
|
|
if marker not in linux[codec]:
|
|
fail(f"Linux {codec} stream-tail anchor changed")
|
|
|
|
harness = f'''#include <stddef.h>
|
|
#include <stdio.h>
|
|
|
|
#define EINTEGRITY 97
|
|
#define ENOMEM 12
|
|
#define EOPNOTSUPP 95
|
|
#define Z_STREAM_END 1
|
|
typedef unsigned int uInt;
|
|
|
|
enum xz_ret {{
|
|
XZ_OK, XZ_STREAM_END, XZ_UNSUPPORTED_CHECK, XZ_MEM_ERROR,
|
|
XZ_MEMLIMIT_ERROR, XZ_FORMAT_ERROR, XZ_OPTIONS_ERROR,
|
|
XZ_DATA_ERROR, XZ_BUF_ERROR
|
|
}};
|
|
|
|
struct z_erofs_decompress_req {{
|
|
int partial_decoding;
|
|
size_t inputsize;
|
|
}};
|
|
|
|
{extract_function(current["decompressor_lzma.c"], "z_erofs_lzma_error")}
|
|
|
|
{extract_function(current["decompressor_deflate.c"], "z_erofs_deflate_finish")}
|
|
|
|
{extract_function(current["decompressor_lzma.c"], "z_erofs_lzma_finish")}
|
|
|
|
{extract_function(current["decompressor_zstd.c"], "z_erofs_zstd_finish")}
|
|
|
|
static int failures;
|
|
|
|
static void
|
|
check(const char *name, int actual, int expected)
|
|
{{
|
|
if (actual != expected) {{
|
|
fprintf(stderr, "%s: actual=%d expected=%d\\n", name, actual, expected);
|
|
failures++;
|
|
}}
|
|
}}
|
|
|
|
int
|
|
main(void)
|
|
{{
|
|
struct z_erofs_decompress_req full = {{ 0, 548 }};
|
|
struct z_erofs_decompress_req partial = {{ 1, 548 }};
|
|
|
|
check("deflate exact", z_erofs_deflate_finish(&full, Z_STREAM_END, 0), 0);
|
|
check("deflate tail", z_erofs_deflate_finish(&full, Z_STREAM_END, 8), EINTEGRITY);
|
|
check("deflate no end", z_erofs_deflate_finish(&full, 0, 0), EINTEGRITY);
|
|
check("deflate partial", z_erofs_deflate_finish(&partial, 0, 8), 0);
|
|
check("lzma exact", z_erofs_lzma_finish(&full, XZ_STREAM_END, 548), 0);
|
|
check("lzma tail", z_erofs_lzma_finish(&full, XZ_STREAM_END, 540), EINTEGRITY);
|
|
check("lzma no end", z_erofs_lzma_finish(&full, XZ_OK, 548), EINTEGRITY);
|
|
check("lzma partial", z_erofs_lzma_finish(&partial, XZ_OK, 352), 0);
|
|
check("lzma partial error", z_erofs_lzma_finish(&partial, XZ_DATA_ERROR, 352), EINTEGRITY);
|
|
check("zstd exact", z_erofs_zstd_finish(&full, 0, 548, 548), 0);
|
|
check("zstd tail", z_erofs_zstd_finish(&full, 0, 540, 548), EINTEGRITY);
|
|
check("zstd no end", z_erofs_zstd_finish(&full, 1, 548, 548), EINTEGRITY);
|
|
check("zstd partial", z_erofs_zstd_finish(&partial, 1, 352, 548), 0);
|
|
return failures != 0;
|
|
}}
|
|
'''
|
|
harness_path.write_text(harness, encoding="ascii")
|
|
|
|
report = {
|
|
"baseline": baseline,
|
|
"batch": "B27",
|
|
"candidate": "P15-083",
|
|
"cleanup_and_guards": True,
|
|
"codecs": sorted(spec["codecs"]),
|
|
"fixture_count": fixture_index["fixture_count"],
|
|
"freebsd_positive_errno": True,
|
|
"gate": "GO",
|
|
"legal_leading_padding_preserved": True,
|
|
"linux_tail_semantics_audited": True,
|
|
"optional_zstd_abi_preserved": True,
|
|
"provider_geom_and_buffer_lifetime_unchanged": True,
|
|
"runtime_base": runtime_base,
|
|
"status": "PASS",
|
|
"test": "TC176-stream-runtime",
|
|
"write_set": sorted(all_changed),
|
|
}
|
|
report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n", encoding="ascii")
|
|
print(json.dumps(report, indent=2, sort_keys=True))
|
|
PY
|
|
then
|
|
pre15_runner_fail 'B27 gate/source/write-set audit failed'
|
|
fi
|
|
|
|
if ! cc -std=c11 -Wall -Wextra -Werror "$PRE15_CASE_TMP/finish-harness.c" \
|
|
-o "$PRE15_CASE_TMP/finish-harness" >"$artifacts/finish-harness-build.stdout" \
|
|
2>"$artifacts/finish-harness-build.stderr" || \
|
|
! "$PRE15_CASE_TMP/finish-harness" >"$artifacts/finish-harness.stdout" \
|
|
2>"$artifacts/finish-harness.stderr"; then
|
|
pre15_dut_fail 'B27 extracted completion policy harness failed'
|
|
fi
|
|
sha256sum "$artifacts/P15-083-result.json" \
|
|
"$artifacts/P15-083-codec-results.json" \
|
|
"$artifacts/B27-fixture-index.json" \
|
|
"$artifacts/B27-source-audit.json" >"$artifacts/SHA256SUMS"
|
|
fi
|
|
pre15_target_reached
|
|
|
|
if test "${PRE15_MODE:-host}" != qemu; then
|
|
printf '%s\n' \
|
|
'TC176 B27 host real LZMA/Deflate/Zstd stream-tail subset PASS' \
|
|
'Legal padding, trailing garbage, truncation, partial decode, corruption, positive errno, and cleanup PASS' \
|
|
'QEMU runtime NOT_RUN in host mode' \
|
|
'Full feature suite NOT_RUN'
|
|
exit 0
|
|
fi
|
|
|
|
for tool in awk clang file nm scp tar; do
|
|
command -v "$tool" >/dev/null 2>&1 || \
|
|
pre15_infra_blocked "missing B27 QEMU tool: $tool"
|
|
done
|
|
: "${PRE15_QEMU_CONTROL_PATH:?QEMU control path is required}"
|
|
: "${PRE15_QEMU_SSH_KEY:?QEMU SSH key is required}"
|
|
: "${PRE15_QEMU_SSH_PORT:?QEMU SSH port is required}"
|
|
: "${PRE15_QEMU_SSH_USER:?QEMU SSH user is required}"
|
|
|
|
fixture_archive=$PRE15_CASE_TMP/B27-fixtures.tar.gz
|
|
module=$PRE15_CASE_TMP/B27-erofs-zstdio1.ko
|
|
if ! /bin/sh "$kld_builder" "$PRE15_DUT" "$PRE15_FREEBSD_SRC" "$module" \
|
|
"$PRE15_CASE_TMP/kld-work" 1 >"$artifacts/B27-kld-build.stdout" \
|
|
2>"$artifacts/B27-kld-build.stderr"; then
|
|
pre15_dut_fail 'B27 cross-target zstdio1 KLD build failed'
|
|
fi
|
|
pre15_record_module "$module"
|
|
file "$module" >"$artifacts/B27-kld-file.txt"
|
|
sha256sum "$module" >"$artifacts/B27-kld-sha256.txt"
|
|
nm -u "$module" | LC_ALL=C sort >"$artifacts/B27-kld-nm-u.txt"
|
|
tar -C "$first" -czf "$fixture_archive" .
|
|
|
|
pre15_scp()
|
|
{
|
|
timeout -k 5 "${PRE15_GUEST_COMMAND_TIMEOUT:-60}" scp -O -q \
|
|
-o BatchMode=yes -o StrictHostKeyChecking=no \
|
|
-o UserKnownHostsFile=/dev/null -o ConnectTimeout=5 \
|
|
-o "ControlPath=$PRE15_QEMU_CONTROL_PATH" \
|
|
-i "$PRE15_QEMU_SSH_KEY" -P "$PRE15_QEMU_SSH_PORT" \
|
|
"$1" "$PRE15_QEMU_SSH_USER@127.0.0.1:$2"
|
|
}
|
|
|
|
if ! pre15_scp "$fixture_archive" /root/B27-fixtures.tar.gz || \
|
|
! pre15_scp "$probe" /root/B27-stream-probe.c || \
|
|
! pre15_scp "$module" /root/B27-erofs-zstdio1.ko; then
|
|
pre15_infra_blocked 'could not transfer B27 module, probe, or fixtures'
|
|
fi
|
|
if ! pre15_guest_ssh_bounded \
|
|
'rm -rf /root/B27-fixtures && mkdir /root/B27-fixtures && tar -xzf /root/B27-fixtures.tar.gz -C /root/B27-fixtures && cc -O2 -Wall -Wextra -Werror -o /root/B27-stream-probe /root/B27-stream-probe.c'; then
|
|
pre15_infra_blocked 'could not prepare B27 guest fixtures/probe'
|
|
fi
|
|
if pre15_guest_ssh_bounded kldstat -q -m erofs >/dev/null 2>&1; then
|
|
pre15_infra_blocked 'guest kernel already owns the erofs.1 interface'
|
|
fi
|
|
if ! pre15_guest_ssh_bounded kldload /root/B27-erofs-zstdio1.ko \
|
|
>"$artifacts/B27-kldload.stdout" 2>"$artifacts/B27-kldload.stderr"; then
|
|
if grep -q 'module already loaded or in kernel' \
|
|
"$artifacts/B27-kldload.stderr"; then
|
|
pre15_infra_blocked 'guest kernel already owns the erofs.1 interface'
|
|
fi
|
|
if grep -Eq 'link_elf|symbol|not defined' "$artifacts/B27-kldload.stderr"; then
|
|
pre15_infra_blocked 'guest kernel lacks the planned ZSTDIO provider ABI'
|
|
fi
|
|
pre15_dut_fail 'B27 exact-source zstdio1 KLD failed to load'
|
|
fi
|
|
pre15_own_guest_kld erofs 'B27 exact-source KLD'
|
|
|
|
attach_mount()
|
|
{
|
|
image=$1
|
|
label=$2
|
|
B27_MD=$(pre15_guest_ssh_bounded mdconfig -a -t vnode \
|
|
-f "/root/B27-fixtures/images/$image") || \
|
|
pre15_dut_fail "$label md attach failed"
|
|
case "$B27_MD" in
|
|
md[0-9]*) ;;
|
|
*) pre15_runner_fail "unexpected B27 md unit: $B27_MD" ;;
|
|
esac
|
|
pre15_own_guest_md "$B27_MD" "$label md"
|
|
B27_MOUNT=/mnt/pre15-b27-$label
|
|
pre15_guest_ssh_bounded mkdir -p "$B27_MOUNT"
|
|
pre15_guest_ssh_bounded mount -t erofs -o ro "/dev/$B27_MD" "$B27_MOUNT" || \
|
|
pre15_dut_fail "$label mount failed"
|
|
pre15_own_guest_mount "$B27_MOUNT" "$label mount"
|
|
}
|
|
|
|
reference=/root/B27-fixtures/source/payload.bin
|
|
for codec in deflate lzma zstd; do
|
|
attach_mount "$codec-valid.erofs" "$codec-valid"
|
|
pre15_guest_ssh_bounded cmp "$B27_MOUNT/payload.bin" "$reference" || \
|
|
pre15_dut_fail "$codec legal leading-padding read mismatch"
|
|
for kind in tail truncated; do
|
|
attach_mount "$codec-$kind.erofs" "$codec-$kind"
|
|
pre15_guest_ssh_bounded /root/B27-stream-probe errno \
|
|
"$B27_MOUNT/payload.bin" 97 || \
|
|
pre15_dut_fail "$codec $kind did not return EINTEGRITY"
|
|
done
|
|
case "$codec" in
|
|
deflate) logical_offset=137204; partial_size=3587 ;;
|
|
lzma|zstd) logical_offset=0; partial_size=4096 ;;
|
|
esac
|
|
attach_mount "$codec-corrupt.erofs" "$codec-corrupt"
|
|
pre15_guest_ssh_bounded /root/B27-stream-probe range \
|
|
"$B27_MOUNT/payload.bin" "$reference" "$logical_offset" \
|
|
"$partial_size" || \
|
|
pre15_dut_fail "$codec range-before-corruption partial decode failed"
|
|
pre15_guest_ssh_bounded /root/B27-stream-probe errno \
|
|
"$B27_MOUNT/payload.bin" 97 || \
|
|
pre15_dut_fail "$codec full corruption did not return EINTEGRITY"
|
|
done
|
|
pre15_guest_ssh_bounded dmesg >"$artifacts/B27-dmesg.txt"
|
|
printf '%s\n' \
|
|
'TC176 B27 QEMU real LZMA/Deflate/Zstd stream-tail subset PASS' \
|
|
'valid=3 trailing=3 truncated=3 partial-before-corruption=3 full-corruption=3 errno=97' \
|
|
'Full feature suite NOT_RUN'
|