Repository: tetratelabs/wazero
Pull request #1056 (2023-01-23 02:57:25)

fs: renames internal syscallfs package to sysfs and notes RATIONALE
It will help for us to rename earlier vs later, and syscallfs will be laborious, especially after we introduce an FSConfig type and need to declare a method name that differentiates from normal fs.FS. e.g. WithFS vs WithSysFS reads nicer than WithSyscallFS, and meanwhile sys is already a public package.


Patch:
diff --git a/Makefile b/Makefile
index 7fbfc22d..bf4351a0 100644
--- a/Makefile
+++ b/Makefile
@@ -218,7 +218,7 @@ check:
 # The following checks help ensure our platform-specific code used for system
 # calls safely falls back on a platform unsupported by the compiler engine.
 # This makes sure the intepreter can be used. Most often the package that can
-# drift here is "platform" or "syscallfs":
+# drift here is "platform" or "sysfs":
 #
 # Ensure we build on an arbitrary operating system
 	@GOARCH=amd64 GOOS=dragonfly go build ./...
diff --git a/cmd/wazero/wazero.go b/cmd/wazero/wazero.go
index a51b821c..71734108 100644
--- a/cmd/wazero/wazero.go
+++ b/cmd/wazero/wazero.go
@@ -16,7 +16,7 @@ import (
 	"github.com/tetratelabs/wazero/experimental/logging"
 	gojs "github.com/tetratelabs/wazero/imports/go"
 	"github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1"
-	"github.com/tetratelabs/wazero/internal/syscallfs"
+	"github.com/tetratelabs/wazero/internal/sysfs"
 	"github.com/tetratelabs/wazero/internal/version"
 	"github.com/tetratelabs/wazero/sys"
 )
