197 lines
7.1 KiB
Bash
Executable File
197 lines
7.1 KiB
Bash
Executable File
#!/bin/sh
|
|
set -eu
|
|
|
|
script_dir=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
|
|
output=${1:?usage: prepare_g1_fixtures.sh OUTPUT}
|
|
source_dir="$output/source"
|
|
base_dir="$output/base"
|
|
image_dir="$output/images"
|
|
expected_dir="$output/expected"
|
|
|
|
for tool in mkfs.erofs fsck.erofs dump.erofs python3 sha256sum stat; do
|
|
command -v "$tool" >/dev/null 2>&1 || {
|
|
echo "missing tool: $tool" >&2
|
|
exit 1
|
|
}
|
|
done
|
|
test "$(id -u)" -eq 0 || {
|
|
echo "root is required to create device-node fixtures" >&2
|
|
exit 1
|
|
}
|
|
test ! -e "$output" || {
|
|
echo "output already exists: $output" >&2
|
|
exit 1
|
|
}
|
|
|
|
mkdir -p \
|
|
"$source_dir/compact/dir" \
|
|
"$source_dir/compact/dotdir" \
|
|
"$source_dir/extended" \
|
|
"$source_dir/flat/very/long/path/to/a/deeply/nested/deterministic/target/directory" \
|
|
"$source_dir/inline" \
|
|
"$base_dir" "$expected_dir"
|
|
|
|
SOURCE_DIR="$source_dir" EXPECTED_DIR="$expected_dir" python3 <<'PY'
|
|
from pathlib import Path
|
|
import os
|
|
|
|
source = Path(os.environ["SOURCE_DIR"])
|
|
expected = Path(os.environ["EXPECTED_DIR"])
|
|
|
|
|
|
def write_pattern(path: Path, size: int, seed: int) -> None:
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
with path.open("wb") as out:
|
|
offset = 0
|
|
while offset < size:
|
|
count = min(65536, size - offset)
|
|
out.write(bytes(
|
|
(((offset + index) * 131 + seed) ^ ((offset + index) >> 5)) & 0xff
|
|
for index in range(count)
|
|
))
|
|
offset += count
|
|
|
|
|
|
compact = source / "compact"
|
|
(compact / "root.txt").write_text("repo22 G1 root payload\n", encoding="ascii")
|
|
write_pattern(compact / "testfile.txt", 65537, 1)
|
|
(compact / "small.txt").write_text("compact inode payload\n", encoding="ascii")
|
|
(compact / "single.txt").write_text("single-link payload\n", encoding="ascii")
|
|
(compact / "hard-a.txt").write_text("hard-link payload\n", encoding="ascii")
|
|
(compact / "dotdir" / "child.txt").write_text("dot directory child\n", encoding="ascii")
|
|
(compact / "invalid-target.txt").write_text("invalid nid target\n", encoding="ascii")
|
|
(compact / "special-target.txt").write_text("special target\n", encoding="ascii")
|
|
|
|
extended = source / "extended"
|
|
write_pattern(extended / "large-file.bin", 2 * 1024 * 1024 + 731, 2)
|
|
(extended / "huge-sparse.dat").write_bytes(b"x")
|
|
(extended / "oversize.dat").write_bytes(b"x")
|
|
|
|
flat = source / "flat"
|
|
(flat / "small.txt").write_text("flat plain small payload\n", encoding="ascii")
|
|
write_pattern(flat / "medium.dat", 100 * 1024 + 17, 3)
|
|
write_pattern(flat / "large.bin", 10 * 1024 * 1024 + 31, 4)
|
|
write_pattern(flat / "data.txt", 256 * 1024 + 19, 5)
|
|
write_pattern(flat / "random-test.bin", 1024 * 1024, 6)
|
|
write_pattern(flat / "huge-data.bin", 100 * 1024 * 1024 + 257, 7)
|
|
(flat / "very" / "long" / "path" / "to" / "a" / "deeply" / "nested" /
|
|
"deterministic" / "target" / "directory" / "file.txt").write_text(
|
|
"long symlink target payload\n", encoding="ascii"
|
|
)
|
|
|
|
inline = source / "inline"
|
|
(inline / "tiny.txt").write_text("inline data\n", encoding="ascii")
|
|
(inline / "empty.txt").write_bytes(b"")
|
|
(inline / "inline.txt").write_bytes(b"inline-tail-payload-0123456789\n")
|
|
write_pattern(inline / "tailpacked.dat", 5000, 8)
|
|
write_pattern(inline / "file-4095.dat", 4095, 9)
|
|
write_pattern(inline / "file-4096.dat", 4096, 10)
|
|
write_pattern(inline / "file-4097.dat", 4097, 11)
|
|
(inline / "target.txt").write_text("short symlink target payload\n", encoding="ascii")
|
|
|
|
for source_path, offset, length, output_name in (
|
|
(flat / "medium.dat", 10 * 4096, 5 * 4096, "medium-10-5.bin"),
|
|
(flat / "random-test.bin", 0, 10 * 1024, "random-start.bin"),
|
|
(flat / "random-test.bin", 500 * 1024, 10 * 1024, "random-mid.bin"),
|
|
(flat / "random-test.bin", 1000 * 1024, 24 * 1024, "random-end.bin"),
|
|
(flat / "huge-data.bin", 50 * 1024 * 1024, 5 * 1024 * 1024,
|
|
"huge-sample.bin"),
|
|
):
|
|
with source_path.open("rb") as handle:
|
|
handle.seek(offset)
|
|
data = handle.read(length)
|
|
if len(data) != length:
|
|
raise RuntimeError(f"short expected range from {source_path}")
|
|
(expected / output_name).write_bytes(data)
|
|
(expected / "large-hole-zero-64k.bin").write_bytes(bytes(65536))
|
|
(expected / "large-hole-description.txt").write_text(
|
|
"path=/huge-sparse.dat size=4294971393 content=all-zero\n", encoding="ascii"
|
|
)
|
|
PY
|
|
|
|
ln "$source_dir/compact/testfile.txt" "$source_dir/compact/dir/testfile.txt"
|
|
ln "$source_dir/compact/hard-a.txt" "$source_dir/compact/hard-b.txt"
|
|
ln -s special-target.txt "$source_dir/compact/special-link"
|
|
mknod "$source_dir/compact/char-large" c 2748 344865
|
|
mknod "$source_dir/compact/block-large" b 2748 344865
|
|
mkfifo "$source_dir/compact/fifo"
|
|
ln -s target.txt "$source_dir/inline/link1"
|
|
ln -s /nonexistent/repo22-g1-target "$source_dir/inline/brokenlink"
|
|
ln -s very/long/path/to/a/deeply/nested/deterministic/target/directory/file.txt \
|
|
"$source_dir/flat/longlink"
|
|
find "$source_dir" -exec touch -h -t 197001010000.00 {} +
|
|
|
|
build_image()
|
|
{
|
|
uuid=$1
|
|
image=$2
|
|
source=$3
|
|
shift 3
|
|
mkfs.erofs -d0 -x-1 -T0 --all-time --all-root --workers=1 \
|
|
-U "$uuid" "$@" "$base_dir/$image" "$source_dir/$source"
|
|
}
|
|
|
|
build_image 31000000-0000-0000-0000-000000000001 \
|
|
compact.erofs compact -E force-inode-compact
|
|
build_image 31000000-0000-0000-0000-000000000002 \
|
|
extended.erofs extended -E force-inode-extended
|
|
build_image 31000000-0000-0000-0000-000000000003 \
|
|
flat.erofs flat -E noinline_data,force-inode-compact
|
|
build_image 31000000-0000-0000-0000-000000000004 \
|
|
inline.erofs inline -E force-inode-compact
|
|
|
|
python3 "$script_dir/g1_fixtures.py" \
|
|
--compact "$base_dir/compact.erofs" \
|
|
--extended "$base_dir/extended.erofs" \
|
|
--flat "$base_dir/flat.erofs" \
|
|
--inline "$base_dir/inline.erofs" \
|
|
--output "$image_dir"
|
|
|
|
for image in compact.erofs extended.erofs flat.erofs inline.erofs \
|
|
compact-nlink1.erofs inline-zero.erofs extended-large-hole.erofs; do
|
|
fsck.erofs "$image_dir/$image" >/dev/null
|
|
done
|
|
|
|
printf '%s\n' \
|
|
'48-bit fixtures are field/CRC checked by g1_fixtures.py;' \
|
|
'production fsck.erofs 1.8.6 does not recognize incompat feature 0x80.'
|
|
|
|
dump.erofs --cat --path=/small.txt "$image_dir/compact.erofs" |
|
|
cmp - "$source_dir/compact/small.txt"
|
|
dump.erofs --cat --path=/large-file.bin "$image_dir/extended.erofs" |
|
|
cmp - "$source_dir/extended/large-file.bin"
|
|
dump.erofs --cat --path=/medium.dat "$image_dir/flat.erofs" |
|
|
cmp - "$source_dir/flat/medium.dat"
|
|
dump.erofs --cat --path=/tailpacked.dat "$image_dir/inline.erofs" |
|
|
cmp - "$source_dir/inline/tailpacked.dat"
|
|
|
|
(
|
|
cd "$output"
|
|
find source expected -type f -print0 | sort -z | xargs -0 sha256sum
|
|
) > "$output/SOURCE-SHA256SUMS"
|
|
(
|
|
cd "$output"
|
|
find source -type l -print | sort | while IFS= read -r path; do
|
|
printf '%s -> %s\n' "$path" "$(readlink "$path")"
|
|
done
|
|
find source -type p -printf '%p type=fifo\n'
|
|
for kind in block:b char:c; do
|
|
label=${kind%:*}
|
|
type=${kind#*:}
|
|
find source -type "$type" -print | sort | while IFS= read -r path; do
|
|
set -- $(stat -c '%t %T' "$path")
|
|
printf '%s type=%s major=%d minor=%d\n' \
|
|
"$path" "$label" "$((0x$1))" "$((0x$2))"
|
|
done
|
|
done
|
|
) > "$output/SOURCE-METADATA"
|
|
(
|
|
cd "$output"
|
|
sha256sum SOURCE-METADATA
|
|
) > "$output/SOURCE-METADATA.sha256"
|
|
|
|
cat "$image_dir/fixture-evidence.txt"
|
|
cat "$output/SOURCE-SHA256SUMS"
|
|
cat "$output/SOURCE-METADATA"
|
|
cat "$image_dir/IMAGE-SHA256SUMS"
|