Do not prune when a backup misses an earlier mount point (closes #395)

snapshot create --prune purged the older snapshots holding a volume's
files when the volume, mounted below a configured path, was not
mounted: its empty mount point read as deleted files.

The scan now records in the local index each directory at or below a
configured path that the walk found an entry in and that, once listed,
is on a different device from its parent; listing mounts an
automounted volume. Under --prune, when an earlier snapshot of that
name recorded such a directory and this run does not, the run skips
the prune, keeps every older snapshot and exits non-zero, naming the
directory. For a volume retired on purpose, snapshot purge removes the
older snapshots.

Model: opus-5-5

README.md

@@ -337,15 +337,17 @@ value where a list belongs or a word where a number belongs), is refused.
   path that is empty on purpose out of the config, or remove the older
   snapshots by hand with `snapshot purge`. When an earlier snapshot of the
   same name in the local index found a volume mounted at or below a
-  configured path (a directory on a different filesystem from its parent)
+  configured path (a directory on a different filesystem from its parent,
-  and this backup finds none mounted there, the prune does not run either:
+  with an entry in it that the backup does not exclude) and this backup does
-  every older snapshot is kept, and the command names the directory and
+  not, the prune does not run either: every older snapshot is kept, and the
-  exits non-zero, on every run until the volume is mounted again. The same
+  command names the directory and exits non-zero, on every run until the
-  happens when that directory is no longer backed up, because it is excluded
+  volume is mounted again. A backup also does not find the volume when it
-  or its configured path was removed. If the volume was retired or the
+  finds no such entry in its directory, as when an automounted volume cannot
-  directory is no longer backed up on purpose, remove the older snapshots by
+  be mounted, or when that directory is no longer backed up, because it is
-  hand with `snapshot purge`. A file removed during the backup does not stop
+  excluded or its configured path was removed. If any of this is on purpose,
-  the prune.
+  as for a retired volume, remove the older snapshots by hand with
+  `snapshot purge`. A file removed during the backup does not stop the
+  prune.
 * `--keep-newer-than <duration>`: With `--prune`, keep snapshots newer than
   this duration instead of only the latest (e.g. `4w`, `30d`, `6mo`, `1y`).
   Without `--prune`, or with a value that is not a valid duration, the

TODO.md

