db: don't inject GetDiskUsage errors in TestIteratorErrors

Add a more general `OpKindIn` errorfs predicate and use it to disable
errors in `GetDiskUsage` (which causes a background error to be
reported, which causes a test failure).

Author: RaduBerinde

error_test.go

@@ -360,7 +360,7 @@ func TestDBWALRotationCrash(t *testing.T) {
 	var crashFS *vfs.MemFS
 	var index atomic.Int32
 	inj := errorfs.InjectorFunc(func(op errorfs.Op) error {
-		if op.Kind.ReadOrWrite() == errorfs.OpIsWrite && index.Add(-1) == -1 {
+		if op.Kind.IsWrite() && index.Add(-1) == -1 {
 			crashFS = memfs.CrashClone(vfs.CrashCloneCfg{UnsyncedDataPercent: 0})
 		}
 		return nil
@@ -435,7 +435,7 @@ func TestDBCompactionCrash(t *testing.T) {
 	mkFS := func() vfs.FS {
 		memfs := vfs.NewCrashableMem()
 		inj := errorfs.InjectorFunc(func(op errorfs.Op) error {
-			if op.Kind.ReadOrWrite() == errorfs.OpIsWrite && crashIndex.Add(-1) == -1 {
+			if op.Kind.IsWrite() && crashIndex.Add(-1) == -1 {
 				// Allow an arbitrary subset of non-synced state to survive beyond the
 				// crash point.
 				crashFS = memfs.CrashClone(vfs.CrashCloneCfg{UnsyncedDataPercent: 10, RNG: crashRNG})

external_test.go

@@ -73,7 +73,10 @@ func TestIteratorErrors(t *testing.T) {
 		// Wrap it in both a counter and a toggle so that we a) know whether an
 		// error was injected over the course of an operation, and b) so that we
 		// can disable error injection during Open.
-		predicate := errorfs.And(errorfs.Reads, errorfs.Randomly(0.50, seed))
+		predicate := errorfs.And(
+			errorfs.OpKindIn("ReadsExceptGetDiskUsage", errorfs.ReadOps.Minus(errorfs.OpGetDiskUsage)),
+			errorfs.Randomly(0.50, seed),
+		)
 		counter := errorfs.Counter{Injector: errorfs.ErrInjected.If(predicate)}
 		toggle := errorfs.Toggle{Injector: &counter}
 		testOpts.Opts.FS = errorfs.Wrap(testOpts.Opts.FS, &toggle)
@@ -82,6 +85,8 @@ func TestIteratorErrors(t *testing.T) {
 		var logBuf bytes.Buffer
 		defer func() {
 			if t.Failed() {
+				// TODO(radu): we don't close the db, which could be emitting a log
+				// right now, causing a race here.
 				t.Log(logBuf.String())
 			}
 		}()

vfs/errorfs/dsl.go

@@ -25,6 +25,11 @@ func And(operands ...Predicate) Predicate {
 	return dsl.And[Op](operands...)
 }
 
+// Not returns a predicate that evaluates to true if the operand evaluates to false.
+func Not(operand Predicate) Predicate {
+	return dsl.Not[Op](operand)
+}
+
 // PathMatch returns a predicate that returns true if an operation's file path
 // matches the provided pattern according to filepath.Match.
 func PathMatch(pattern string) Predicate {
@@ -52,16 +57,25 @@ func (pm *pathMatch) Evaluate(op Op) bool {
 var (
 	// Reads is a predicate that returns true iff an operation is a read
 	// operation.
-	Reads Predicate = opKindPred{kind: OpIsRead}
+	Reads Predicate = OpKindIn("Reads", ReadOps)
 	// Writes is a predicate that returns true iff an operation is a write
 	// operation.
-	Writes Predicate = opKindPred{kind: OpIsWrite}
+	Writes Predicate = OpKindIn("Writes", WriteOps)
 )
 
-type opFileWrite struct{}
+// OpKindIn returns a predicate that evaluates to true if an operation's kind is
+// in the given set.
+func OpKindIn(desc string, kinds OpKinds) Predicate {
+	return opKindPred{desc: desc, kinds: kinds}
+}
+
+type opKindPred struct {
+	desc  string
+	kinds OpKinds
+}
 
-func (o opFileWrite) String() string      { return "OpFileWrite" }
-func (o opFileWrite) Evaluate(op Op) bool { return op.Kind == OpFileWrite }
+func (p opKindPred) String() string      { return p.desc }
+func (p opKindPred) Evaluate(op Op) bool { return p.kinds.Contains(op.Kind) }
 
 type opFileReadAt struct {
 	// offset configures the predicate to evaluate to true only if the
@@ -77,13 +91,6 @@ func (o *opFileReadAt) Evaluate(op Op) bool {
 	return op.Kind == OpFileReadAt && o.offset == op.Offset
 }
 
-type opKindPred struct {
-	kind OpReadWrite
-}
-
-func (p opKindPred) String() string      { return p.kind.String() }
-func (p opKindPred) Evaluate(op Op) bool { return p.kind == op.Kind.ReadOrWrite() }
-
 // Randomly constructs a new predicate that pseudorandomly evaluates to true
 // with probability p using randomness determinstically derived from seed.
 //
@@ -172,7 +179,7 @@ func NewParser() *Parser {
 	}
 	p.predicates.DefineConstant("Reads", func() dsl.Predicate[Op] { return Reads })
 	p.predicates.DefineConstant("Writes", func() dsl.Predicate[Op] { return Writes })
-	p.predicates.DefineConstant("OpFileWrite", func() dsl.Predicate[Op] { return opFileWrite{} })
+	p.predicates.DefineConstant("OpFileWrite", func() dsl.Predicate[Op] { return OpKindIn("OpFileWrite", MakeOpKinds(OpFileWrite)) })
 	p.predicates.DefineFunc("PathMatch",
 		func(p *dsl.Parser[dsl.Predicate[Op]], s *dsl.Scanner) dsl.Predicate[Op] {
 			pattern := s.ConsumeString()

vfs/errorfs/errorfs.go

@@ -87,40 +87,52 @@ const (
 	OpFileSyncTo
 	// OpFileFlush describes a file flush operation.
 	OpFileFlush
+
+	numOpKinds
 )
 
-// ReadOrWrite returns the operation's kind.
-func (o OpKind) ReadOrWrite() OpReadWrite {
-	switch o {
-	case OpOpen, OpOpenDir, OpList, OpStat, OpGetDiskUsage, OpFileRead, OpFileReadAt, OpFileStat:
-		return OpIsRead
-	case OpCreate, OpLink, OpRemove, OpRemoveAll, OpRename, OpReuseForWrite, OpMkdirAll, OpLock, OpFileClose, OpFileWrite, OpFileWriteAt, OpFileSync, OpFileSyncData, OpFileSyncTo, OpFileFlush, OpFilePreallocate:
-		return OpIsWrite
-	default:
-		panic(fmt.Sprintf("unrecognized op %v\n", o))
+func (o OpKind) IsRead() bool {
+	if o < 0 || o >= numOpKinds {
+		panic(fmt.Sprintf("invalid op kind: %d", o))
 	}
+	return ReadOps.Contains(o)
 }
 
-// OpReadWrite is an enum describing whether an operation is a read or write
-// operation.
-type OpReadWrite int
+func (o OpKind) IsWrite() bool {
+	if o < 0 || o >= numOpKinds {
+		panic(fmt.Sprintf("invalid op kind: %d", o))
+	}
+	return WriteOps.Contains(o)
+}
 
-const (
-	// OpIsRead describes read operations.
-	OpIsRead OpReadWrite = iota
-	// OpIsWrite describes write operations.
-	OpIsWrite
-)
+// OpKinds represents a set of OpKind values.
+type OpKinds uint64
 
-// String implements fmt.Stringer.
-func (kind OpReadWrite) String() string {
-	switch kind {
-	case OpIsRead:
-		return "Reads"
-	case OpIsWrite:
-		return "Writes"
-	default:
-		panic(fmt.Sprintf("unrecognized OpKind %d", kind))
+func MakeOpKinds(kinds ...OpKind) OpKinds {
+	var res OpKinds
+	for _, kind := range kinds {
+		res |= OpKinds(1) << kind
+	}
+	return res
+}
+
+func (k OpKinds) Minus(kind ...OpKind) OpKinds {
+	return k &^ MakeOpKinds(kind...)
+}
+
+func (k OpKinds) Contains(kind OpKind) bool {
+	return k&(OpKinds(1)<<kind) != 0
+}
+
+var ReadOps = MakeOpKinds(OpOpen, OpOpenDir, OpList, OpStat, OpGetDiskUsage, OpFileRead, OpFileReadAt, OpFileStat)
+var WriteOps = MakeOpKinds(OpCreate, OpLink, OpRemove, OpRemoveAll, OpRename, OpReuseForWrite, OpMkdirAll, OpLock, OpFileClose, OpFileWrite, OpFileWriteAt, OpFileSync, OpFileSyncData, OpFileSyncTo, OpFileFlush, OpFilePreallocate)
+
+func init() {
+	if ReadOps&WriteOps != 0 {
+		panic("some op is both read and write")
+	}
+	if ReadOps|WriteOps != (OpKinds(1)<<numOpKinds - 1) {
+		panic("some op is neither read nor write")
 	}
 }