Linux: Make copyFile sparse aware

Today the Linux impl just uses io.Copy which does not handle
sparse files, so they would be expanded to their full size.

Co-authored-by: Fabiano Fidêncio <ffidencio@nvidia.com>
Signed-off-by: Danny Canter <danny@dcantah.dev>

Author: dcantah

fs/copy_linux.go

@@ -26,6 +26,122 @@ import (
 	"golang.org/x/sys/unix"
 )
 
+// maxCopyChunk is the maximum size passed to copy_file_range per call,
+// avoiding int overflow on 32-bit architectures.
+const maxCopyChunk = 1 << 30 // 1 GiB
+
+// copyFile copies a file from source to target preserving sparse file holes.
+//
+// If the filesystem does not support SEEK_DATA/SEEK_HOLE, it falls back
+// to a plain io.Copy.
+func copyFile(target, source string) error {
+	src, err := os.Open(source)
+	if err != nil {
+		return fmt.Errorf("failed to open source %s: %w", source, err)
+	}
+	defer src.Close()
+
+	fi, err := src.Stat()
+	if err != nil {
+		return fmt.Errorf("failed to stat source %s: %w", source, err)
+	}
+	size := fi.Size()
+
+	tgt, err := os.Create(target)
+	if err != nil {
+		return fmt.Errorf("failed to open target %s: %w", target, err)
+	}
+	defer tgt.Close()
+
+	if err := tgt.Truncate(size); err != nil {
+		return fmt.Errorf("failed to truncate target %s: %w", target, err)
+	}
+
+	srcFd := int(src.Fd())
+
+	// Try a SEEK_DATA to check if the filesystem supports it.
+	// If not, fall back to a plain copy.
+	if _, err := unix.Seek(srcFd, 0, unix.SEEK_DATA); err != nil {
+		// ENXIO means no data in the file at all. In other words it's entirely sparse.
+		// The truncated target is already correct.
+		if errors.Is(err, syscall.ENXIO) {
+			return nil
+		}
+
+		if errors.Is(err, syscall.EOPNOTSUPP) || errors.Is(err, syscall.ENOTSUP) || errors.Is(err, syscall.EINVAL) {
+			// Filesystem doesn't support SEEK_DATA/SEEK_HOLE. Fall back to a plain copy.
+			src.Close()
+			tgt.Close()
+			return openAndCopyFile(target, source)
+		}
+
+		return fmt.Errorf("failed to seek data in source %s: %w", source, err)
+	}
+
+	// Copy data regions from source to target, skipping holes.
+	var offset int64
+	tgtFd := int(tgt.Fd())
+
+	for offset < size {
+		dataStart, err := unix.Seek(srcFd, offset, unix.SEEK_DATA)
+		if err != nil {
+			// No more data past offset. Remainder of file is a hole.
+			if errors.Is(err, syscall.ENXIO) {
+				break
+			}
+			return fmt.Errorf("SEEK_DATA failed at offset %d: %w", offset, err)
+		}
+
+		// Find the end of this data region (start of next hole).
+		holeStart, err := unix.Seek(srcFd, dataStart, unix.SEEK_HOLE)
+		if err != nil {
+			// ENXIO shouldn't happen after a successful SEEK_DATA, but
+			// treat it as data extending to end of file.
+			if errors.Is(err, syscall.ENXIO) {
+				holeStart = size
+			} else {
+				return fmt.Errorf("SEEK_HOLE failed at offset %d: %w", dataStart, err)
+			}
+		}
+
+		// Copy the data region [dataStart, holeStart).
+		srcOff := dataStart
+		tgtOff := dataStart
+		remain := holeStart - dataStart
+
+		for remain > 0 {
+			chunk := remain
+			if chunk > maxCopyChunk {
+				chunk = maxCopyChunk
+			}
+
+			n, err := unix.CopyFileRange(srcFd, &srcOff, tgtFd, &tgtOff, int(chunk), 0)
+			if err != nil {
+				// Fall back to a plain copy if copy_file_range is not supported
+				// across the source and target filesystems.
+				if errors.Is(err, syscall.EXDEV) || errors.Is(err, syscall.ENOSYS) || errors.Is(err, syscall.EOPNOTSUPP) {
+					src.Close()
+					tgt.Close()
+					return openAndCopyFile(target, source)
+				}
+				return fmt.Errorf("copy_file_range failed: %w", err)
+			}
+			if n == 0 {
+				return fmt.Errorf("copy_file_range returned 0 with %d bytes remaining", remain)
+			}
+			remain -= int64(n)
+		}
+
+		offset = holeStart
+	}
+
+	if err := tgt.Sync(); err != nil {
+		return fmt.Errorf("failed to sync target %s: %w", target, err)
+	}
+
+	return nil
+}
+
 func copyFileInfo(fi os.FileInfo, src, name string) error {
 	st := fi.Sys().(*syscall.Stat_t)
 	if err := os.Lchown(name, int(st.Uid), int(st.Gid)); err != nil {

fs/copy_linux_test.go

@@ -19,17 +19,115 @@
 package fs
 
 import (
+	"bytes"
 	"io"
 	"math/rand"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"syscall"
 	"testing"
 
 	"github.com/containerd/continuity/testutil"
 	"github.com/containerd/continuity/testutil/loopback"
 )
 
+func TestCopyFileSparse(t *testing.T) {
+	dir := t.TempDir()
+
+	type testCase struct {
+		name string
+		// parts alternates: data length, hole length, data length, ...
+		// A 0 data length at the start means the file begins with a hole.
+		parts []int64
+	}
+
+	tests := []testCase{
+		{
+			name:  "DataHoleData",
+			parts: []int64{4096, 1024 * 1024, 4096},
+		},
+		{
+			name:  "HoleOnly",
+			parts: []int64{0, 1024 * 1024, 1},
+		},
+		{
+			name:  "HoleAtStart",
+			parts: []int64{0, 1024 * 1024, 4096},
+		},
+		{
+			name:  "HoleAtEnd",
+			parts: []int64{4096, 1024 * 1024},
+		},
+		{
+			name:  "MultipleHoles",
+			parts: []int64{4096, 512 * 1024, 4096, 512 * 1024, 4096},
+		},
+		{
+			name:  "NoHoles",
+			parts: []int64{64 * 1024},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			srcPath := filepath.Join(dir, tc.name+"-src")
+			dstPath := filepath.Join(dir, tc.name+"-dst")
+
+			applier := createSparseFile(tc.name+"-src", 42, 0o644, tc.parts...)
+			if err := applier.Apply(dir); err != nil {
+				t.Fatal(err)
+			}
+
+			if err := CopyFile(dstPath, srcPath); err != nil {
+				t.Fatalf("CopyFile failed: %v", err)
+			}
+
+			// Verify content matches exactly.
+			srcData, err := os.ReadFile(srcPath)
+			if err != nil {
+				t.Fatal(err)
+			}
+			dstData, err := os.ReadFile(dstPath)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !bytes.Equal(srcData, dstData) {
+				t.Fatal("source and destination file contents differ")
+			}
+
+			// Verify sparseness is preserved: destination should not use
+			// significantly more blocks than the source.
+			srcStat, err := os.Stat(srcPath)
+			if err != nil {
+				t.Fatal(err)
+			}
+			dstStat, err := os.Stat(dstPath)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			srcBlocks := srcStat.Sys().(*syscall.Stat_t).Blocks
+			dstBlocks := dstStat.Sys().(*syscall.Stat_t).Blocks
+
+			t.Logf("src size=%d blocks=%d, dst size=%d blocks=%d",
+				srcStat.Size(), srcBlocks, dstStat.Size(), dstBlocks)
+
+			if srcStat.Size() != dstStat.Size() {
+				t.Fatalf("size mismatch: src=%d dst=%d", srcStat.Size(), dstStat.Size())
+			}
+
+			// Allow some slack for filesystem metadata, but destination
+			// should not use more than 10% extra blocks.
+			maxBlocks := srcBlocks + srcBlocks/10 + 8
+			if dstBlocks > maxBlocks {
+				t.Fatalf("destination is not sparse: src blocks=%d, dst blocks=%d (max allowed=%d)",
+					srcBlocks, dstBlocks, maxBlocks)
+			}
+		})
+	}
+}
+
 func TestCopyReflinkWithXFS(t *testing.T) {
 	testutil.RequiresRoot(t)
 	mnt := t.TempDir()

fs/copy_nondarwin.go

@@ -1,4 +1,4 @@
-//go:build !darwin
+//go:build !darwin && !linux
 
 /*
    Copyright The containerd Authors.