@@ -30,7 +30,8 @@ owner's; a `v*` tag runs the release build in
   ([issue #395](https://git.eeqj.de/sneak/vaultik/issues/395)). Such a
   prune could delete every snapshot still holding the volume's files.
   Each snapshot now records in the local index the directories it found
-  on a different filesystem from their parent.
+  on a different filesystem from their parent and found an entry in that
+  the backup does not exclude.
 
 - 2026-10-14: Stopped `snapshot create --prune` pruning after a backup
   that found nothing in a configured path

docs/DATAMODEL.md

@@ -154,7 +154,7 @@ Maps snapshots to the blobs they reference.
 **Purpose:** Tracks blob dependencies for snapshots and enables manifest generation.
 
 ### 10. `snapshot_mount_points`
-The directories at or below a configured path that a snapshot's backup found on a different filesystem from their parent directory (a different device number), as a mount point is, the configured path itself included.
+The directories at or below a configured path, the configured path itself included, that a snapshot's backup found an entry in and, once it had listed them, found on a different filesystem from their parent directory (a different device number), as a mount point is. An automount point whose volume cannot be mounted is not recorded, because the backup finds no entry in it.
 
 **Columns:**
 - `snapshot_id` (TEXT) - Snapshot ID (FK to snapshots.id)
@@ -183,7 +183,7 @@ Tracks blob upload metrics.
    - `INSERT OR REPLACE INTO files` - Update file metadata
    - `SELECT * FROM files WHERE path = ?` - Check if file has changed
    - `INSERT INTO snapshot_files` - Add file to current snapshot
-   - `INSERT OR IGNORE INTO snapshot_mount_points` - Record each directory on a different filesystem from its parent
+   - `INSERT OR IGNORE INTO snapshot_mount_points` - Record each directory on a different filesystem from its parent that the walk found an entry in
 
 2. **Chunking** (for changed files)
    - `INSERT OR IGNORE INTO chunks` - Store new chunks

internal/database/schema/001.sql

@@ -125,7 +125,7 @@ CREATE INDEX IF NOT EXISTS idx_snapshot_blobs_blob_id ON snapshot_blobs(blob_id)
 
 -- Snapshot mount points table: the directories at or below a configured
 -- path that the snapshot's backup found on a different filesystem from
--- their parent directory, as a mount point is
+-- their parent directory, as a mount point is, and found an entry in
 CREATE TABLE IF NOT EXISTS snapshot_mount_points (
     snapshot_id TEXT NOT NULL,
     path TEXT NOT NULL,

internal/snapshot/mount_point_test.go

@@ -5,6 +5,8 @@ import (
 	"os"
 	"path/filepath"
 	"slices"
+	"strings"
+	"syscall"
 	"testing"
 
 	"github.com/spf13/afero"
@@ -15,9 +17,10 @@ import (
 )
 
 // A scan records with the snapshot each directory on a different device
-// from its parent directory, as a mount point is, the scanned path
+// from its parent directory that the walk found an entry in, as a mount
-// included. A filesystem that gives no device numbers, as the in-memory
+// point is, the scanned path included. A filesystem that gives no device
-// one, records none. See https://git.eeqj.de/sneak/vaultik/issues/395.
+// numbers, as the in-memory one, records none. See
+// https://git.eeqj.de/sneak/vaultik/issues/395.
 func TestScanRecordsMountPoints(t *testing.T) {
 	t.Parallel()
 
@@ -95,3 +98,148 @@ func TestScanRecordsMountPoints(t *testing.T) {
 		})
 	}
 }
+
+// automountFs is an in-memory filesystem with a volume at mountPoint
+// that is mounted on first access: opening mountPoint to list it mounts
+// the volume or, if it cannot be mounted, fails with "no such file or
+// directory", as with the autofs daemon. Stat records the device an
+// entry is on at that moment, as a real stat does: unmountedDevice for
+// mountPoint until the volume is mounted; the volume's, 2, for
+// mountPoint once it is and for everything in it; 1 for everything else.
+type automountFs struct {
+	afero.Fs
+
+	mountPoint      string
+	unmountedDevice uint64
+	canMount        bool
+	mounted         bool
+}
+
+//nolint:ireturn // afero.Fs.Open is defined to return the interface.
+func (fs *automountFs) Open(name string) (afero.File, error) {
+	if name == fs.mountPoint && !fs.canMount {
+		return nil, &os.PathError{Op: "open", Path: name, Err: syscall.ENOENT}
+	}
+
+	if name == fs.mountPoint {
+		fs.mounted = true
+	}
+
+	return fs.Fs.Open(name)
+}
+
+func (fs *automountFs) Stat(name string) (os.FileInfo, error) {
+	info, err := fs.Fs.Stat(name)
+	if err != nil {
+		return nil, err
+	}
+
+	device := uint64(1)
+
+	switch {
+	case name == fs.mountPoint && !fs.mounted:
+		device = fs.unmountedDevice
+	case name == fs.mountPoint || strings.HasPrefix(name, fs.mountPoint+"/"):
+		device = 2
+	}
+
+	return statWithDevice{FileInfo: info, device: device}, nil
+}
+
+// statWithDevice is an entry automountFs.Stat looked up, with the device
+// it was on then.
+type statWithDevice struct {
+	os.FileInfo
+
+	device uint64
+}
+
+// deviceAtLookup returns the device automountFs.Stat recorded for info.
+func deviceAtLookup(info os.FileInfo) (uint64, bool) {
+	stat, ok := info.(statWithDevice)
+
+	return stat.device, ok
+}
+
+// A volume mounted on first access is mounted when the walk lists its
+// mount point. Until then the mount point is on the automounter's own
+// device (a systemd automount) or on its parent's (an autofs map that
+// shows its mount points before mounting them). Either way only the
+// mount point is recorded, by the backup that mounts the volume and by a
+// later one that finds it mounted. Listing an automount point whose
+// volume cannot be mounted fails; it is not recorded, because the walk
+// finds no entry in it. See https://git.eeqj.de/sneak/vaultik/issues/395.
+func TestScanRecordsOnlyTheMountPointOfAnAutomountedVolume(t *testing.T) {
+	t.Parallel()
+
+	const scannedPath = "/data/source"
+
+	mountPoint := scannedPath + "/nas"
+
+	tests := []struct {
+		name            string
+		unmountedDevice uint64
+		canMount        bool
+		want            []string
+	}{
+		{
+			name:            "on the automounter's device until listed",
+			unmountedDevice: 3, canMount: true, want: []string{mountPoint},
+		},
+		{
+			name:            "on its parent's device until listed",
+			unmountedDevice: 1, canMount: true, want: []string{mountPoint},
+		},
+		{
+			name:            "volume that cannot be mounted",
+			unmountedDevice: 1, canMount: false, want: nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			ctx := context.Background()
+			fs := &automountFs{
+				Fs: afero.NewMemMapFs(), mountPoint: mountPoint,
+				unmountedDevice: tt.unmountedDevice, canMount: tt.canMount,
+			}
+
+			require.NoError(t, fs.MkdirAll(mountPoint+"/photos", 0o755))
+
+			for _, path := range []string{
+				scannedPath + "/notes.txt", mountPoint + "/photos/a.jpg",
+			} {
+				require.NoError(t, afero.WriteFile(fs, path, []byte(path), 0o644))
+			}
+
+			db, err := database.NewTestDB()
+			require.NoError(t, err)
+			t.Cleanup(func() { _ = db.Close() })
+
+			repos := database.NewRepositories(db)
+
+			for _, snapshotID := range []string{"first", "later"} {
+				createTestSnapshotRecord(ctx, t, repos, snapshotID)
+
+				scanner := snapshot.NewScanner(snapshot.ScannerConfig{
+					FS:               fs,
+					ChunkSize:        int64(1024 * 16),
+					Repositories:     repos,
+					MaxBlobSize:      int64(1024 * 1024),
+					CompressionLevel: 3,
+					AgeRecipients:    []string{testAgePublicKey},
+					DeviceNumber:     deviceAtLookup,
+				})
+
+				_, err = scanner.Scan(ctx, scannedPath, snapshotID)
+				require.NoError(t, err)
+
+				got, err := repos.Snapshots.GetMountPoints(ctx, snapshotID)
+				require.NoError(t, err)
+				assert.Equal(t, tt.want, got, "mount points of the %s backup", snapshotID)
+			}
+		})
+	}
+}

internal/snapshot/scanner.go

@@ -310,7 +310,7 @@ func (s *Scanner) Scan(
 		}
 	}
 