@@ -227,8 +227,8 @@ func doRun(args []string, stdOut io.Writer, stdErr logging.Writer, exit func(cod
 	exit(0)
 }
 
-func validateMounts(mounts sliceFlag, stdErr logging.Writer, exit func(code int)) syscallfs.FS {
-	fs := make([]syscallfs.FS, 0, len(mounts))
+func validateMounts(mounts sliceFlag, stdErr logging.Writer, exit func(code int)) sysfs.FS {
+	fs := make([]sysfs.FS, 0, len(mounts))
 	for _, mount := range mounts {
 		if len(mount) == 0 {
 			fmt.Fprintln(stdErr, "invalid mount: empty string")
@@ -261,18 +261,18 @@ func validateMounts(mounts sliceFlag, stdErr logging.Writer, exit func(code int)
 			host = abs
 		}
 
-		next, err := syscallfs.NewDirFS(host, guest)
+		next, err := sysfs.NewDirFS(host, guest)
 		if err != nil {
 			fmt.Fprintf(stdErr, "invalid mount: %v\n", err)
 			exit(1)
 		} else {
 			if readOnly {
-				next = syscallfs.NewReadFS(next)
+				next = sysfs.NewReadFS(next)
 			}
 			fs = append(fs, next)
 		}
 	}
-	if fs, err := syscallfs.NewRootFS(fs...); err != nil {
+	if fs, err := sysfs.NewRootFS(fs...); err != nil {
 		fmt.Fprintf(stdErr, "invalid mounts %v: %v\n", fs, err)
 		exit(1)
 		return nil
diff --git a/experimental/writefs/writefs.go b/experimental/writefs/writefs.go
index bd6bf948..b48d67c2 100644
--- a/experimental/writefs/writefs.go
+++ b/experimental/writefs/writefs.go
@@ -10,7 +10,7 @@ package writefs
 import (
 	"io/fs"
 
-	"github.com/tetratelabs/wazero/internal/syscallfs"
+	"github.com/tetratelabs/wazero/internal/sysfs"
 )
 
 // NewDirFS creates a writeable filesystem at the given path on the host
@@ -35,6 +35,6 @@ import (
 // Do not attempt to use the result as a fs.FS, as it will panic. This is a
 // bridge to a future filesystem abstraction made for wazero.
 func NewDirFS(hostDir string) (fs.FS, error) {
-	// syscallfs.DirFS is intentionally internal as it is still evolving
-	return syscallfs.NewDirFS(hostDir, "/")
+	// sysfs.DirFS is intentionally internal as it is still evolving
+	return sysfs.NewDirFS(hostDir, "/")
 }
diff --git a/imports/wasi_snapshot_preview1/fs.go b/imports/wasi_snapshot_preview1/fs.go
index 087b11c4..a77244f6 100644
--- a/imports/wasi_snapshot_preview1/fs.go
+++ b/imports/wasi_snapshot_preview1/fs.go
@@ -12,7 +12,7 @@ import (
 	"github.com/tetratelabs/wazero/api"
 	"github.com/tetratelabs/wazero/internal/platform"
 	"github.com/tetratelabs/wazero/internal/sys"
-	"github.com/tetratelabs/wazero/internal/syscallfs"
+	"github.com/tetratelabs/wazero/internal/sysfs"
 	. "github.com/tetratelabs/wazero/internal/wasi_snapshot_preview1"
 	"github.com/tetratelabs/wazero/internal/wasm"
 )
@@ -513,7 +513,7 @@ func fdReadOrPread(mod api.Module, params []uint64, isPread bool) Errno {
 	var resultNread uint32
 	if isPread {
 		offset := int64(params[3])
-		reader = syscallfs.ReaderAtOffset(r.File, offset)
+		reader = sysfs.ReaderAtOffset(r.File, offset)
 		resultNread = uint32(params[4])
 	} else {
 		resultNread = uint32(params[3])
@@ -1039,7 +1039,7 @@ func fdWriteOrPwrite(mod api.Module, params []uint64, isPwrite bool) Errno {
 		return ErrnoBadf
 	} else if isPwrite {
 		offset := int64(params[3])
-		writer = syscallfs.WriterAtOffset(f.File, offset)
+		writer = sysfs.WriterAtOffset(f.File, offset)
 		resultNwritten = uint32(params[4])
 	} else {
 		writer = f.File.(io.Writer)
@@ -1180,7 +1180,7 @@ func pathFilestatGetFn(_ context.Context, mod api.Module, params []uint64) Errno
 	resultBuf := uint32(params[4])
 
 	// Stat the file without allocating a file descriptor
-	stat, err := syscallfs.StatPath(fsc.FS(), pathName)
+	stat, err := sysfs.StatPath(fsc.FS(), pathName)
 	if err != nil {
 		return ToErrno(err)
 	}
diff --git a/internal/gojs/fs.go b/internal/gojs/fs.go
index 6182c4cb..287b9409 100644
--- a/internal/gojs/fs.go
+++ b/internal/gojs/fs.go
@@ -13,7 +13,7 @@ import (
 	"github.com/tetratelabs/wazero/internal/gojs/goos"
 	"github.com/tetratelabs/wazero/internal/platform"
 	internalsys "github.com/tetratelabs/wazero/internal/sys"
-	"github.com/tetratelabs/wazero/internal/syscallfs"
+	"github.com/tetratelabs/wazero/internal/sysfs"
 	"github.com/tetratelabs/wazero/internal/wasm"
 )
 
@@ -117,7 +117,7 @@ func (jsfsStat) invoke(ctx context.Context, mod api.Module, args ...interface{})
 func syscallStat(mod api.Module, path string) (*jsSt, error) {
 	fsc := mod.(*wasm.CallContext).Sys.FS()
 
-	if stat, err := syscallfs.StatPath(fsc.FS(), path); err != nil {
+	if stat, err := sysfs.StatPath(fsc.FS(), path); err != nil {
 		return nil, err
 	} else {
 		return newJsSt(stat), nil
@@ -278,7 +278,7 @@ func syscallRead(mod api.Module, fd uint32, offset interface{}, p []byte) (n uin
 	var reader io.Reader = f.File
 
 	if offset != nil {
-		reader = syscallfs.ReaderAtOffset(f.File, toInt64(offset))
+		reader = sysfs.ReaderAtOffset(f.File, toInt64(offset))
 	}
 
 	if nRead, e := reader.Read(p); e == nil || e == io.EOF {
@@ -324,7 +324,7 @@ func syscallWrite(mod api.Module, fd uint32, offset interface{}, p []byte) (n ui
 	if f, ok := fsc.LookupFile(fd); !ok {
 		err = syscall.EBADF
 	} else if offset != nil {
-		writer = syscallfs.WriterAtOffset(f.File, toInt64(offset))
+		writer = sysfs.WriterAtOffset(f.File, toInt64(offset))
 	} else {
 		writer = f.File.(io.Writer)
 	}
diff --git a/internal/sys/fs.go b/internal/sys/fs.go
index dd5cf7c0..47d11a84 100644
--- a/internal/sys/fs.go
+++ b/internal/sys/fs.go
@@ -10,7 +10,7 @@ import (
 	"time"
 
 	"github.com/tetratelabs/wazero/internal/platform"
-	"github.com/tetratelabs/wazero/internal/syscallfs"
+	"github.com/tetratelabs/wazero/internal/sysfs"
 )
 
 const (
@@ -108,7 +108,7 @@ func (stdioFileInfo) IsDir() bool         { return false }
 func (stdioFileInfo) Sys() interface{}    { return nil }
 
 type lazyDir struct {
-	fs syscallfs.FS
+	fs sysfs.FS
 	f  fs.File
 }
 
@@ -199,7 +199,7 @@ type ReadDir struct {
 
 type FSContext struct {
 	// fs is the root ("/") mount.
-	fs syscallfs.FS
+	fs sysfs.FS
 
 	// openedFiles is a map of file descriptor numbers (>=FdPreopen) to open files
 	// (or directories) and defaults to empty.
@@ -210,15 +210,15 @@ type FSContext struct {
 // NewFSContext creates a FSContext with stdio streams and an optional
 // pre-opened filesystem.
 //
-// If `preopened` is not syscallfs.UnimplementedFS, it is inserted into
+// If `preopened` is not sysfs.UnimplementedFS, it is inserted into
 // the file descriptor table as FdPreopen.
-func NewFSContext(stdin io.Reader, stdout, stderr io.Writer, preopened syscallfs.FS) (fsc *FSContext, err error) {
+func NewFSContext(stdin io.Reader, stdout, stderr io.Writer, preopened sysfs.FS) (fsc *FSContext, err error) {
 	fsc = &FSContext{fs: preopened}
 	fsc.openedFiles.Insert(stdinReader(stdin))
 	fsc.openedFiles.Insert(stdioWriter(stdout, noopStdoutStat))
 	fsc.openedFiles.Insert(stdioWriter(stderr, noopStderrStat))
 
-	if _, ok := preopened.(syscallfs.UnimplementedFS); ok {
+	if _, ok := preopened.(sysfs.UnimplementedFS); ok {
 		return fsc, nil
 	}
 
@@ -267,7 +267,7 @@ func (s fileModeStat) IsDir() bool        { return false }
 
 // FS returns the underlying filesystem. Any files that should be added to the
 // table should be inserted via InsertFile.
-func (c *FSContext) FS() syscallfs.FS {
+func (c *FSContext) FS() sysfs.FS {
 	return c.fs
 }
 
diff --git a/internal/sys/sys.go b/internal/sys/sys.go
index b0d6e3be..0fa9b252 100644
--- a/internal/sys/sys.go
+++ b/internal/sys/sys.go
@@ -8,7 +8,7 @@ import (
 	"time"
 
 	"github.com/tetratelabs/wazero/internal/platform"
-	"github.com/tetratelabs/wazero/internal/syscallfs"
+	"github.com/tetratelabs/wazero/internal/sysfs"
 	"github.com/tetratelabs/wazero/sys"
 )
 
@@ -88,7 +88,7 @@ func (c *Context) Nanosleep(ns int64) {
 	(*(c.nanosleep))(ns)
 }
 
-// FS returns the possibly empty (syscallfs.UnimplementedFS) file system context.
+// FS returns the possibly empty (sysfs.UnimplementedFS) file system context.
 func (c *Context) FS() *FSContext {
 	return c.fsc
 }
@@ -182,9 +182,9 @@ func NewContext(
 	}
 
 	if fs != nil {
-		sysCtx.fsc, err = NewFSContext(stdin, stdout, stderr, syscallfs.Adapt(fs, "/"))
+		sysCtx.fsc, err = NewFSContext(stdin, stdout, stderr, sysfs.Adapt(fs, "/"))
 	} else {
-		sysCtx.fsc, err = NewFSContext(stdin, stdout, stderr, syscallfs.UnimplementedFS{})
+		sysCtx.fsc, err = NewFSContext(stdin, stdout, stderr, sysfs.UnimplementedFS{})
 	}
 
 	return
diff --git a/internal/syscallfs/adapter.go b/internal/sysfs/adapter.go
similarity index 98%
rename from internal/syscallfs/adapter.go
rename to internal/sysfs/adapter.go
index a1474eb1..7433ec3b 100644
--- a/internal/syscallfs/adapter.go
+++ b/internal/sysfs/adapter.go
@@ -1,4 +1,4 @@
-package syscallfs
+package sysfs
 
 import (
 	"fmt"
diff --git a/internal/syscallfs/dirfs.go b/internal/sysfs/dirfs.go
similarity index 99%
rename from internal/syscallfs/dirfs.go
rename to internal/sysfs/dirfs.go
index 57daea42..7ec4353a 100644
--- a/internal/syscallfs/dirfs.go
+++ b/internal/sysfs/dirfs.go
@@ -1,4 +1,4 @@
-package syscallfs
+package sysfs
 
 import (
 	"errors"
diff --git a/internal/syscallfs/readfs.go b/internal/sysfs/readfs.go
similarity index 99%
rename from internal/syscallfs/readfs.go
rename to internal/sysfs/readfs.go
index e99b954d..ee09c688 100644
--- a/internal/syscallfs/readfs.go
+++ b/internal/sysfs/readfs.go
@@ -1,4 +1,4 @@
-package syscallfs
+package sysfs
 
 import (
 	"io"
diff --git a/internal/syscallfs/rootfs.go b/internal/sysfs/rootfs.go
similarity index 99%
rename from internal/syscallfs/rootfs.go
rename to internal/sysfs/rootfs.go
index 8bcafd87..3c767a43 100644
--- a/internal/syscallfs/rootfs.go
+++ b/internal/sysfs/rootfs.go
@@ -1,4 +1,4 @@
-package syscallfs
+package sysfs
 
 import (
 	"fmt"
diff --git a/internal/syscallfs/syscall.go b/internal/sysfs/syscall.go
similarity index 95%
rename from internal/syscallfs/syscall.go
rename to internal/sysfs/syscall.go
index ed4e4083..b9ecc951 100644
--- a/internal/syscallfs/syscall.go
+++ b/internal/sysfs/syscall.go
@@ -1,6 +1,6 @@
 //go:build !windows
 
-package syscallfs
+package sysfs
 
 import "syscall"
 
diff --git a/internal/syscallfs/syscall_windows.go b/internal/sysfs/syscall_windows.go
similarity index 99%
rename from internal/syscallfs/syscall_windows.go
rename to internal/sysfs/syscall_windows.go
index 303b08fd..863dc456 100644
--- a/internal/syscallfs/syscall_windows.go
+++ b/internal/sysfs/syscall_windows.go
@@ -1,4 +1,4 @@
-package syscallfs
+package sysfs
 
 import (
 	"errors"
diff --git a/internal/syscallfs/syscallfs.go b/internal/sysfs/sysfs.go
similarity index 96%
rename from internal/syscallfs/syscallfs.go
rename to internal/sysfs/sysfs.go
index bcd36c10..5227ae8e 100644
--- a/internal/syscallfs/syscallfs.go
+++ b/internal/sysfs/sysfs.go
@@ -1,4 +1,9 @@
-package syscallfs
+// Package sysfs includes a low-level filesystem interface and utilities needed
+// for WebAssembly host functions (ABI) such as WASI and runtime.GOOS=js.
+//
+// The name sysfs was chosen because wazero's public API has a "sys" package,
+// which was named after https://github.com/golang/sys.
+package sysfs
 
 import (
 	"io"
diff --git a/internal/syscallfs/testdata/empty.txt b/internal/sysfs/testdata/empty.txt
similarity index 100%
rename from internal/syscallfs/testdata/empty.txt
rename to internal/sysfs/testdata/empty.txt
diff --git a/internal/syscallfs/testdata/wazero.txt b/internal/sysfs/testdata/wazero.txt
similarity index 100%
rename from internal/syscallfs/testdata/wazero.txt
rename to internal/sysfs/testdata/wazero.txt
diff --git a/internal/syscallfs/unsupported.go b/internal/sysfs/unsupported.go
similarity index 98%
rename from internal/syscallfs/unsupported.go
rename to internal/sysfs/unsupported.go
index 991bb155..fd386434 100644
--- a/internal/syscallfs/unsupported.go
+++ b/internal/sysfs/unsupported.go
@@ -1,4 +1,4 @@
-package syscallfs
+package sysfs
 
 import (
 	"fmt"


Test patch:
diff --git a/imports/wasi_snapshot_preview1/fs_test.go b/imports/wasi_snapshot_preview1/fs_test.go
index 7b34897d..65c30839 100644
--- a/imports/wasi_snapshot_preview1/fs_test.go
+++ b/imports/wasi_snapshot_preview1/fs_test.go
@@ -17,7 +17,7 @@ import (
 	"github.com/tetratelabs/wazero/internal/fstest"
 	"github.com/tetratelabs/wazero/internal/leb128"
 	"github.com/tetratelabs/wazero/internal/sys"
-	"github.com/tetratelabs/wazero/internal/syscallfs"
+	"github.com/tetratelabs/wazero/internal/sysfs"
 	"github.com/tetratelabs/wazero/internal/testing/require"
 	. "github.com/tetratelabs/wazero/internal/wasi_snapshot_preview1"
 	"github.com/tetratelabs/wazero/internal/wasm"
@@ -719,7 +719,7 @@ func Test_fdPread_Errors(t *testing.T) {
 }
 
 func Test_fdPrestatGet(t *testing.T) {
-	testfs, err := syscallfs.NewDirFS(t.TempDir(), "/")
+	testfs, err := sysfs.NewDirFS(t.TempDir(), "/")
 	require.NoError(t, err)
 
 	mod, r, log := requireProxyModule(t, wazero.NewModuleConfig().WithFS(testfs))
@@ -806,7 +806,7 @@ func Test_fdPrestatGet_Errors(t *testing.T) {
 }
 
 func Test_fdPrestatDirName(t *testing.T) {
-	testfs, err := syscallfs.NewDirFS(t.TempDir(), "/")
+	testfs, err := sysfs.NewDirFS(t.TempDir(), "/")
 	require.NoError(t, err)
 
 	mod, r, log := requireProxyModule(t, wazero.NewModuleConfig().WithFS(testfs))
@@ -2283,7 +2283,7 @@ func Test_fdWrite_Errors(t *testing.T) {
 
 func Test_pathCreateDirectory(t *testing.T) {
 	tmpDir := t.TempDir() // open before loop to ensure no locking problems.
-	fs, err := syscallfs.NewDirFS(tmpDir, "/")
+	fs, err := sysfs.NewDirFS(tmpDir, "/")
 	require.NoError(t, err)
 
 	mod, r, log := requireProxyModule(t, wazero.NewModuleConfig().WithFS(fs))
@@ -2314,7 +2314,7 @@ func Test_pathCreateDirectory(t *testing.T) {
 
 func Test_pathCreateDirectory_Errors(t *testing.T) {
 	tmpDir := t.TempDir() // open before loop to ensure no locking problems.
-	fs, err := syscallfs.NewDirFS(tmpDir, "/")
+	fs, err := sysfs.NewDirFS(tmpDir, "/")
 	require.NoError(t, err)
 
 	mod, r, log := requireProxyModule(t, wazero.NewModuleConfig().WithFS(fs))
@@ -2602,9 +2602,9 @@ func Test_pathLink(t *testing.T) {
 
 func Test_pathOpen(t *testing.T) {
 	dir := t.TempDir() // open before loop to ensure no locking problems.
-	writeFS, err := syscallfs.NewDirFS(dir, "/")
+	writeFS, err := sysfs.NewDirFS(dir, "/")
 	require.NoError(t, err)
-	readFS := syscallfs.NewReadFS(writeFS)
+	readFS := sysfs.NewReadFS(writeFS)
 
 	fileName := "file"
 	fileContents := []byte("012")
@@ -2638,7 +2638,7 @@ func Test_pathOpen(t *testing.T) {
 		expectedLog   string
 	}{
 		{
-			name: "syscallfs.ReadFS",
+			name: "sysfs.ReadFS",
 			fs:   readFS,
 			path: func(*testing.T) string { return fileName },
 			expected: func(t *testing.T, fsc *sys.FSContext) {
@@ -2650,7 +2650,7 @@ func Test_pathOpen(t *testing.T) {
 `,
 		},
 		{
-			name: "syscallfs.DirFS",
+			name: "sysfs.DirFS",
 			fs:   writeFS,
 			path: func(*testing.T) string { return fileName },
 			expected: func(t *testing.T, fsc *sys.FSContext) {
@@ -2662,7 +2662,7 @@ func Test_pathOpen(t *testing.T) {
 `,
 		},
 		{
-			name:          "syscallfs.ReadFS FD_APPEND",
+			name:          "sysfs.ReadFS FD_APPEND",
 			fs:            readFS,
 			fdflags:       FD_APPEND,
 			path:          func(t *testing.T) (file string) { return appendName },
@@ -2673,7 +2673,7 @@ func Test_pathOpen(t *testing.T) {
 `,
 		},
 		{
-			name:    "syscallfs.DirFS FD_APPEND",
+			name:    "sysfs.DirFS FD_APPEND",
 			fs:      writeFS,
 			path:    func(t *testing.T) (file string) { return appendName },
 			fdflags: FD_APPEND,
@@ -2693,7 +2693,7 @@ func Test_pathOpen(t *testing.T) {
 `,
 		},
 		{
-			name:          "syscallfs.ReadFS O_CREAT",
+			name:          "sysfs.ReadFS O_CREAT",
 			fs:            readFS,
 			oflags:        O_CREAT,
 			expectedErrno: ErrnoNosys,
@@ -2704,7 +2704,7 @@ func Test_pathOpen(t *testing.T) {
 `,
 		},
 		{
-			name:   "syscallfs.DirFS O_CREAT",
+			name:   "sysfs.DirFS O_CREAT",
 			fs:     writeFS,
 			path:   func(t *testing.T) (file string) { return "creat" },
 			oflags: O_CREAT,
@@ -2725,7 +2725,7 @@ func Test_pathOpen(t *testing.T) {
 `,
 		},
 		{
-			name:          "syscallfs.ReadFS O_CREAT O_TRUNC",
+			name:          "sysfs.ReadFS O_CREAT O_TRUNC",
 			fs:            readFS,
 			oflags:        O_CREAT | O_TRUNC,
 			expectedErrno: ErrnoNosys,
@@ -2736,7 +2736,7 @@ func Test_pathOpen(t *testing.T) {
 `,
 		},
 		{
-			name:   "syscallfs.DirFS O_CREAT O_TRUNC",
+			name:   "sysfs.DirFS O_CREAT O_TRUNC",
 			fs:     writeFS,
 			path:   func(t *testing.T) (file string) { return path.Join(dirName, "O_CREAT-O_TRUNC") },
 			oflags: O_CREAT | O_TRUNC,
@@ -2757,7 +2757,7 @@ func Test_pathOpen(t *testing.T) {
 `,
 		},
 		{
-			name:   "syscallfs.ReadFS O_DIRECTORY",
+			name:   "sysfs.ReadFS O_DIRECTORY",
 			fs:     readFS,
 			oflags: O_DIRECTORY,
 			path:   func(*testing.T) string { return dirName },
@@ -2772,7 +2772,7 @@ func Test_pathOpen(t *testing.T) {
 `,
 		},
 		{
-			name:   "syscallfs.DirFS O_DIRECTORY",
+			name:   "sysfs.DirFS O_DIRECTORY",
 			fs:     writeFS,
 			path:   func(*testing.T) string { return dirName },
 			oflags: O_DIRECTORY,
@@ -2787,7 +2787,7 @@ func Test_pathOpen(t *testing.T) {
 `,
 		},
 		{
-			name:          "syscallfs.ReadFS O_TRUNC",
+			name:          "sysfs.ReadFS O_TRUNC",
 			fs:            readFS,
 			oflags:        O_TRUNC,
 			expectedErrno: ErrnoNosys,
@@ -2798,7 +2798,7 @@ func Test_pathOpen(t *testing.T) {
 `,
 		},
 		{
-			name:   "syscallfs.DirFS O_TRUNC",
+			name:   "sysfs.DirFS O_TRUNC",
 			fs:     writeFS,
 			path:   func(t *testing.T) (file string) { return "trunc" },
 			oflags: O_TRUNC,
@@ -2893,7 +2893,7 @@ func writeFile(t *testing.T, tmpDir, file string, contents []byte) {
 
 func Test_pathOpen_Errors(t *testing.T) {
 	tmpDir := t.TempDir() // open before loop to ensure no locking problems.
-	fs, err := syscallfs.NewDirFS(tmpDir, "/")
+	fs, err := sysfs.NewDirFS(tmpDir, "/")
 	require.NoError(t, err)
 
 	mod, r, log := requireProxyModule(t, wazero.NewModuleConfig().WithFS(fs))
@@ -3037,7 +3037,7 @@ func Test_pathReadlink(t *testing.T) {
 
 func Test_pathRemoveDirectory(t *testing.T) {
 	tmpDir := t.TempDir() // open before loop to ensure no locking problems.
-	fs, err := syscallfs.NewDirFS(tmpDir, "/")
+	fs, err := sysfs.NewDirFS(tmpDir, "/")
 	require.NoError(t, err)
 
 	mod, r, log := requireProxyModule(t, wazero.NewModuleConfig().WithFS(fs))
@@ -3070,7 +3070,7 @@ func Test_pathRemoveDirectory(t *testing.T) {
 
 func Test_pathRemoveDirectory_Errors(t *testing.T) {
 	tmpDir := t.TempDir() // open before loop to ensure no locking problems.
-	fs, err := syscallfs.NewDirFS(tmpDir, "/")
+	fs, err := sysfs.NewDirFS(tmpDir, "/")
 	require.NoError(t, err)
 
 	mod, r, log := requireProxyModule(t, wazero.NewModuleConfig().WithFS(fs))
@@ -3208,7 +3208,7 @@ func Test_pathSymlink(t *testing.T) {
 
 func Test_pathRename(t *testing.T) {
 	tmpDir := t.TempDir() // open before loop to ensure no locking problems.
-	fs, err := syscallfs.NewDirFS(tmpDir, "/")
+	fs, err := sysfs.NewDirFS(tmpDir, "/")
 	require.NoError(t, err)
 
 	mod, r, log := requireProxyModule(t, wazero.NewModuleConfig().WithFS(fs))
@@ -3252,7 +3252,7 @@ func Test_pathRename(t *testing.T) {
 
 func Test_pathRename_Errors(t *testing.T) {
 	tmpDir := t.TempDir() // open before loop to ensure no locking problems.
-	fs, err := syscallfs.NewDirFS(tmpDir, "/")
+	fs, err := sysfs.NewDirFS(tmpDir, "/")
 	require.NoError(t, err)
 
 	mod, r, log := requireProxyModule(t, wazero.NewModuleConfig().WithFS(fs))
@@ -3428,7 +3428,7 @@ func Test_pathRename_Errors(t *testing.T) {
 
 func Test_pathUnlinkFile(t *testing.T) {
 	tmpDir := t.TempDir() // open before loop to ensure no locking problems.
-	fs, err := syscallfs.NewDirFS(tmpDir, "/")
+	fs, err := sysfs.NewDirFS(tmpDir, "/")
 	require.NoError(t, err)
 
 	mod, r, log := requireProxyModule(t, wazero.NewModuleConfig().WithFS(fs))
@@ -3461,7 +3461,7 @@ func Test_pathUnlinkFile(t *testing.T) {
 
 func Test_pathUnlinkFile_Errors(t *testing.T) {
 	tmpDir := t.TempDir() // open before loop to ensure no locking problems.
-	fs, err := syscallfs.NewDirFS(tmpDir, "/")
+	fs, err := sysfs.NewDirFS(tmpDir, "/")
 	require.NoError(t, err)
 
 	mod, r, log := requireProxyModule(t, wazero.NewModuleConfig().WithFS(fs))
@@ -3572,13 +3572,13 @@ func requireOpenFile(t *testing.T, tmpDir string, pathName string, data []byte,
 		require.NoError(t, os.WriteFile(realPath, data, 0o600))
 	}
 
-	writeFS, err := syscallfs.NewDirFS(tmpDir, "/")
+	writeFS, err := sysfs.NewDirFS(tmpDir, "/")
 	require.NoError(t, err)
 
 	testFS := writeFS
 	if readOnly {
 		oflags = os.O_RDONLY
-		testFS = syscallfs.NewReadFS(testFS)
+		testFS = sysfs.NewReadFS(testFS)
 	}
 
 	mod, r, log := requireProxyModule(t, wazero.NewModuleConfig().WithFS(testFS))
diff --git a/imports/wasi_snapshot_preview1/wasi_stdlib_test.go b/imports/wasi_snapshot_preview1/wasi_stdlib_test.go
index 803edec5..32a5a3ba 100644
--- a/imports/wasi_snapshot_preview1/wasi_stdlib_test.go
+++ b/imports/wasi_snapshot_preview1/wasi_stdlib_test.go
@@ -11,7 +11,7 @@ import (
 
 	"github.com/tetratelabs/wazero"
 	"github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1"
-	"github.com/tetratelabs/wazero/internal/syscallfs"
+	"github.com/tetratelabs/wazero/internal/sysfs"
 	"github.com/tetratelabs/wazero/internal/testing/require"
 	"github.com/tetratelabs/wazero/sys"
 )
@@ -51,7 +51,7 @@ func Test_fdReaddir_ls(t *testing.T) {
 func testFdReaddirLs(t *testing.T, bin []byte) {
 	// TODO: make a subfs
 	moduleConfig := wazero.NewModuleConfig().
-		WithFS(syscallfs.Adapt(fstest.MapFS{
+		WithFS(sysfs.Adapt(fstest.MapFS{
 			"-":   {},
 			"a-":  {Mode: fs.ModeDir},
 			"ab-": {},
@@ -87,7 +87,7 @@ ENOTDIR
 		for i := 0; i < count; i++ {
 			testFS[strconv.Itoa(i)] = &fstest.MapFile{}
 		}
-		config := wazero.NewModuleConfig().WithFS(syscallfs.Adapt(testFS, "/")).WithArgs("wasi", "ls", ".")
+		config := wazero.NewModuleConfig().WithFS(sysfs.Adapt(testFS, "/")).WithArgs("wasi", "ls", ".")
 		console := compileAndRun(t, config, bin)
 
 		lines := strings.Split(console, "\n")
@@ -112,7 +112,7 @@ func Test_fdReaddir_stat(t *testing.T) {
 func testFdReaddirStat(t *testing.T, bin []byte) {
 	moduleConfig := wazero.NewModuleConfig().WithArgs("wasi", "stat")
 
-	console := compileAndRun(t, moduleConfig.WithFS(syscallfs.Adapt(fstest.MapFS{}, "/")), bin)
+	console := compileAndRun(t, moduleConfig.WithFS(sysfs.Adapt(fstest.MapFS{}, "/")), bin)
 
 	// TODO: switch this to a real stat test
 	require.Equal(t, `
diff --git a/internal/fstest/fstest.go b/internal/fstest/fstest.go
index dd9bca17..03310309 100644
--- a/internal/fstest/fstest.go
+++ b/internal/fstest/fstest.go
@@ -12,7 +12,7 @@
 //	}
 //
 // Failures found here should result in new tests in the appropriate package,
-// for example, gojs, syscallfs or wasi_snapshot_preview1.
+// for example, gojs, sysfs or wasi_snapshot_preview1.
 //
 // This package must have no dependencies. Otherwise, compiling this with
 // TinyGo or `GOARCH=wasm GOOS=js` can become bloated or complicated.
diff --git a/internal/gojs/fs_test.go b/internal/gojs/fs_test.go
index a6c1ecc4..204a58e1 100644
--- a/internal/gojs/fs_test.go
+++ b/internal/gojs/fs_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/tetratelabs/wazero/experimental/writefs"
 	"github.com/tetratelabs/wazero/internal/fstest"
 	"github.com/tetratelabs/wazero/internal/platform"
-	"github.com/tetratelabs/wazero/internal/syscallfs"
+	"github.com/tetratelabs/wazero/internal/sysfs"
 	"github.com/tetratelabs/wazero/internal/testing/require"
 )
 
@@ -45,7 +45,7 @@ func Test_testfs(t *testing.T) {
 	require.NoError(t, os.Mkdir(testfsDir, 0o700))
 	require.NoError(t, fstest.WriteTestFiles(testfsDir))
 
-	rootFS, err := syscallfs.NewDirFS(tmpDir, "/")
+	rootFS, err := sysfs.NewDirFS(tmpDir, "/")
 	require.NoError(t, err)
 
 	stdout, stderr, err := compileAndRun(testCtx, "testfs", wazero.NewModuleConfig().WithFS(rootFS))
diff --git a/internal/sys/fs_test.go b/internal/sys/fs_test.go
index 5beb9b39..74873206 100644
--- a/internal/sys/fs_test.go
+++ b/internal/sys/fs_test.go
@@ -10,7 +10,7 @@ import (
 	"testing"
 	"testing/fstest"
 
-	"github.com/tetratelabs/wazero/internal/syscallfs"
+	"github.com/tetratelabs/wazero/internal/sysfs"
 	testfs "github.com/tetratelabs/wazero/internal/testing/fs"
 	"github.com/tetratelabs/wazero/internal/testing/require"
 )
@@ -31,31 +31,31 @@ func TestNewFSContext(t *testing.T) {
 	embedFS, err := fs.Sub(testdata, "testdata")
 	require.NoError(t, err)
 
-	dirfs, err := syscallfs.NewDirFS(".", "/")
+	dirfs, err := sysfs.NewDirFS(".", "/")
 	require.NoError(t, err)
 
 	// Test various usual configuration for the file system.
 	tests := []struct {
 		name string
-		fs   syscallfs.FS
+		fs   sysfs.FS
 	}{
 		{
 			name: "embed.FS",
-			fs:   syscallfs.Adapt(embedFS, "/"),
+			fs:   sysfs.Adapt(embedFS, "/"),
 		},
 		{
-			name: "syscallfs.NewDirFS",
+			name: "sysfs.NewDirFS",
 			// Don't use "testdata" because it may not be present in
 			// cross-architecture (a.k.a. scratch) build containers.
 			fs: dirfs,
 		},
 		{
-			name: "syscallfs.NewReadFS",
-			fs:   syscallfs.NewReadFS(dirfs),
+			name: "sysfs.NewReadFS",
+			fs:   sysfs.NewReadFS(dirfs),
 		},
 		{
 			name: "fstest.MapFS",
-			fs:   syscallfs.Adapt(fstest.MapFS{}, "/"),
+			fs:   sysfs.Adapt(fstest.MapFS{}, "/"),
 		},
 	}
 
@@ -96,10 +96,10 @@ func TestNewFSContext(t *testing.T) {
 }
 
 func TestUnimplementedFSContext(t *testing.T) {
-	testFS, err := NewFSContext(nil, nil, nil, syscallfs.UnimplementedFS{})
+	testFS, err := NewFSContext(nil, nil, nil, sysfs.UnimplementedFS{})
 	require.NoError(t, err)
 
-	expected := &FSContext{fs: syscallfs.UnimplementedFS{}}
+	expected := &FSContext{fs: sysfs.UnimplementedFS{}}
 	expected.openedFiles.Insert(noopStdin)
 	expected.openedFiles.Insert(noopStdout)
 	expected.openedFiles.Insert(noopStderr)
@@ -109,12 +109,12 @@ func TestUnimplementedFSContext(t *testing.T) {
 		require.NoError(t, err)
 
 		// Closes opened files
-		require.Equal(t, &FSContext{fs: syscallfs.UnimplementedFS{}}, testFS)
+		require.Equal(t, &FSContext{fs: sysfs.UnimplementedFS{}}, testFS)
 	})
 }
 
 func TestContext_Close(t *testing.T) {
-	testFS := syscallfs.Adapt(testfs.FS{"foo": &testfs.File{}}, "/")
+	testFS := sysfs.Adapt(testfs.FS{"foo": &testfs.File{}}, "/")
 
 	fsc, err := NewFSContext(nil, nil, nil, testFS)
 	require.NoError(t, err)
@@ -139,7 +139,7 @@ func TestContext_Close(t *testing.T) {
 func TestContext_Close_Error(t *testing.T) {
 	file := &testfs.File{CloseErr: errors.New("error closing")}
 
-	testFS := syscallfs.Adapt(testfs.FS{"foo": file}, "/")
+	testFS := sysfs.Adapt(testfs.FS{"foo": file}, "/")
 
 	fsc, err := NewFSContext(nil, nil, nil, testFS)
 	require.NoError(t, err)
diff --git a/internal/sys/sys_test.go b/internal/sys/sys_test.go
index 50b26f45..c24c7fdf 100644
--- a/internal/sys/sys_test.go
+++ b/internal/sys/sys_test.go
@@ -6,16 +6,16 @@ import (
 	"time"
 
 	"github.com/tetratelabs/wazero/internal/platform"
-	"github.com/tetratelabs/wazero/internal/syscallfs"
+	"github.com/tetratelabs/wazero/internal/sysfs"
 	testfs "github.com/tetratelabs/wazero/internal/testing/fs"
 	"github.com/tetratelabs/wazero/internal/testing/require"
 	"github.com/tetratelabs/wazero/sys"
 )
 
 func TestContext_FS(t *testing.T) {
-	sysCtx := DefaultContext(syscallfs.UnimplementedFS{})
+	sysCtx := DefaultContext(sysfs.UnimplementedFS{})
 
-	fsc, err := NewFSContext(nil, nil, nil, syscallfs.UnimplementedFS{})
+	fsc, err := NewFSContext(nil, nil, nil, sysfs.UnimplementedFS{})
 	require.NoError(t, err)
 
 	require.Equal(t, fsc, sysCtx.FS())
@@ -51,7 +51,7 @@ func TestDefaultSysContext(t *testing.T) {
 	require.Equal(t, &ns, sysCtx.nanosleep)
 	require.Equal(t, platform.NewFakeRandSource(), sysCtx.RandSource())
 
-	testFS := syscallfs.Adapt(testfs.FS{}, "/")
+	testFS := sysfs.Adapt(testfs.FS{}, "/")
 	expectedFS, _ := NewFSContext(nil, nil, nil, testFS)
 
 	expectedOpenedFiles := FileTable{}
diff --git a/internal/syscallfs/adapter_test.go b/internal/sysfs/adapter_test.go
similarity index 98%
rename from internal/syscallfs/adapter_test.go
rename to internal/sysfs/adapter_test.go
index 5824e9d0..df6fcfb8 100644
--- a/internal/syscallfs/adapter_test.go
+++ b/internal/sysfs/adapter_test.go
@@ -1,4 +1,4 @@
-package syscallfs
+package sysfs
 
 import (
 	"errors"
@@ -155,7 +155,7 @@ func TestAdapt_TestFS(t *testing.T) {
 		tc := tc
 
 		t.Run(tc.name, func(t *testing.T) {
-			// Adapt a normal fs.FS to syscallfs.FS
+			// Adapt a normal fs.FS to sysfs.FS
 			testFS := Adapt(tc.fs, "/")
 
 			// Adapt it back to fs.FS and run the tests
diff --git a/internal/syscallfs/dirfs_test.go b/internal/sysfs/dirfs_test.go
similarity index 99%
rename from internal/syscallfs/dirfs_test.go
rename to internal/sysfs/dirfs_test.go
index b6bd1b9a..0e5b13ae 100644
--- a/internal/syscallfs/dirfs_test.go
+++ b/internal/sysfs/dirfs_test.go
@@ -1,4 +1,4 @@
-package syscallfs
+package sysfs
 
 import (
 	"errors"
diff --git a/internal/syscallfs/readfs_test.go b/internal/sysfs/readfs_test.go
similarity index 99%
rename from internal/syscallfs/readfs_test.go
rename to internal/sysfs/readfs_test.go
index dcc4a27d..8ee12fcd 100644
--- a/internal/syscallfs/readfs_test.go
+++ b/internal/sysfs/readfs_test.go
@@ -1,4 +1,4 @@
-package syscallfs
+package sysfs
 
 import (
 	"io/fs"
diff --git a/internal/syscallfs/rootfs_test.go b/internal/sysfs/rootfs_test.go
similarity index 99%
rename from internal/syscallfs/rootfs_test.go
rename to internal/sysfs/rootfs_test.go
index 3d865a4d..9c373adf 100644
--- a/internal/syscallfs/rootfs_test.go
+++ b/internal/sysfs/rootfs_test.go
@@ -1,4 +1,4 @@
-package syscallfs
+package sysfs
 
 import (
 	"errors"
diff --git a/internal/syscallfs/syscallfs_bench_test.go b/internal/sysfs/sysfs_bench_test.go
similarity index 98%
rename from internal/syscallfs/syscallfs_bench_test.go
rename to internal/sysfs/sysfs_bench_test.go
index 6f1a0cb8..bf43390b 100644
--- a/internal/syscallfs/syscallfs_bench_test.go
+++ b/internal/sysfs/sysfs_bench_test.go
@@ -1,4 +1,4 @@
-package syscallfs
+package sysfs
 
 import (
 	"io"
diff --git a/internal/syscallfs/syscallfs_test.go b/internal/sysfs/sysfs_test.go
similarity index 99%
rename from internal/syscallfs/syscallfs_test.go
rename to internal/sysfs/sysfs_test.go
index d22a9f4d..389b231f 100644
--- a/internal/syscallfs/syscallfs_test.go
+++ b/internal/sysfs/sysfs_test.go
@@ -1,4 +1,4 @@
-package syscallfs
+package sysfs
 
 import (
 	"embed"
@@ -423,7 +423,7 @@ func TestWriterAtOffset(t *testing.T) {
 		name string
 		fs   FS
 	}{
-		{name: "syscallfs.dirFS", fs: dirFS},
+		{name: "sysfs.dirFS", fs: dirFS},
 	}
 
 	for _, tc := range tests {
@@ -490,7 +490,7 @@ func TestWriterAtOffset_empty(t *testing.T) {
 		name string
 		fs   FS
 	}{
-		{name: "syscallfs.dirFS", fs: dirFS},
+		{name: "sysfs.dirFS", fs: dirFS},
 	}
 
 	for _, tc := range tests {