fs: extracts syscallfs.ReaderAtOffset for WASI and gojs (#1037)

This extracts a utility `syscallfs.ReaderAtOffset()` to allow WASI and
gojs to re-use the same logic to implement `syscall.Pread`.

What's different than before is that if WASI passes multiple iovecs an
emulated `ReaderAt` will seek to the read position on each call to
`Read` vs once per loop. This was a design decision to keep the call
sites compatible between files that implement ReaderAt and those that
emulate them with Seeker (e.g. avoid the need for a read-scoped closer/
defer function). The main use case for emulation is `embed.file`, whose
seek function is cheap, so there's little performance impact to this.

Signed-off-by: Adrian Cole <adrian@tetrate.io>

internal/gojs/fs.go

@@ -274,17 +274,13 @@ func syscallRead(mod api.Module, fd uint32, offset interface{}, p []byte) (n uin
 		err = syscall.EBADF
 	}
 
+	var reader io.Reader = f.File
+
 	if offset != nil {
-		if s, ok := f.File.(io.Seeker); ok {
-			if _, err := s.Seek(toInt64(offset), io.SeekStart); err != nil {
-				return 0, err
-			}
-		} else {
-			return 0, syscall.ENOTSUP
-		}
+		reader = syscallfs.ReaderAtOffset(f.File, toInt64(offset))
 	}
 
-	if nRead, e := f.File.Read(p); e == nil || e == io.EOF {
+	if nRead, e := reader.Read(p); e == nil || e == io.EOF {
 		// fs_js.go cannot parse io.EOF so coerce it to nil.
 		// See https://github.com/golang/go/issues/43913
 		n = uint32(nRead)
@@ -309,7 +305,7 @@ func (jsfsWrite) invoke(ctx context.Context, mod api.Module, args ...interface{}
 	}
 	offset := goos.ValueToUint32(args[2])
 	byteCount := goos.ValueToUint32(args[3])
-	fOffset := args[4] // nil unless Pread
+	fOffset := args[4] // nil unless Pwrite
 	callback := args[5].(funcWrapper)
 
 	if byteCount > 0 { // empty is possible on EOF

internal/gojs/testdata/fs/main.go

@@ -1,7 +1,9 @@
 package fs
 
 import (
+	"bytes"
 	"fmt"
+	"io"
 	"log"
 	"os"
 	"syscall"
@@ -34,12 +36,35 @@ func testAdHoc() {
 		}
 	}
 
+	// Read the full contents of the file using io.Reader
 	b, err := os.ReadFile("/animals.txt")
 	if err != nil {
 		log.Panicln(err)
 	}
 	fmt.Println("contents:", string(b))
 
+	// Re-open the same file to test io.ReaderAt
+	f, err := os.Open("/animals.txt")
+	if err != nil {
+		log.Panicln(err)
+	}
+	defer f.Close()
+
+	// Seek to an arbitrary position.
+	if _, err = f.Seek(4, io.SeekStart); err != nil {
+		log.Panicln(err)
+	}
+
+	b1 := make([]byte, len(b))
+	// We expect to revert to the original position on ReadAt zero.
+	if _, err = f.ReadAt(b1, 0); err != nil {
+		log.Panicln(err)
+	}
+
+	if !bytes.Equal(b, b1) {
+		log.Panicln("unexpected ReadAt contents: ", string(b1))
+	}
+
 	b, err = os.ReadFile("/empty.txt")
 	if err != nil {
 		log.Panicln(err)

internal/syscallfs/adapter_test.go

@@ -125,16 +125,36 @@ func TestAdapt_TestFS(t *testing.T) {
 
 	// Make a new fs.FS, noting the Go 1.17 fstest doesn't automatically filter
 	// "." entries in a directory. TODO: remove when we remove 1.17
-	fsFS := make(gofstest.MapFS, len(fstest.FS)-1)
+	mapFS := make(gofstest.MapFS, len(fstest.FS)-1)
 	for k, v := range fstest.FS {
 		if k != "." {
-			fsFS[k] = v
+			mapFS[k] = v
 		}
 	}
 
-	// Adapt a normal fs.FS to syscallfs.FS
-	testFS := Adapt("/", fsFS)
+	tmpDir := t.TempDir()
+	require.NoError(t, fstest.WriteTestFiles(tmpDir))
+	dirFS := os.DirFS(tmpDir)
 
-	// Adapt it back to fs.FS and run the tests
-	require.NoError(t, fstest.TestFS(&testFSAdapter{testFS}))
+	// TODO: We can't currently test embed.FS here because the source of
+	// fstest.FS are not real files.
+	tests := []struct {
+		name string
+		fs   fs.FS
+	}{
+		{name: "os.DirFS", fs: dirFS},
+		{name: "fstest.MapFS", fs: mapFS},
+	}
+
+	for _, tc := range tests {
+		tc := tc
+
+		t.Run(tc.name, func(t *testing.T) {
+			// Adapt a normal fs.FS to syscallfs.FS
+			testFS := Adapt("/", tc.fs)
+
+			// Adapt it back to fs.FS and run the tests
+			require.NoError(t, fstest.TestFS(&testFSAdapter{testFS}))
+		})
+	}
 }

internal/syscallfs/syscallfs.go

@@ -4,6 +4,7 @@ import (
 	"io"
 	"io/fs"
 	"os"
+	"syscall"
 )
 
 // FS is a writeable fs.FS bridge backed by syscall functions needed for ABI
@@ -134,8 +135,8 @@ func StatPath(fs FS, path string) (fs.FileInfo, error) {
 // readFile declares all read interfaces defined on os.File used by wazero.
 type readFile interface {
 	fs.ReadDirFile
-	io.ReaderAt
-	io.Seeker
+	io.ReaderAt // for pread
+	io.Seeker   // fallback for ReaderAt for embed:fs
 }
 
 // file declares all interfaces defined on os.File used by wazero.
@@ -146,3 +147,81 @@ type file interface {
 }
 
 type syncer interface{ Sync() error }
+
+// ReaderAtOffset gets an io.Reader from a fs.File that reads from an offset,
+// yet doesn't affect the underlying position. This is used to implement
+// syscall.Pread.
+//
+// Note: The file accessed shouldn't be used concurrently, but wasm isn't safe
+// to use concurrently anyway. Hence, we don't do any locking against parallel
+// reads.
+func ReaderAtOffset(f fs.File, offset int64) io.Reader {
+	if ret, ok := f.(io.ReaderAt); ok {
+		return &readerAtOffset{ret, offset}
+	} else if ret, ok := f.(io.ReadSeeker); ok {
+		return &seekToOffsetReader{ret, offset}
+	} else {
+		return enosysReader{}
+	}
+}
+
+type enosysReader struct{}
+
+// enosysReader implements io.Reader
+func (rs enosysReader) Read([]byte) (n int, err error) {
+	return 0, syscall.ENOSYS
+}
+
+type readerAtOffset struct {
+	r      io.ReaderAt
+	offset int64
+}
+
+// Read implements io.Reader
+func (r *readerAtOffset) Read(p []byte) (int, error) {
+	if len(p) == 0 {
+		return 0, nil // less overhead on zero-length reads.
+	}
+
+	n, err := r.r.ReadAt(p, r.offset)
+	r.offset += int64(n)
+	return n, err
+}
+
+// seekToOffsetReader implements io.Reader that seeks to an offset and reverts
+// to its initial offset after each call to Read.
+//
+// See /RATIONALE.md "fd_pread: io.Seeker fallback when io.ReaderAt is not supported"
+type seekToOffsetReader struct {
+	s      io.ReadSeeker
+	offset int64
+}
+
+// Read implements io.Reader
+func (rs *seekToOffsetReader) Read(p []byte) (int, error) {
+	if len(p) == 0 {
+		return 0, nil // less overhead on zero-length reads.
+	}
+
+	// Determine the current position in the file, as we need to revert it.
+	currentOffset, err := rs.s.Seek(0, io.SeekCurrent)
+	if err != nil {
+		return 0, err
+	}
+
+	// Put the read position back when complete.
+	defer func() { _, _ = rs.s.Seek(currentOffset, io.SeekStart) }()
+
+	// If the current offset isn't in sync with this reader, move it.
+	if rs.offset != currentOffset {
+		_, err := rs.s.Seek(rs.offset, io.SeekStart)
+		if err != nil {
+			return 0, err
+		}
+	}
+
+	// Perform the read, updating the offset.
+	n, err := rs.s.Read(p)
+	rs.offset += int64(n)
+	return n, err
+}

internal/syscallfs/syscallfs_bench_test.go

@@ -0,0 +1,63 @@
+package syscallfs
+
+import (
+	"io"
+	"io/fs"
+	"os"
+	"testing"
+)
+
+func BenchmarkReaderAtOffset(b *testing.B) {
+	dirFS := os.DirFS("testdata")
+	embedFS, err := fs.Sub(readerAtFS, "testdata")
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	benches := []struct {
+		name string
+		fs   fs.FS
+		ra   bool
+	}{
+		{name: "os.DirFS io.File", fs: dirFS, ra: false},
+		{name: "os.DirFS readerAtOffset", fs: dirFS, ra: true},
+		{name: "embed.FS embed.file", fs: embedFS, ra: false},
+		{name: "embed.FS seekToOffsetReader", fs: embedFS, ra: true},
+	}
+
+	buf := make([]byte, 3)
+
+	for _, bc := range benches {
+		bc := bc
+
+		b.Run(bc.name, func(b *testing.B) {
+			f, err := bc.fs.Open("wazero.txt")
+			if err != nil {
+				b.Fatal(err)
+			}
+			defer f.Close()
+
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				b.StopTimer()
+
+				// Reset the read position back to the beginning of the file.
+				if _, err = f.(io.Seeker).Seek(0, io.SeekStart); err != nil {
+					b.Fatal(err)
+				}
+
+				// Get the reader we are benchmarking
+				var r io.Reader = f
+				if bc.ra {
+					r = ReaderAtOffset(f, 3)
+				}
+
+				b.StartTimer()
+				if _, err := r.Read(buf); err != nil {
+					b.Fatal(err)
+				}
+				b.StopTimer()
+			}
+		})
+	}
+}

internal/syscallfs/syscallfs_test.go

@@ -1,6 +1,8 @@
 package syscallfs
 
 import (
+	"embed"
+	_ "embed"
 	"errors"
 	"io"
 	"io/fs"
@@ -11,6 +13,7 @@ import (
 	"strings"
 	"syscall"
 	"testing"
+	"testing/fstest"
 	"time"
 
 	"github.com/tetratelabs/wazero/internal/platform"
@@ -257,3 +260,154 @@ func (f *testFSAdapter) Open(name string) (fs.File, error) {
 func requireErrno(t *testing.T, expected syscall.Errno, actual error) {
 	require.True(t, errors.Is(actual, expected), "expected %v, but was %v", expected, actual)
 }
+
+var (
+	//go:embed testdata/*.txt
+	readerAtFS   embed.FS
+	readerAtFile = "wazero.txt"
+	emptyFile    = "empty.txt"
+)
+
+func TestReaderAtOffset(t *testing.T) {
+	embedFS, err := fs.Sub(readerAtFS, "testdata")
+	require.NoError(t, err)
+
+	d, err := embedFS.Open(readerAtFile)
+	require.NoError(t, err)
+	defer d.Close()
+
+	bytes, err := io.ReadAll(d)
+	require.NoError(t, err)
+
+	mapFS := fstest.MapFS{readerAtFile: &fstest.MapFile{Data: bytes}}
+
+	// Write a file as can't open "testdata" in scratch tests because they
+	// can't read the original filesystem.
+	tmpDir := t.TempDir()
+	require.NoError(t, os.WriteFile(path.Join(tmpDir, readerAtFile), bytes, 0o600))
+	dirFS := os.DirFS(tmpDir)
+
+	tests := []struct {
+		name string
+		fs   fs.FS
+	}{
+		{name: "os.DirFS", fs: dirFS},
+		{name: "embed.FS", fs: embedFS},
+		{name: "fstest.MapFS", fs: mapFS},
+	}
+
+	buf := make([]byte, 3)
+
+	for _, tc := range tests {
+		tc := tc
+
+		t.Run(tc.name, func(t *testing.T) {
+			f, err := tc.fs.Open(readerAtFile)
+			require.NoError(t, err)
+			defer f.Close()
+
+			var r io.Reader = f
+			ra := ReaderAtOffset(f, 0)
+
+			requireRead3 := func(r io.Reader, buf []byte) {
+				n, err := r.Read(buf)
+				require.NoError(t, err)
+				require.Equal(t, 3, n)
+			}
+
+			// The file should work as a reader (base case)
+			requireRead3(r, buf)
+			require.Equal(t, "waz", string(buf))
+			buf = buf[:]
+
+			// The readerAt impl should be able to start from zero also
+			requireRead3(ra, buf)
+			require.Equal(t, "waz", string(buf))
+			buf = buf[:]
+
+			// If the offset didn't change, we expect the next three chars.
+			requireRead3(r, buf)
+			require.Equal(t, "ero", string(buf))
+			buf = buf[:]
+
+			// If state was held between reader-at, we expect the same
+			requireRead3(ra, buf)
+			require.Equal(t, "ero", string(buf))
+			buf = buf[:]
+
+			// We should also be able to make another reader-at
+			ra = ReaderAtOffset(f, 3)
+			requireRead3(ra, buf)
+			require.Equal(t, "ero", string(buf))
+		})
+	}
+}
+
+func TestReaderAtOffset_empty(t *testing.T) {
+	embedFS, err := fs.Sub(readerAtFS, "testdata")
+	require.NoError(t, err)
+
+	d, err := embedFS.Open(readerAtFile)
+	require.NoError(t, err)
+	defer d.Close()
+
+	mapFS := fstest.MapFS{emptyFile: &fstest.MapFile{}}
+
+	// Write a file as can't open "testdata" in scratch tests because they
+	// can't read the original filesystem.
+	tmpDir := t.TempDir()
+	require.NoError(t, os.WriteFile(path.Join(tmpDir, emptyFile), []byte{}, 0o600))
+	dirFS := os.DirFS(tmpDir)
+
+	tests := []struct {
+		name string
+		fs   fs.FS
+	}{
+		{name: "os.DirFS", fs: dirFS},
+		{name: "embed.FS", fs: embedFS},
+		{name: "fstest.MapFS", fs: mapFS},
+	}
+
+	buf := make([]byte, 3)
+
+	for _, tc := range tests {
+		tc := tc
+
+		t.Run(tc.name, func(t *testing.T) {
+			f, err := tc.fs.Open(emptyFile)
+			require.NoError(t, err)
+			defer f.Close()
+
+			var r io.Reader = f
+			ra := ReaderAtOffset(f, 0)
+
+			requireRead3 := func(r io.Reader, buf []byte) {
+				n, err := r.Read(buf)
+				require.Equal(t, err, io.EOF)
+				require.Equal(t, 0, n) // file is empty
+			}
+
+			// The file should work as a reader (base case)
+			requireRead3(r, buf)
+
+			// The readerAt impl should be able to start from zero also
+			requireRead3(ra, buf)
+		})
+	}
+}
+
+func TestReaderAtOffset_Unsupported(t *testing.T) {
+	embedFS, err := fs.Sub(readerAtFS, "testdata")
+	require.NoError(t, err)
+
+	f, err := embedFS.Open(emptyFile)
+	require.NoError(t, err)
+	defer f.Close()
+
+	// mask both io.ReaderAt and io.Seeker
+	ra := ReaderAtOffset(struct{ fs.File }{f}, 0)
+
+	buf := make([]byte, 3)
+	_, err = ra.Read(buf)
+	require.Equal(t, syscall.ENOSYS, err)
+}

internal/syscallfs/testdata/wazero.txt

@@ -0,0 +1 @@
+wazero