lock MFS root in node

core/commands/files.go

@@ -9,6 +9,7 @@ import (
 	gopath "path"
 	"sort"
 	"strings"
+	"time"
 
 	humanize "github.com/dustin/go-humanize"
 	"github.com/ipfs/go-ipfs/core"
@@ -768,6 +769,8 @@ stat' on the file or any of its ancestors.
 		cmds.BoolOption(filesTruncateOptionName, "t", "Truncate the file to size zero before writing."),
 		cmds.Int64Option(filesCountOptionName, "n", "Maximum number of bytes to read."),
 		cmds.BoolOption(filesRawLeavesOptionName, "Use raw blocks for newly created leaf nodes. (experimental)"),
+		// FIXME: Fake lock for manual testing. Remove.
+		cmds.IntOption("lock-time", "lt", "[TESTING] timeout to hold the MFS lock while copying").WithDefault(0),
 		cidVersionOption,
 		hashOption,
 	},
@@ -792,20 +795,25 @@ stat' on the file or any of its ancestors.
 		if err != nil {
 			return err
 		}
+		filesRoot := nd.LockedFilesRoot.LockRoot()
+		defer nd.LockedFilesRoot.UnlockRoot()
+		// Keep the hold for a fake, arbitrary amount of time to test it manually.
+		timeout, _ := req.Options["lock-time"].(int)
+		defer time.Sleep(time.Duration(timeout) * time.Second)
 
 		offset, _ := req.Options[filesOffsetOptionName].(int64)
 		if offset < 0 {
 			return fmt.Errorf("cannot have negative write offset")
 		}
 
 		if mkParents {
-			err := ensureContainingDirectoryExists(nd.FilesRoot, path, prefix)
+			err := ensureContainingDirectoryExists(filesRoot, path, prefix)
 			if err != nil {
 				return err
 			}
 		}
 
-		fi, err := getFileHandle(nd.FilesRoot, path, create, prefix)
+		fi, err := getFileHandle(filesRoot, path, create, prefix)
 		if err != nil {
 			return err
 		}

core/core.go

@@ -82,6 +82,7 @@ type IpfsNode struct {
 	Reporter             *metrics.BandwidthCounter `optional:"true"`
 	Discovery            mdns.Service              `optional:"true"`
 	FilesRoot            *mfs.Root
+	LockedFilesRoot      *node.LockedFilesRoot
 	RecordValidator      record.Validator
 
 	// Online

core/corerepo/gc.go

@@ -84,7 +84,9 @@ func BestEffortRoots(filesRoot *mfs.Root) ([]cid.Cid, error) {
 }
 
 func GarbageCollect(n *core.IpfsNode, ctx context.Context) error {
-	roots, err := BestEffortRoots(n.FilesRoot)
+	filesRoot := n.LockedFilesRoot.LockRoot()
+	defer n.LockedFilesRoot.UnlockRoot()
+	roots, err := BestEffortRoots(filesRoot)
 	if err != nil {
 		return err
 	}
@@ -148,7 +150,9 @@ func (e *MultiError) Error() string {
 }
 
 func GarbageCollectAsync(n *core.IpfsNode, ctx context.Context) <-chan gc.Result {
-	roots, err := BestEffortRoots(n.FilesRoot)
+	filesRoot := n.LockedFilesRoot.LockRoot()
+	defer n.LockedFilesRoot.UnlockRoot()
+	roots, err := BestEffortRoots(filesRoot)
 	if err != nil {
 		out := make(chan gc.Result)
 		out <- gc.Result{Error: err}

core/node/core.go

@@ -3,6 +3,7 @@ package node
 import (
 	"context"
 	"fmt"
+	"sync"
 
 	"github.com/ipfs/go-blockservice"
 	"github.com/ipfs/go-cid"
@@ -168,3 +169,24 @@ func Files(mctx helpers.MetricsCtx, lc fx.Lifecycle, repo repo.Repo, dag format.
 
 	return root, err
 }
+
+func LockedFiles(mctx helpers.MetricsCtx, lc fx.Lifecycle, root *mfs.Root) (*LockedFilesRoot, error) {
+	return &LockedFilesRoot{
+		root: root,
+		lock: &sync.Mutex{},
+	}, nil
+}
+
+type LockedFilesRoot struct {
+	root *mfs.Root
+	lock *sync.Mutex
+}
+
+func (lfr *LockedFilesRoot) LockRoot() *mfs.Root {
+	lfr.lock.Lock()
+	return lfr.root
+}
+
+func (lfr *LockedFilesRoot) UnlockRoot() {
+	lfr.lock.Unlock()
+}

core/node/groups.go

@@ -296,6 +296,7 @@ var Core = fx.Options(
 	fx.Provide(FetcherConfig),
 	fx.Provide(Pinning),
 	fx.Provide(Files),
+	fx.Provide(LockedFiles),
 )
 
 func Networked(bcfg *BuildCfg, cfg *config.Config) fx.Option {

test-mfs-lock.bash

@@ -0,0 +1,13 @@
+set -x
+set -v
+
+# The daemon needs to be running, otherwise the commands will compete on their
+# lock of the entire repo (not the MFS root) and fail.
+ipfs swarm addrs > /dev/null || (echo "daemon not running" && exit 1)
+
+ipfs --version
+ipfs files mkdir /test-lock/
+ipfs files rm /test-lock/ -r
+((echo "content" | ./cmd/ipfs/ipfs files write --create --parents --truncate --lock-time 3 /test-lock/file) && echo "ipfs write lock released" &)
+ipfs repo gc
+# FIXME: This is a flaky test just to manually check the lock in ipfs write is blocking the GC.