diff --git a/filesystem/ext4/ext4.md b/filesystem/ext4/ext4.md index 2ecac96d..e8f57cb2 100644 --- a/filesystem/ext4/ext4.md +++ b/filesystem/ext4/ext4.md @@ -297,6 +297,12 @@ The conversion usually happens when a single entry will exceed the capacity of a 1. Find the data blocks for that inode, see [inode to data blocks](#inode-to-data-blocks). 1. Interpret the data blocks. +The extents describe only the blocks that are allocated, so they need not cover the whole file. When reading a logical byte range: + +* File blocks that no extent covers (the holes of a sparse file) read as zeros. +* Uninitialized extents (length field > 32768, see [inode to data blocks](#inode-to-data-blocks)) are allocated but were never written; they read as zeros and their disk blocks are not fetched. +* Extents must be sorted by file block and must not overlap. A mapping that violates this is treated as corrupt and the read fails instead of returning data from the wrong place. + ### Create File 1. Walk the tree until you find the inode for the parent directory. diff --git a/filesystem/ext4/file.go b/filesystem/ext4/file.go index d78ebdd0..85653f45 100644 --- a/filesystem/ext4/file.go +++ b/filesystem/ext4/file.go @@ -1,9 +1,11 @@ package ext4 import ( + "errors" "fmt" "io" "io/fs" + "math" "github.com/diskfs/go-diskfs/filesystem" ) @@ -32,70 +34,82 @@ func (fl *File) Read(b []byte) (int, error) { if fl.fileType == dirFileTypeDirectory { return 0, fmt.Errorf("cannot read directory") } - var ( - fileSize = int64(fl.size) - blocksize = uint64(fl.filesystem.superblock.blockSize) - ) + if fl.offset < 0 || fl.size > math.MaxInt64 { + return 0, fmt.Errorf("invalid ext4 file size or offset") + } + fileSize := int64(fl.size) if fl.offset >= fileSize { return 0, io.EOF } - - // Calculate the number of bytes to read - bytesToRead := int64(len(b)) - if fl.offset+bytesToRead > fileSize { - bytesToRead = fileSize - fl.offset + if len(b) == 0 { + return 0, nil } - - // Create a buffer to hold the bytes to be read - readBytes := int64(0) - b = b[:bytesToRead] - - // the offset given for reading is relative to the file, so we need to calculate - // where these are in the extents relative to the file - readStartBlock := uint64(fl.offset) / blocksize - for _, e := range fl.extents { - // if the last block of the extent is before the first block we want to read, skip it - // notice: need equal sign - if uint64(e.fileBlock)+uint64(e.count) <= readStartBlock { - continue + blockSize := int64(fl.filesystem.superblock.blockSize) + if blockSize < 1024 || blockSize > 65536 || blockSize&(blockSize-1) != 0 { + return 0, fmt.Errorf("invalid ext4 block size") + } + var previousEnd int64 + for _, extent := range fl.extents { + count := int64(extent.count) + if count > 32768 { + count -= 32768 } - // extentSize is the number of bytes on the disk for the extent - extentSize := int64(e.count) * int64(blocksize) - // where do we start and end in the extent? - startPositionInExtent := fl.offset - int64(e.fileBlock)*int64(blocksize) - - // Protect - if startPositionInExtent < 0 || startPositionInExtent > extentSize { - return int(readBytes), fmt.Errorf("read offset %d falls outside extent (fileBlock %d, count %d) of file %s", fl.offset, e.fileBlock, e.count, fl.filename) + start := int64(extent.fileBlock) * blockSize + end := start + count*blockSize + if count == 0 || start < previousEnd { + return 0, fmt.Errorf("invalid ext4 extent order or length") } - - leftInExtent := extentSize - startPositionInExtent - // how many bytes are left to read - toReadInOffset := bytesToRead - readBytes - if toReadInOffset > leftInExtent { - toReadInOffset = leftInExtent + if extent.count <= 32768 && (extent.startingBlock > uint64(math.MaxInt64)/uint64(blockSize) || + int64(extent.startingBlock)*blockSize > math.MaxInt64-count*blockSize) { + return 0, fmt.Errorf("ext4 extent address overflows") } - // read those bytes - startPosOnDisk := e.startingBlock*blocksize + uint64(startPositionInExtent) - b2 := make([]byte, toReadInOffset) - read, err := fl.filesystem.backend.ReadAt(b2, int64(startPosOnDisk)) - if err != nil { - return int(readBytes), fmt.Errorf("failed to read bytes: %v", err) + previousEnd = end + } + want := int64(len(b)) + if want > fileSize-fl.offset { + want = fileSize - fl.offset + } + start, end := fl.offset, fl.offset+want + clear(b[:want]) + for _, extent := range fl.extents { + count := int64(extent.count) + unwritten := count > 32768 + if unwritten { + count -= 32768 } - copy(b[readBytes:], b2[:read]) - readBytes += int64(read) - fl.offset += int64(read) - - if readBytes >= bytesToRead { + extentStart := int64(extent.fileBlock) * blockSize + extentEnd := extentStart + count*blockSize + if extentStart >= end { + // extents are validated to be sorted, so nothing further can overlap the window break } + overlapStart, overlapEnd := max(start, extentStart), min(end, extentEnd) + if overlapStart >= overlapEnd || unwritten { + continue + } + destination := b[overlapStart-start : overlapEnd-start] + physicalOffset := int64(extent.startingBlock)*blockSize + overlapStart - extentStart + n, err := fl.filesystem.backend.ReadAt(destination, physicalOffset) + if n < 0 || n > len(destination) { + fl.offset = overlapStart + return int(overlapStart - start), errors.Join(fmt.Errorf("ext4 backend returned invalid read count"), err) + } + if n != len(destination) { + err = errors.Join(io.ErrUnexpectedEOF, err) + } else if err == io.EOF { + // io.ReaderAt may report io.EOF together with a complete read at the end of the backend + err = nil + } + if err != nil { + fl.offset = overlapStart + int64(n) + return int(fl.offset - start), fmt.Errorf("failed to read extent bytes: %w", err) + } } - var err error - if fl.offset >= fileSize { - err = io.EOF + fl.offset = end + if end == fileSize { + return int(want), io.EOF } - - return int(readBytes), err + return int(want), nil } // Write writes len(b) bytes to the File. diff --git a/filesystem/ext4/file_sparse_read_test.go b/filesystem/ext4/file_sparse_read_test.go new file mode 100644 index 00000000..1288ed47 --- /dev/null +++ b/filesystem/ext4/file_sparse_read_test.go @@ -0,0 +1,405 @@ +package ext4 + +import ( + "bytes" + "errors" + "fmt" + "io" + "os" + "os/exec" + "path/filepath" + "testing" + + "github.com/diskfs/go-diskfs/backend" + backendfile "github.com/diskfs/go-diskfs/backend/file" +) + +const sparseTestBlock = 4096 + +func sparseReadFixture(t *testing.T, mapping extents, size int) (result *File, bytesOnDisk []byte) { + t.Helper() + data := make([]byte, 128*sparseTestBlock) + for i := range data { + data[i] = byte((i*17+29)%251 + 1) + } + name := filepath.Join(t.TempDir(), "backend.data") + if err := os.WriteFile(name, data, 0o600); err != nil { + t.Fatal(err) + } + f, err := os.Open(name) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { + if err := f.Close(); err != nil { + t.Error(err) + } + }) + model := &File{inode: &inode{size: uint64(size)}, filesystem: &FileSystem{superblock: &superblock{blockSize: sparseTestBlock}, backend: backendfile.New(f, true)}, extents: mapping, fileType: dirFileTypeRegular} + return model, data +} + +func sparseTestRead(t *testing.T, f *File, b []byte) (n int, err error) { + t.Helper() + defer func() { + if r := recover(); r != nil { + t.Fatalf("reader panicked on a valid or bounded diagnostic input: %v", r) + } + }() + return f.Read(b) +} + +func TestSparseReadContract(t *testing.T) { + cases := []struct { + name string + mapping extents + size int + expected func([]byte) []byte + }{ + {"dense", extents{{fileBlock: 0, startingBlock: 3, count: 2}}, 2 * sparseTestBlock, func(d []byte) []byte { return bytes.Clone(d[3*sparseTestBlock : 5*sparseTestBlock]) }}, + {"fragmented-no-hole", extents{{fileBlock: 0, startingBlock: 3, count: 1}, {fileBlock: 1, startingBlock: 8, count: 1}}, 2 * sparseTestBlock, func(d []byte) []byte { + return append(bytes.Clone(d[3*sparseTestBlock:4*sparseTestBlock]), d[8*sparseTestBlock:9*sparseTestBlock]...) + }}, + {"leading-hole", extents{{fileBlock: 2, startingBlock: 9, count: 1}}, 3 * sparseTestBlock, func(d []byte) []byte { + return append(make([]byte, 2*sparseTestBlock), d[9*sparseTestBlock:10*sparseTestBlock]...) + }}, + {"middle-hole", extents{{fileBlock: 0, startingBlock: 3, count: 1}, {fileBlock: 3, startingBlock: 8, count: 1}}, 4 * sparseTestBlock, func(d []byte) []byte { + return append(append(bytes.Clone(d[3*sparseTestBlock:4*sparseTestBlock]), make([]byte, 2*sparseTestBlock)...), d[8*sparseTestBlock:9*sparseTestBlock]...) + }}, + {"trailing-hole-partial-eof", extents{{fileBlock: 0, startingBlock: 3, count: 1}}, 3*sparseTestBlock + 17, func(d []byte) []byte { + return append(bytes.Clone(d[3*sparseTestBlock:4*sparseTestBlock]), make([]byte, 2*sparseTestBlock+17)...) + }}, + {"all-hole", nil, 2*sparseTestBlock + 3, func([]byte) []byte { return make([]byte, 2*sparseTestBlock+3) }}, + {"unwritten-not-physical-data", extents{{fileBlock: 0, startingBlock: 3, count: 32769}}, sparseTestBlock, func([]byte) []byte { return make([]byte, sparseTestBlock) }}, + {"initialized-32768-boundary", extents{{fileBlock: 0, startingBlock: 3, count: 32768}}, sparseTestBlock, func(d []byte) []byte { return bytes.Clone(d[3*sparseTestBlock : 4*sparseTestBlock]) }}, + {"real-libseccomp-layout", extents{{fileBlock: 0, startingBlock: 3, count: 42}, {fileBlock: 47, startingBlock: 45, count: 2}}, 199128, func(d []byte) []byte { + want := make([]byte, 199128) + copy(want[:42*sparseTestBlock], d[3*sparseTestBlock:45*sparseTestBlock]) + copy(want[47*sparseTestBlock:], d[45*sparseTestBlock:]) + return want + }}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + f, data := sparseReadFixture(t, tc.mapping, tc.size) + want := tc.expected(data) + if len(want) != tc.size { + t.Fatal("invalid test oracle length") + } + for _, chunk := range []int{1, 7, 511, 4096, 4097, tc.size + 17} { + if _, err := f.Seek(0, io.SeekStart); err != nil { + t.Fatal(err) + } + var got []byte + for len(got) < tc.size { + b := bytes.Repeat([]byte{0xdd}, chunk) + n, err := sparseTestRead(t, f, b) + if n <= 0 || n > len(b) { + t.Fatalf("no progress or invalid count: n=%d err=%v", n, err) + } + got = append(got, b[:n]...) + if err != nil { + if err != io.EOF || len(got) != tc.size { + t.Fatalf("early read error: n=%d err=%v", n, err) + } + break + } + } + if !bytes.Equal(got, want) { + t.Fatalf("sparse read content mismatch: chunk=%d", chunk) + } + if n, err := f.Read(make([]byte, 1)); n != 0 || err != io.EOF { + t.Fatalf("EOF: n=%d err=%v", n, err) + } + if n, err := f.Read(nil); n != 0 || err != io.EOF { + t.Fatalf("zero read at EOF: n=%d err=%v", n, err) + } + } + for _, offset := range []int64{0, 1, 4095, 4096, 8191, 8192, 172031, 172032, 192511, 192512, int64(tc.size) - 1, int64(tc.size)} { + if offset < 0 || offset > int64(tc.size) { + continue + } + if _, err := f.Seek(offset, io.SeekStart); err != nil { + t.Fatal(err) + } + b := bytes.Repeat([]byte{0xcc}, 4097) + n, err := sparseTestRead(t, f, b) + end := min(tc.size, int(offset)+len(b)) + if n != end-int(offset) || !bytes.Equal(b[:n], want[offset:int64(end)]) { + t.Fatalf("seeked content mismatch at %d: n=%d err=%v", offset, n, err) + } + if end == tc.size && err != io.EOF || end < tc.size && err != nil { + t.Fatalf("seeked EOF mismatch: %v", err) + } + } + }) + } +} + +type sparseFaultStorage struct { + backend.Storage + count int + fault error + calls int +} + +func (s *sparseFaultStorage) ReadAt(b []byte, off int64) (int, error) { + s.calls++ + n := s.count + if n >= 0 && n <= len(b) { + if _, err := s.Storage.ReadAt(b[:n], off); err != nil { + return 0, err + } + } + return n, s.fault +} + +func TestSparseReadBackendFailures(t *testing.T) { + marker := errors.New("backend-fault") + for _, tc := range []struct { + name string + n int + fault, errorWant error + }{ + {"short-nil", 3, nil, io.ErrUnexpectedEOF}, + {"short-eof", 3, io.EOF, io.ErrUnexpectedEOF}, + {"short-other", 3, marker, marker}, + {"short-joined-eof", 3, errors.Join(io.EOF, marker), marker}, + {"negative-count-with-error", -1, marker, marker}, + {"oversized-count-with-error", sparseTestBlock + 1, marker, marker}, + {"full-count-with-joined-error", sparseTestBlock, errors.Join(io.EOF, marker), marker}, + {"negative-count", -1, nil, nil}, + {"oversized-count", sparseTestBlock + 1, nil, nil}, + {"full-count-with-error", sparseTestBlock, marker, marker}, + } { + t.Run(tc.name, func(t *testing.T) { + f, data := sparseReadFixture(t, extents{{fileBlock: 2, startingBlock: 3, count: 1}}, 3*sparseTestBlock) + injected := &sparseFaultStorage{Storage: f.filesystem.backend, count: tc.n, fault: tc.fault} + f.filesystem.backend = injected + b := bytes.Repeat([]byte{0xaa}, 3*sparseTestBlock) + n, err := sparseTestRead(t, f, b) + wantN := 2 * sparseTestBlock + if tc.n >= 0 && tc.n <= sparseTestBlock { + wantN += tc.n + } + if n != wantN || f.offset != int64(wantN) || err == nil { + t.Fatalf("invalid prefix/error/offset: n=%d offset=%d error=%v", n, f.offset, err) + } + if tc.errorWant != nil && !errors.Is(err, tc.errorWant) { + t.Fatalf("backend error lost: %v", err) + } + if !bytes.Equal(b[:2*sparseTestBlock], make([]byte, 2*sparseTestBlock)) { + t.Fatal("preceding hole not zero") + } + if tc.n > 0 && tc.n <= sparseTestBlock && !bytes.Equal(b[2*sparseTestBlock:wantN], data[3*sparseTestBlock:3*sparseTestBlock+tc.n]) { + t.Fatal("short-read prefix differs") + } + if injected.calls != 1 { + t.Fatalf("backend called %d times", injected.calls) + } + }) + } +} + +func TestSparseReadInvalidMapping(t *testing.T) { + for name, mapping := range map[string]extents{ + "zero-length": {{fileBlock: 0, startingBlock: 3, count: 0}}, + "overlap": {{fileBlock: 0, startingBlock: 3, count: 2}, {fileBlock: 1, startingBlock: 8, count: 1}}, + "unsorted": {{fileBlock: 2, startingBlock: 3, count: 1}, {fileBlock: 0, startingBlock: 8, count: 1}}, + "physical-overflow": {{fileBlock: 0, startingBlock: ^uint64(0), count: 1}}, + } { + t.Run(name, func(t *testing.T) { + f, _ := sparseReadFixture(t, mapping, 4*sparseTestBlock) + if n, err := sparseTestRead(t, f, make([]byte, sparseTestBlock)); n != 0 || err == nil || f.offset != 0 { + t.Fatalf("invalid mapping was admitted: n=%d err=%v offset=%d", n, err, f.offset) + } + }) + } +} + +func TestSparseReadDoesNotFetchHoles(t *testing.T) { + f, _ := sparseReadFixture(t, extents{{fileBlock: 0, startingBlock: 3, count: 32770}}, 2*sparseTestBlock) + injected := &sparseFaultStorage{Storage: f.filesystem.backend, count: 0, fault: fmt.Errorf("must-not-read")} + f.filesystem.backend = injected + b := bytes.Repeat([]byte{0xff}, 2*sparseTestBlock) + if n, err := sparseTestRead(t, f, b); n != len(b) || err != io.EOF || injected.calls != 0 || !bytes.Equal(b, make([]byte, len(b))) { + t.Fatalf("unwritten extent fetched or not cleared: n=%d err=%v calls=%d", n, err, injected.calls) + } +} + +func TestSparseReadFailureAfterInitializedData(t *testing.T) { + f, data := sparseReadFixture(t, extents{{fileBlock: 0, startingBlock: 3, count: 1}, {fileBlock: 2, startingBlock: 8, count: 1}}, 3*sparseTestBlock) + fault := &sparseSecondReadFault{Storage: f.filesystem.backend} + f.filesystem.backend = fault + b := bytes.Repeat([]byte{0xaa}, 3*sparseTestBlock) + n, err := sparseTestRead(t, f, b) + wantN := 2*sparseTestBlock + 3 + if n != wantN || f.offset != int64(wantN) || !errors.Is(err, io.ErrUnexpectedEOF) || fault.calls != 2 { + t.Fatalf("prior data prefix/offset/error lost: n=%d offset=%d err=%v calls=%d", n, f.offset, err, fault.calls) + } + if !bytes.Equal(b[:sparseTestBlock], data[3*sparseTestBlock:4*sparseTestBlock]) || !bytes.Equal(b[sparseTestBlock:2*sparseTestBlock], make([]byte, sparseTestBlock)) || !bytes.Equal(b[2*sparseTestBlock:n], data[8*sparseTestBlock:8*sparseTestBlock+3]) { + t.Fatal("prior data, hole or short suffix differs") + } +} + +type sparseSecondReadFault struct { + backend.Storage + calls int +} + +func (s *sparseSecondReadFault) ReadAt(b []byte, off int64) (int, error) { + s.calls++ + if s.calls == 1 { + return s.Storage.ReadAt(b, off) + } + n, err := s.Storage.ReadAt(b[:3], off) + if err != nil { + return n, err + } + return n, io.EOF +} + +func TestSparseReadAcceptsEOFWithFullRead(t *testing.T) { + f, data := sparseReadFixture(t, extents{{fileBlock: 2, startingBlock: 3, count: 1}}, 4*sparseTestBlock) + injected := &sparseFaultStorage{Storage: f.filesystem.backend, count: sparseTestBlock, fault: io.EOF} + f.filesystem.backend = injected + b := bytes.Repeat([]byte{0xaa}, 3*sparseTestBlock) + n, err := sparseTestRead(t, f, b) + if n != len(b) || err != nil || f.offset != int64(len(b)) || injected.calls != 1 { + t.Fatalf("complete read reported with io.EOF was rejected: n=%d err=%v offset=%d calls=%d", n, err, f.offset, injected.calls) + } + if !bytes.Equal(b[:2*sparseTestBlock], make([]byte, 2*sparseTestBlock)) || !bytes.Equal(b[2*sparseTestBlock:], data[3*sparseTestBlock:4*sparseTestBlock]) { + t.Fatal("hole or extent content differs") + } +} + +const ( + mkfsSparseBlock = 4096 + mkfsSparseImageSize = 16 * 1024 * 1024 +) + +// mkfsSparseFixture builds an ext4 image with mkfs.ext4 -d from a sparse source file and +// adds an unwritten extent with debugfs. Logical layout in blocks: [0,2) data, [2,5) hole, +// [5,6) data, [6,8) unwritten, [8,9) hole; the size ends mid-block. It skips the test when +// the e2fsprogs tools are not installed. +func mkfsSparseFixture(t *testing.T) (image string, want []byte) { + t.Helper() + for _, tool := range []string{"mkfs.ext4", "debugfs", "e2fsck"} { + if _, err := exec.LookPath(tool); err != nil { + t.Skipf("skipping real-image sparse test: %v", err) + } + } + want = make([]byte, 9*mkfsSparseBlock-100) + for i := 0; i < 2*mkfsSparseBlock; i++ { + want[i] = byte(i*7 + 1) // no all-zero block, or mke2fs would turn it into a hole + } + for i := 5 * mkfsSparseBlock; i < 6*mkfsSparseBlock; i++ { + want[i] = byte(i*13 + 3) + } + dir := t.TempDir() + source := filepath.Join(dir, "root") + if err := os.Mkdir(source, 0o755); err != nil { + t.Fatal(err) + } + sf, err := os.Create(filepath.Join(source, "sparse.dat")) + if err != nil { + t.Fatal(err) + } + for _, chunk := range []struct{ start, end int }{{0, 2 * mkfsSparseBlock}, {5 * mkfsSparseBlock, 6 * mkfsSparseBlock}} { + if _, err := sf.WriteAt(want[chunk.start:chunk.end], int64(chunk.start)); err != nil { + t.Fatal(err) + } + } + if err := sf.Truncate(int64(len(want))); err != nil { + t.Fatal(err) + } + if err := sf.Close(); err != nil { + t.Fatal(err) + } + image = filepath.Join(dir, "sparse.img") + if err := os.WriteFile(image, nil, 0o600); err != nil { + t.Fatal(err) + } + if err := os.Truncate(image, mkfsSparseImageSize); err != nil { + t.Fatal(err) + } + runE2fsTool(t, exec.Command("mkfs.ext4", "-q", "-F", "-b", "4096", "-d", source, image)) + runE2fsTool(t, exec.Command("debugfs", "-w", "-R", "fallocate /sparse.dat 6 7", image)) + runE2fsTool(t, exec.Command("e2fsck", "-f", "-n", image)) + return image, want +} + +func runE2fsTool(t *testing.T, cmd *exec.Cmd) { + t.Helper() + if out, err := cmd.CombinedOutput(); err != nil { + t.Fatalf("%v: %v\n%s", cmd.Args, err, out) + } +} + +// garbleUnwrittenExtents overwrites the disk blocks of every unwritten extent with garbage, +// so that only a reader that skips them returns zeros there, and reports how many holes and +// unwritten extents the mapping has. +func garbleUnwrittenExtents(t *testing.T, image *os.File, mapping extents) (holes, unwritten int) { + t.Helper() + var previousEnd uint64 + for _, e := range mapping { + if uint64(e.fileBlock) > previousEnd { + holes++ + } + count := uint64(e.count) + if count > 32768 { + count -= 32768 + unwritten++ + if _, err := image.WriteAt(bytes.Repeat([]byte{0x5a}, int(count)*mkfsSparseBlock), int64(e.startingBlock)*mkfsSparseBlock); err != nil { + t.Fatal(err) + } + } + previousEnd = uint64(e.fileBlock) + count + } + return holes, unwritten +} + +// TestSparseReadFromMkfsImage reads a real sparse file through the extent parser and Read. +func TestSparseReadFromMkfsImage(t *testing.T) { + image, want := mkfsSparseFixture(t) + f, err := os.OpenFile(image, os.O_RDWR, 0) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { + if err := f.Close(); err != nil { + t.Error(err) + } + }) + fs, err := Read(backendfile.New(f, true), mkfsSparseImageSize, 0, 512) + if err != nil { + t.Fatal(err) + } + opened, err := fs.OpenFile("/sparse.dat", os.O_RDONLY) + if err != nil { + t.Fatal(err) + } + file, ok := opened.(*File) + if !ok { + t.Fatalf("unexpected file type %T", opened) + } + // the fixture must really contain a hole and an unwritten extent, or this test proves nothing + if holes, unwritten := garbleUnwrittenExtents(t, f, file.extents); holes == 0 || unwritten == 0 { + t.Fatalf("fixture is not sparse: extents=%+v holes=%d unwritten=%d", file.extents, holes, unwritten) + } + got, err := io.ReadAll(opened) + if err != nil { + t.Fatal(err) + } + if !bytes.Equal(got, want) { + t.Fatalf("sparse file content mismatch: len=%d want=%d extents=%+v", len(got), len(want), file.extents) + } + // a read that starts inside the hole, crosses the data block and ends inside the unwritten extent + if _, err := opened.Seek(3*mkfsSparseBlock+5, io.SeekStart); err != nil { + t.Fatal(err) + } + b := bytes.Repeat([]byte{0xcc}, 3*mkfsSparseBlock) + if n, err := opened.Read(b); n != len(b) || err != nil || !bytes.Equal(b, want[3*mkfsSparseBlock+5:6*mkfsSparseBlock+5]) { + t.Fatalf("read across hole/data/unwritten boundaries: n=%d err=%v", n, err) + } +}