tarconv: add strip whiteout mode for bottom layers

Signed-off-by: Derek McGowan <derek@mcg.dev>

Author: dmcgowan

tarconv/apply.go

@@ -18,7 +18,7 @@
 // via direct writer calls, without staging an intermediate fs.FS.
 //
 // The single entry point is [Apply]. It handles all tar entry types (regular
-// files, directories, symlinks, hard links, device nodes, FIFOs) and three
+// files, directories, symlinks, hard links, device nodes, FIFOs) and four
 // whiteout strategies selectable via options:
 //
 //   - Default (no option): translate AUFS/OCI whiteouts to overlayfs xattrs.
@@ -27,6 +27,9 @@
 //     Suitable for flat merged images where all layers are applied in sequence.
 //   - [WithPreserveWhiteouts]: keep .wh.* entries as plain files.
 //     Suitable for tooling that needs the raw tar content.
+//   - [WithStripWhiteouts]: drop .wh.* entries entirely.
+//     Suitable for the bottommost layer of a chain, where no lower layer
+//     exists for a whiteout to hide.
 //
 // Tar-index mode is enabled by creating the [erofs.Writer] with
 // [erofs.WithDataFile] pointing at a file that receives the raw tar bytes,
@@ -75,6 +78,9 @@ const (
 	whiteoutMerge
 	// whiteoutPreserve keeps whiteout entries as plain regular files.
 	whiteoutPreserve
+	// whiteoutStrip drops whiteout entries entirely: neither translated,
+	// preserved, nor acted on.
+	whiteoutStrip
 )
 
 // config holds the parsed options for an Apply call.
@@ -106,6 +112,15 @@ func WithPreserveWhiteouts() Option {
 	return func(c *config) { c.whiteouts = whiteoutPreserve }
 }
 
+// WithStripWhiteouts makes Apply drop .wh.* and .wh..wh..opq entries
+// entirely: they are neither translated to overlayfs representation nor
+// preserved as plain files. Use this for the bottommost layer of a chain,
+// where no lower layer exists for a whiteout to hide, so the whiteout
+// carries no meaning.
+func WithStripWhiteouts() Option {
+	return func(c *config) { c.whiteouts = whiteoutStrip }
+}
+
 // WithTarIndexData enables tar-index mode.
 //
 // In tar-index mode Apply does not copy file payload bytes into the EROFS
@@ -147,6 +162,7 @@ type pendingLink struct {
 //
 // Use [WithMerge] to resolve whiteouts structurally instead (flat merged image).
 // Use [WithPreserveWhiteouts] to keep whiteout entries as plain files.
+// Use [WithStripWhiteouts] to drop whiteout entries entirely.
 //
 // Hard links may appear in any order. Links whose targets have not yet appeared
 // are queued and resolved as subsequent entries are processed. An unresolved
@@ -212,6 +228,8 @@ func Apply(w *erofs.Writer, r io.Reader, opts ...Option) error {
 					if err := setOpaqueXattr(w, dir, hdr); err != nil {
 						return fmt.Errorf("tarconv: opaque %s: %w", dir, err)
 					}
+				case whiteoutStrip:
+					// Nothing below this layer to hide; drop the marker.
 				}
 			} else {
 				target := path.Join(dir, base[len(whiteoutPrefix):])
@@ -237,6 +255,8 @@ func Apply(w *erofs.Writer, r io.Reader, opts ...Option) error {
 						}
 						pendingOrigin[dir] = true
 					}
+				case whiteoutStrip:
+					// Nothing below this layer to hide; drop the marker.
 				}
 			}
 			// Drain any data bytes (whiteouts are zero-size in practice but be safe).

tarconv/convert_test.go

@@ -544,6 +544,52 @@ func TestConvertWhiteouts(t *testing.T) {
 	}
 }
 
+// TestStripWhiteouts checks that WithStripWhiteouts drops whiteout entries
+// entirely: no overlay char device, no opaque xattr, no origin xattr.
+func TestStripWhiteouts(t *testing.T) {
+	tarData := makeTar(t, func(tw *tar.Writer) {
+		tw.WriteHeader(&tar.Header{Typeflag: tar.TypeDir, Name: "lib/", Mode: 0o755, ModTime: epoch})
+		tw.WriteHeader(&tar.Header{Typeflag: tar.TypeReg, Name: "lib/.wh..wh..opq", Size: 0, ModTime: epoch})
+		tw.WriteHeader(&tar.Header{Typeflag: tar.TypeReg, Name: "lib/.wh.removed.so", Size: 0, ModTime: epoch})
+		tw.WriteHeader(&tar.Header{Typeflag: tar.TypeReg, Name: "lib/kept.so", Size: 4, Mode: 0o644, ModTime: epoch})
+		tw.Write([]byte("keep"))
+	})
+	out := &buf{}
+	w := erofs.Create(out)
+	if err := tarconv.Apply(w, bytes.NewReader(tarData), tarconv.WithStripWhiteouts()); err != nil {
+		t.Fatalf("Apply(WithStripWhiteouts): %v", err)
+	}
+	if err := w.Close(); err != nil {
+		t.Fatalf("Writer.Close: %v", err)
+	}
+	img := out.b
+	fsckImage(t, img)
+	fsys := openImage(t, img)
+
+	// Neither whiteout name should exist as an entry of any kind.
+	if _, err := fs.Stat(fsys, "lib/removed.so"); !errors.Is(err, fs.ErrNotExist) {
+		t.Errorf("lib/removed.so: expected ErrNotExist, got %v", err)
+	}
+	if _, err := fs.Stat(fsys, "lib/.wh.removed.so"); !errors.Is(err, fs.ErrNotExist) {
+		t.Errorf("lib/.wh.removed.so: expected ErrNotExist (not preserved), got %v", err)
+	}
+	if _, err := fs.Stat(fsys, "lib/.wh..wh..opq"); !errors.Is(err, fs.ErrNotExist) {
+		t.Errorf("lib/.wh..wh..opq: expected ErrNotExist (not preserved), got %v", err)
+	}
+
+	// lib itself should carry neither the opaque nor the origin xattr.
+	info := checkStat(t, fsys, "lib")
+	st := info.Sys().(*erofs.Stat)
+	if _, ok := st.Xattrs[overlayOpaqueXattr]; ok {
+		t.Errorf("lib: unexpected opaque xattr, xattrs=%v", st.Xattrs)
+	}
+	if _, ok := st.Xattrs["trusted.overlay.origin"]; ok {
+		t.Errorf("lib: unexpected trusted.overlay.origin, xattrs=%v", st.Xattrs)
+	}
+
+	checkFile(t, fsys, "lib/kept.so", "keep")
+}
+
 // TestConvertOpaqueBeforeDir tests that the opaque xattr is applied even when
 // the .wh..wh..opq entry appears before the directory entry itself.
 func TestConvertOpaqueBeforeDir(t *testing.T) {