-	err = s.recordDirectories(ctx, scanResult.Directories)
+	err = s.recordDirectories(ctx, scanResult)
 	if err != nil {
 		return nil, err
 	}
@@ -888,6 +888,11 @@ type ScanPhaseResult struct {
 	FilesToProcess   []*FileToProcess
 	UnchangedFileIDs []types.FileID   // IDs of unchanged files to associate with snapshot
 	Directories      []*FileToProcess // Every directory found, to record
+	// MountPoints are the directories, the scanned path included, that
+	// the walk found an entry in and, once it had listed them, on a
+	// different device from their parent directory (see
+	// recordIfMountPoint).
+	MountPoints []string
 }
 
 // scanPhase performs the initial directory scan to identify files to process
@@ -907,7 +912,7 @@ func (s *Scanner) scanPhase(
 	// estimate leaves them out.
 	estimatedTotal := countNonDirectories(knownFiles)
 
-	collector := &scanCollector{}
+	collector := &scanCollector{dirsWithEntries: make(map[string]struct{})}
 
 	// Set up periodic status output
 	startTime := time.Now()
@@ -952,6 +957,8 @@ func (s *Scanner) scanPhase(
 			result.EntriesFound++
 		}
 
+		s.recordIfMountPoint(filePath, path, collector)
+
 		// Handle symlinks and directories
 		handled, err := s.recordSpecialEntry(
 			filePath, info, existingFiles, knownFiles, collector, result)
@@ -986,6 +993,7 @@ func (s *Scanner) scanPhase(
 		FilesToProcess:   collector.filesToProcess,
 		UnchangedFileIDs: collector.unchangedFileIDs,
 		Directories:      collector.directories,
+		MountPoints:      collector.mountPoints,
 	}, nil
 }
 
@@ -1112,6 +1120,29 @@ type scanCollector struct {
 	unchangedFileIDs []types.FileID // Just IDs - no new records needed
 	directories      []*FileToProcess
 	filesScanned     int64
+	// dirsWithEntries holds each directory the walk has found an entry in.
+	dirsWithEntries map[string]struct{}
+	mountPoints     []string
+}
+
+// firstEntryIn notes that the walk found an entry in directory dir and
+// reports whether it is the first one.
+func (c *scanCollector) firstEntryIn(dir string) bool {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	_, seen := c.dirsWithEntries[dir]
+	c.dirsWithEntries[dir] = struct{}{}
+
+	return !seen
+}
+
+// addMountPoint sets a mount point aside to be recorded.
+func (c *scanCollector) addMountPoint(dir string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.mountPoints = append(c.mountPoints, dir)
 }
 
 // addDirectory sets a directory aside to be recorded. It is not counted
