Is NewVFS intended to be constructed only once per process?

[adenzhou1350]

At main 6aa2332, NewVFS mutates the package-level internalNodes slice and meta.TrashName.

Using the existing pkg/vfs createTestVFS helper with memkv and in-memory object storage, a focused Linux Go 1.25.10 race run shows:

• Default configuration: constructing two VFS values and looking up .config succeeds both times.
• Meta.Subdir="sub": the first construction leaves four internal nodes (trash omitted), but the second leaves three and Lookup(root, ".config") returns ENOENT.
• PrefixInternal=true: .jfs.config is reachable after the first prefixed construction, but not the second; meta.TrashName becomes .jfs.jfs.trash.

The first behavior comes from unconditionally removing the slice's last element. The second comes from prefixing names already modified by an earlier call:

juicefs/pkg/vfs/vfs.go

Lines 1266 to 1278 in 6aa2332

	n := getInternalNode(ConfigInode)
	v.Conf.Format.RemoveSecret()
	data, _ := json.MarshalIndent(v.Conf, "", " ")
	n.attr.Length = uint64(len(data))
	if conf.Meta.Subdir != "" { // don't show trash directory
	internalNodes = internalNodes[:len(internalNodes)-1]
	}
	if conf.PrefixInternal {
	for _, n := range internalNodes {
	n.name = ".jfs" + n.name
	}
	meta.TrashName = ".jfs" + meta.TrashName
	}

Is NewVFS intended to be initialized only once per process? The normal mount path appears to call it once, so this is not a report of a reproduced mounted-client failure or data loss. If repeated calls are supported, should these nodes be instance-local? A partial reset during construction would still affect earlier VFS instances and exported package-level lookup helpers.

I can contribute the native regression and a scoped fix once the intended lifetime contract is clear. The reproduction used private temporary state and no FUSE mount or external metadata service.

Native characterization test (pkg/vfs)

Save as pkg/vfs/owner_vfs_instance_probe_test.go and run go test -race -count=1 -run "^TestOwnerVFSConstructionIsRepeatable$" ./pkg/vfs. The default subtest passes; the two repeated-construction cases fail on the pinned source. This is not a fixed test suite or a claim that repeated construction is supported.

/*
 * JuiceFS, Copyright 2026 Juicedata, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package vfs

import (
	"path/filepath"
	"testing"

	"github.com/juicedata/juicefs/pkg/meta"
)

// This serial characterization uses the real VFS constructor and memkv store.
// Restore globals so the probe cannot change unrelated tests' starting state.
func TestOwnerVFSConstructionIsRepeatable(t *testing.T) {
	initial := append([]*internalNode(nil), internalNodes...)
	for i, node := range initial {
		copyNode, copyAttr := *node, *node.attr
		copyNode.attr = &copyAttr
		initial[i] = &copyNode
	}
	trashName := meta.TrashName
	restore := func() {
		internalNodes = make([]*internalNode, len(initial))
		for i, node := range initial {
			copyNode, copyAttr := *node, *node.attr
			copyNode.attr = &copyAttr
			internalNodes[i] = &copyNode
		}
		meta.TrashName = trashName
	}
	t.Cleanup(restore)
	// Never let NewVFS rename a process-global /tmp/state<parent>.json.
	t.Setenv("_FUSE_STATE_PATH", filepath.Join(t.TempDir(), "absent-state.json"))

	t.Run("default_control", func(t *testing.T) {
		restore()
		for i := 0; i < 2; i++ {
			v, _ := createTestVFS(nil, "")
			if entry, errno := v.Lookup(NewLogContext(meta.Background()), meta.RootInode, ".config"); errno != 0 || entry.Inode != ConfigInode {
				t.Fatalf("construction %d: .config lookup = %v, %v", i+1, entry, errno)
			}
		}
	})
	t.Run("subdir_control_then_second_constructor", func(t *testing.T) {
		restore()
		for i := 0; i < 2; i++ {
			v, _ := createTestVFS(func(conf *meta.Config) { conf.Subdir = "sub" }, "")
			if node := getInternalNode(trashInode); node != nil {
				t.Fatal("subdir constructor left the trash node visible")
			}
			if len(internalNodes) != len(initial)-1 {
				t.Errorf("construction %d: %d internal nodes, want %d (only trash omitted)", i+1, len(internalNodes), len(initial)-1)
			}
			if entry, errno := v.Lookup(NewLogContext(meta.Background()), meta.RootInode, ".config"); errno != 0 || entry.Inode != ConfigInode {
				t.Errorf("construction %d: .config lookup = %v, %v", i+1, entry, errno)
			}
		}
	})
	t.Run("prefix_control_then_second_constructor", func(t *testing.T) {
		restore()
		v, _ := createTestVFS(nil, "")
		conf := *v.Conf
		conf.PrefixInternal = true
		for i := 0; i < 2; i++ {
			prefixed := NewVFS(&conf, v.Meta, v.Store, nil, nil)
			if entry, errno := prefixed.Lookup(NewLogContext(meta.Background()), meta.RootInode, ".jfs.config"); errno != 0 || entry.Inode != ConfigInode {
				t.Errorf("construction %d: .jfs.config lookup = %v, %v", i+1, entry, errno)
			}
			if meta.TrashName != ".jfs"+trashName {
				t.Errorf("construction %d: TrashName = %q, want %q", i+1, meta.TrashName, ".jfs"+trashName)
			}
		}
	})
}

AI-assisted investigation; the reported outcomes were independently reproduced with the native constructor.

[junkerderprovinz]

In practice yes: the only caller is juicefs mount (cmd/mount.go#L689), and pkg/vfs keeps more process-wide state than internalNodes, like the package-level op metrics that vfs.InitMetrics registers once and the /tmp/state<ppid>.json handle file that every NewVFS call loads and renames. Everything that may open several volumes in one process, such as the Java SDK's jfs_init, goes through fs.NewFileSystem instead, which builds its own reader, writer and metrics per instance and never touches those globals. So for more than one instance pkg/fs is the route the code already supports. Making NewVFS itself repeatable would mean moving the internal node table onto VFS, and pkg/fs reads that table too through vfs.IsSpecialName.