vfs: make Unwrap part of FS, fix metamorphic restart op

metamorphic/test.go

@@ -267,15 +267,28 @@ func (t *Test) minFMV() pebble.FormatMajorVersion {
 
 func (t *Test) restartDB(dbID objID) error {
 	db := t.getDB(dbID)
+	// If strictFS is not used, we use pebble.NoSync for writeOpts, so we can't
+	// restart the database (even if we don't revert to synced data).
 	if !t.testOpts.strictFS {
 		return nil
 	}
-	t.opts.Cache.Ref()
-	// The fs isn't necessarily a MemFS.
-	fs, ok := vfs.Root(t.opts.FS).(*vfs.MemFS)
-	if ok {
-		fs.SetIgnoreSyncs(true)
+	if t.testOpts.sharedStorageEnabled {
+		// We simulate a crash by essentially ignoring writes to disk after a
+		// certain point. However, we cannot prevent the process (which didn't
+		// actually crash) from deleting an external object before we call Close().
+		// TODO(radu): perhaps we want all syncs to fail after the "crash" point?
+		return nil
+	}
+	// We can't do this if we have more than one database since they share the
+	// same FS (and we only close/reopen one of them).
+	// TODO(radu): have each database use its own MemFS.
+	if len(t.dbs) > 1 {
+		return nil
 	}
+	t.opts.Cache.Ref()
+
+	memFS := vfs.Root(t.opts.FS).(*vfs.MemFS)
+	memFS.SetIgnoreSyncs(true)
 	if err := db.Close(); err != nil {
 		return err
 	}
@@ -287,10 +300,9 @@ func (t *Test) restartDB(dbID objID) error {
 			return err
 		}
 	}
-	if ok {
-		fs.ResetToSyncedState()
-		fs.SetIgnoreSyncs(false)
-	}
+
+	memFS.ResetToSyncedState()
+	memFS.SetIgnoreSyncs(false)
 
 	// TODO(jackson): Audit errorRate and ensure custom options' hooks semantics
 	// are well defined within the context of retries.

vfs/disk_health.go

@@ -581,6 +581,11 @@ func WithDiskHealthChecks(
 	return fs, fs
 }
 
+// Unwrap is part of the FS interface.
+func (d *diskHealthCheckingFS) Unwrap() FS {
+	return d.fs
+}
+
 // timeFilesystemOp executes the provided closure, which should perform a
 // singular filesystem operation of a type matching opType on the named file. It
 // records the provided start time such that the long-lived disk-health checking

vfs/disk_health_test.go

@@ -215,6 +215,8 @@ func (m mockFS) GetDiskUsage(path string) (DiskUsage, error) {
 	return m.getDiskUsage(path)
 }
 
+func (m mockFS) Unwrap() FS { return nil }
+
 var _ FS = &mockFS{}
 
 func TestDiskHealthChecking_WriteStatsCollector(t *testing.T) {

vfs/mem_fs.go

@@ -564,6 +564,9 @@ func (*MemFS) GetDiskUsage(string) (DiskUsage, error) {
 	return DiskUsage{}, ErrUnsupported
 }
 
+// Unwrap implements FS.Unwrap.
+func (*MemFS) Unwrap() FS { return nil }
+
 // memNode holds a file's data or a directory's children.
 type memNode struct {
 	isDir bool
@@ -721,6 +724,9 @@ func (f *memFile) Write(p []byte) (int, error) {
 			panic("stuff")
 		}
 	} else {
+		if grow := f.pos - len(f.n.mu.data); grow > 0 {
+			f.n.mu.data = append(f.n.mu.data, make([]byte, grow)...)
+		}
 		f.n.mu.data = append(f.n.mu.data[:f.pos], p...)
 	}
 	f.pos += len(p)

vfs/vfs.go

@@ -176,6 +176,13 @@ type FS interface {
 	// GetDiskUsage returns disk space statistics for the filesystem where
 	// path is any file or directory within that filesystem.
 	GetDiskUsage(path string) (DiskUsage, error)
+
+	// Unwrap is implemented by "wrapping" filesystems (those that add some
+	// functionality on top of an underlying FS); it returns the wrapped FS.
+	// It is used by vfs.Root.
+	//
+	// Returns nil if this is not a wrapping filesystem.
+	Unwrap() FS
 }
 
 // A DeviceID uniquely identifies a block device on which filesystem data is
@@ -344,6 +351,8 @@ func (defaultFS) PathDir(path string) string {
 	return filepath.Dir(path)
 }
 
+func (defaultFS) Unwrap() FS { return nil }
+
 type randomReadsOption struct{}
 
 // RandomReadsOption is an OpenOption that optimizes opened file handle for
@@ -444,18 +453,13 @@ func LinkOrCopy(fs FS, oldname, newname string) error {
 // Root returns the base FS implementation, unwrapping all nested FSs that
 // expose an Unwrap method.
 func Root(fs FS) FS {
-	type unwrapper interface {
-		Unwrap() FS
-	}
-
 	for {
-		u, ok := fs.(unwrapper)
-		if !ok {
-			break
+		n := fs.Unwrap()
+		if n == nil {
+			return fs
 		}
-		fs = u.Unwrap()
+		fs = n
 	}
-	return fs
 }
 
 // ErrUnsupported may be returned a FS when it does not support an operation.

vfs/vfstest/open_files.go

@@ -119,6 +119,8 @@ func (fs *openFilesFS) GetDiskUsage(path string) (vfs.DiskUsage, error) {
 	return fs.inner.GetDiskUsage(path)
 }
 
+func (fs *openFilesFS) Unwrap() vfs.FS { return fs.inner }
+
 func (fs *openFilesFS) wrapOpenFile(f vfs.File, err error) (vfs.File, error) {
 	if f == nil || err != nil {
 		return f, err