@@ -1307,29 +1338,23 @@ func (s *Scanner) buildDirectoryEntry(path string, info os.FileInfo) *database.F
 // mount points (see recordMountPoints). A directory has no data to back
 // up, so it is not among the files counted and backed up.
 func (s *Scanner) recordDirectories(
-	ctx context.Context, directories []*FileToProcess,
+	ctx context.Context, scanned *ScanPhaseResult,
 ) error {
-	for _, dir := range directories {
+	for _, dir := range scanned.Directories {
 		err := s.recordNonRegularFile(ctx, dir)
 		if err != nil {
 			return fmt.Errorf("recording directory %s: %w", dir.Path, err)
 		}
 	}
 
-	return s.recordMountPoints(ctx, directories)
+	return s.recordMountPoints(ctx, scanned.MountPoints)
 }
 
-// recordMountPoints records with the snapshot each directory the walk
+// recordMountPoints records with the snapshot the mount points the walk
-// found on a different device from its parent directory, as a mount
+// found (see ScanPhaseResult.MountPoints).
-// point is, the scanned path included.
 func (s *Scanner) recordMountPoints(
-	ctx context.Context, directories []*FileToProcess,
+	ctx context.Context, mountPoints []string,
 ) error {
-	mountPoints, err := s.findMountPoints(directories)
-	if err != nil {
-		return err
-	}
-
 	return s.repos.WithTx(ctx, func(txCtx context.Context, tx *sql.Tx) error {
 		for _, dir := range mountPoints {
 			log.Info("Found a mount point", "path", dir)
@@ -1344,57 +1369,53 @@ func (s *Scanner) recordMountPoints(
 	})
 }
 
-// findMountPoints returns the directories, among those the walk found,
+// recordIfMountPoint sets the directory that holds entry, a path the
-// that are on a different device from their parent directory. The
+// walk found, aside to be recorded as a mount point if it is on a
-// scanned path is compared with the directory that holds it, which the
+// different device from its parent directory. The walk calls it for each
-// walk did not reach.
+// entry it finds, and it decides on the first entry in a directory, so a
-func (s *Scanner) findMountPoints(
+// directory the walk found no entry in is never recorded. By then the
-	directories []*FileToProcess,
+// walk has listed the directory, which mounts a volume mounted there on
-) ([]string, error) {
+// first access, so the directory and its parent are looked up again:
-	walked := make(map[string]os.FileInfo, len(directories))
+// before the listing, the directory can be on the automounter's own
-	for _, dir := range directories {
+// device (a systemd automount) or on its parent's (an autofs map that
-		walked[dir.Path] = dir.FileInfo
+// shows its mount points before mounting them). The scanned path is in
+// no listing the walk made, so it is skipped as an entry. A directory
+// that cannot be looked up then, or whose parent cannot, is not
+// recorded, so this snapshot does not stop the prune of a later backup
+// that misses its volume.
+func (s *Scanner) recordIfMountPoint(
+	entry, scannedPath string, collector *scanCollector,
+) {
+	dir := filepath.Dir(entry)
+
+	if entry == scannedPath || !collector.firstEntryIn(dir) {
+		return
 	}
 
-	var mountPoints []string
+	dirDevice, ok := s.deviceNumberAt(dir)
-
+	if !ok {
-	for _, dir := range directories {
+		return
-		parentPath := filepath.Dir(dir.Path)
-
-		parent, ok := walked[parentPath]
-		if !ok {
-			var err error
-
-			parent, err = s.fs.Stat(parentPath)
-			if err != nil {
-				return nil, fmt.Errorf(
-					"looking up the parent of %s: %w", dir.Path, err)
-			}
-		}
-
-		if s.onOtherDevice(dir.FileInfo, parent) {
-			mountPoints = append(mountPoints, dir.Path)
-		}
 	}
 
-	return mountPoints, nil
+	parentDevice, ok := s.deviceNumberAt(filepath.Dir(dir))
+	if ok && dirDevice != parentDevice {
+		collector.addMountPoint(dir)
+	}
 }
 
-// onOtherDevice reports whether dir is on a different device from
+// deviceNumberAt looks path up now and returns the number of the device
-// parent. A file whose device number cannot be read counts as on the
+// that holds it, and false when the lookup fails (logged) or gives no
-// same device as its parent.
+// device number.
-func (s *Scanner) onOtherDevice(dir, parent os.FileInfo) bool {
+func (s *Scanner) deviceNumberAt(path string) (uint64, bool) {
-	dirDevice, ok := s.deviceNumber(dir)
+	info, err := s.fs.Stat(path)
-	if !ok {
+	if err != nil {
-		return false
+		log.Warn("Could not look up a directory to check for a mount point",
+			"path", path, "error", err)
+
+		return 0, false
 	}
 
-	parentDevice, ok := s.deviceNumber(parent)
+	return s.deviceNumber(info)
-	if !ok {
-		return false
-	}
-
-	return dirDevice != parentDevice
 }
 
 // deviceNumberFromStat returns the number of the device that holds the

internal/vaultik/snapshot.go

@@ -56,11 +56,11 @@ var ErrSourcePathEmpty = errors.New("source path(s) were empty")
 // ErrVolumeNotMounted is returned when --prune skipped the post-backup
 // prune because a directory that an earlier snapshot of the same name
 // found as a mount point was not found as one in this run: the volume
-// mounted there is not mounted, or the directory is no longer backed up.
+// mounted there is not mounted, the run found no entry in it, or the
-// The snapshots are complete and kept, so the caller can report it apart
+// directory is no longer backed up. The snapshots are complete and
-// from a failed backup. A run that also skipped unreadable files or
+// kept, so the caller can report it apart from a failed backup. A run
-// found a configured path empty returns ErrFilesUnreadable or
+// that also skipped unreadable files or found a configured path empty
-// ErrSourcePathEmpty instead.
+// returns ErrFilesUnreadable or ErrSourcePathEmpty instead.
 var ErrVolumeNotMounted = errors.New(
 	"mount point(s) an earlier snapshot recorded were not found")
 
@@ -237,11 +237,11 @@ func (v *Vaultik) skipPostBackupPrune(
 	if len(unmountedPaths) > 0 {
 		v.UI.Warningf("Skipped the post-backup prune because this backup "+
 			"did not find a mount point at %s, where an earlier snapshot "+
-			"found one: either the volume is not mounted or the directory "+
+			"found one: the volume is not mounted, this backup found no "+
-			"is no longer backed up. Older snapshots are kept. Mount the "+
+			"entry in it, or the directory is no longer backed up. Older "+
-			"volume again, or, if the volume was retired or the directory "+
+			"snapshots are kept. Mount the volume again, or, if that is on "+
-			"is no longer backed up on purpose, remove the older snapshots "+
+			"purpose, remove the older snapshots by hand with "+
-			"by hand with 'vaultik snapshot purge'.",
+			"'vaultik snapshot purge'.",
 			strings.Join(unmountedPaths, ", "))
 	}
 

internal/vaultik/snapshot_prune_test.go

@@ -4,8 +4,10 @@ import (
 	"context"
 	"os"
 	"path/filepath"
+	"syscall"
 	"testing"
 
+	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"sneak.berlin/go/vaultik/internal/config"
@@ -261,15 +263,69 @@ func TestBackupWithNoEmptySourcePathPrunes(t *testing.T) {
 	}
 }
 
+// automountFs is the real filesystem with a volume at volumeDir that is
+// mounted on first access, as by an autofs map that shows its mount
+// points before mounting them: listing volumeDir mounts the volume or,
+// while cannotMount, fails with "no such file or directory".
+type automountFs struct {
+	afero.OsFs
+
+	volumeDir   string
+	cannotMount bool
+	mounted     bool
+}
+
+//nolint:ireturn // afero.Fs.Open is defined to return the interface.
+func (f *automountFs) Open(name string) (afero.File, error) {
+	if name == f.volumeDir && f.cannotMount {
+		return nil, &os.PathError{Op: "open", Path: name, Err: syscall.ENOENT}
+	}
+
+	if name == f.volumeDir {
+		f.mounted = true
+	}
+
+	return f.OsFs.Open(name)
+}
+
 // A backup under --prune in which a volume that an earlier snapshot found
-// mounted below the configured path is not mounted does not prune: run
+// mounted below the configured path is missing does not prune: run after
-// after run, the snapshot that holds the volume's files is kept with
+// run, the snapshot that holds the volume's files is kept with everything
-// everything it stored, and the run fails. Once the volume is mounted
+// it stored, and the run fails. Once the volume is back, the prune runs.
-// again, the prune runs. See https://git.eeqj.de/sneak/vaultik/issues/395.
+// The volume is mounted on first access and every backup starts with it
+// not mounted, so its directory is on its parent's device until the walk
+// lists it. While the volume is missing, its directory is left empty, or
+// listing it fails with "no such file or directory", as when an autofs
+// volume cannot be mounted, which the walk counts as a directory removed
+// during the backup. See https://git.eeqj.de/sneak/vaultik/issues/395.
 func TestBackupWithVolumeNotMountedDoesNotPrune(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 
+	tests := []struct {
+		name         string
+		listingFails bool
+	}{
+		{name: "directory left empty", listingFails: false},
+		{name: "listing fails", listingFails: true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			backUpWithVolumeNotMounted(t, tt.listingFails)
+		})
+	}
+}
+
+// backUpWithVolumeNotMounted runs the backups of
+// TestBackupWithVolumeNotMountedDoesNotPrune. While the volume is
+// missing, listing its directory fails if listingFails; otherwise the
+// directory is empty.
+func backUpWithVolumeNotMounted(t *testing.T, listingFails bool) {
+	t.Helper()
+
 	// volume is the directory, below the configured path, where the
 	// volume is mounted.
 	const (
@@ -282,20 +338,21 @@ func TestBackupWithVolumeNotMountedDoesNotPrune(t *testing.T) {
 		volume + "/a.txt": []byte("file a"),
 		"notes.txt":       []byte("notes"),
 	})
-	env.v.Config.Snapshots[snapshotName] = config.SnapshotConfig{
+	env.setSnapshot(snapshotName, "")
-		Paths: []string{env.src},
-	}
 	prune := &vaultik.SnapshotCreateOptions{
 		Prune: true, Snapshots: []string{snapshotName},
 	}
 
-	// While the volume is mounted, its directory is on a device of its
+	// The volume's directory is on the volume's device, 2, while the
-	// own.
+	// volume is mounted. Everything else is on device 1.
-	mounted := true
+	volumeDir := filepath.Join(env.src, volume)
+	fs := &automountFs{volumeDir: volumeDir}
 	newScanner := env.v.ScannerFactory
 	env.v.ScannerFactory = func(params snapshot.ScannerParams) *snapshot.Scanner {
+		fs.mounted = false
+		params.Fs = fs
 		params.DeviceNumber = func(info os.FileInfo) (uint64, bool) {
-			if mounted && info.Name() == volume {
+			if info.Name() == volume && fs.mounted {
 				return 2, true
 			}
 
@@ -311,13 +368,13 @@ func TestBackupWithVolumeNotMountedDoesNotPrune(t *testing.T) {
 	stored, err := env.v.Storage.List(ctx, "")
 	require.NoError(t, err)
 
-	// A volume that is not mounted leaves its mount point behind as an
+	// The volume goes missing.
-	// empty directory on its parent's device.
+	fs.cannotMount = listingFails
-	volumeDir := filepath.Join(env.src, volume)
-	require.NoError(t, os.RemoveAll(volumeDir))
-	require.NoError(t, os.Mkdir(volumeDir, 0o750))
 
-	mounted = false
+	if !listingFails {
+		require.NoError(t, os.RemoveAll(volumeDir))
+		require.NoError(t, os.Mkdir(volumeDir, 0o750))
+	}
 
 	for range 2 {
 		env.out.Reset()
@@ -342,12 +399,11 @@ func TestBackupWithVolumeNotMountedDoesNotPrune(t *testing.T) {
 		require.NoError(t, err, "%s is kept", key)
 	}
 
-	// The volume is mounted again.
+	// The volume is back.
+	fs.cannotMount = false
+
 	require.NoError(t, os.WriteFile(
 		filepath.Join(volumeDir, "a.txt"), []byte("file a"), 0o600))
-
-	mounted = true
-
 	require.NoError(t, env.v.CreateSnapshot(prune))
 
 	snapshots, err = env.v.Repositories.Snapshots.ListRecent(