diff options
Diffstat (limited to 'vendor/github.com/tetratelabs/wazero/internal/sysfs')
62 files changed, 0 insertions, 3549 deletions
diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/adapter.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/adapter.go deleted file mode 100644 index 51a9a5480..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/adapter.go +++ /dev/null @@ -1,105 +0,0 @@ -package sysfs - -import ( - "fmt" - "io/fs" - "path" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/sys" -) - -type AdaptFS struct { - FS fs.FS -} - -// String implements fmt.Stringer -func (a *AdaptFS) String() string { - return fmt.Sprintf("%v", a.FS) -} - -// OpenFile implements the same method as documented on sys.FS -func (a *AdaptFS) OpenFile(path string, flag experimentalsys.Oflag, perm fs.FileMode) (experimentalsys.File, experimentalsys.Errno) { - return OpenFSFile(a.FS, cleanPath(path), flag, perm) -} - -// Lstat implements the same method as documented on sys.FS -func (a *AdaptFS) Lstat(path string) (sys.Stat_t, experimentalsys.Errno) { - // At this time, we make the assumption sys.FS instances do not support - // symbolic links, therefore Lstat is the same as Stat. This is obviously - // not true, but until FS.FS has a solid story for how to handle symlinks, - // we are better off not making a decision that would be difficult to - // revert later on. - // - // For further discussions on the topic, see: - // https://github.com/golang/go/issues/49580 - return a.Stat(path) -} - -// Stat implements the same method as documented on sys.FS -func (a *AdaptFS) Stat(path string) (sys.Stat_t, experimentalsys.Errno) { - f, errno := a.OpenFile(path, experimentalsys.O_RDONLY, 0) - if errno != 0 { - return sys.Stat_t{}, errno - } - defer f.Close() - return f.Stat() -} - -// Readlink implements the same method as documented on sys.FS -func (a *AdaptFS) Readlink(string) (string, experimentalsys.Errno) { - return "", experimentalsys.ENOSYS -} - -// Mkdir implements the same method as documented on sys.FS -func (a *AdaptFS) Mkdir(string, fs.FileMode) experimentalsys.Errno { - return experimentalsys.ENOSYS -} - -// Chmod implements the same method as documented on sys.FS -func (a *AdaptFS) Chmod(string, fs.FileMode) experimentalsys.Errno { - return experimentalsys.ENOSYS -} - -// Rename implements the same method as documented on sys.FS -func (a *AdaptFS) Rename(string, string) experimentalsys.Errno { - return experimentalsys.ENOSYS -} - -// Rmdir implements the same method as documented on sys.FS -func (a *AdaptFS) Rmdir(string) experimentalsys.Errno { - return experimentalsys.ENOSYS -} - -// Link implements the same method as documented on sys.FS -func (a *AdaptFS) Link(string, string) experimentalsys.Errno { - return experimentalsys.ENOSYS -} - -// Symlink implements the same method as documented on sys.FS -func (a *AdaptFS) Symlink(string, string) experimentalsys.Errno { - return experimentalsys.ENOSYS -} - -// Unlink implements the same method as documented on sys.FS -func (a *AdaptFS) Unlink(string) experimentalsys.Errno { - return experimentalsys.ENOSYS -} - -// Utimens implements the same method as documented on sys.FS -func (a *AdaptFS) Utimens(string, int64, int64) experimentalsys.Errno { - return experimentalsys.ENOSYS -} - -func cleanPath(name string) string { - if len(name) == 0 { - return name - } - // fs.ValidFile cannot be rooted (start with '/') - cleaned := name - if name[0] == '/' { - cleaned = name[1:] - } - cleaned = path.Clean(cleaned) // e.g. "sub/." -> "sub" - return cleaned -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/datasync_linux.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/datasync_linux.go deleted file mode 100644 index 5a8a415c5..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/datasync_linux.go +++ /dev/null @@ -1,14 +0,0 @@ -//go:build linux && !tinygo - -package sysfs - -import ( - "os" - "syscall" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func datasync(f *os.File) sys.Errno { - return sys.UnwrapOSError(syscall.Fdatasync(int(f.Fd()))) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/datasync_tinygo.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/datasync_tinygo.go deleted file mode 100644 index e58fc9142..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/datasync_tinygo.go +++ /dev/null @@ -1,13 +0,0 @@ -//go:build tinygo - -package sysfs - -import ( - "os" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func datasync(f *os.File) sys.Errno { - return sys.ENOSYS -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/datasync_unsupported.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/datasync_unsupported.go deleted file mode 100644 index aa05719be..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/datasync_unsupported.go +++ /dev/null @@ -1,14 +0,0 @@ -//go:build !linux - -package sysfs - -import ( - "os" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func datasync(f *os.File) sys.Errno { - // Attempt to sync everything, even if we only need to sync the data. - return fsync(f) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/dir.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/dir.go deleted file mode 100644 index f9823287c..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/dir.go +++ /dev/null @@ -1,24 +0,0 @@ -package sysfs - -import ( - "io" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func adjustReaddirErr(f sys.File, isClosed bool, err error) sys.Errno { - if err == io.EOF { - return 0 // e.g. Readdir on darwin returns io.EOF, but linux doesn't. - } else if errno := sys.UnwrapOSError(err); errno != 0 { - errno = dirError(f, isClosed, errno) - // Comply with errors allowed on sys.File Readdir - switch errno { - case sys.EINVAL: // os.File Readdir can return this - return sys.EBADF - case sys.ENOTDIR: // dirError can return this - return sys.EBADF - } - return errno - } - return 0 -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/dirfs.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/dirfs.go deleted file mode 100644 index 04384038f..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/dirfs.go +++ /dev/null @@ -1,99 +0,0 @@ -package sysfs - -import ( - "io/fs" - "os" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/internal/platform" - "github.com/tetratelabs/wazero/sys" -) - -func DirFS(dir string) experimentalsys.FS { - return &dirFS{ - dir: dir, - cleanedDir: ensureTrailingPathSeparator(dir), - } -} - -func ensureTrailingPathSeparator(dir string) string { - if !os.IsPathSeparator(dir[len(dir)-1]) { - return dir + string(os.PathSeparator) - } - return dir -} - -// dirFS is not exported because the input fields must be maintained together. -// This is likely why os.DirFS doesn't, either! -type dirFS struct { - experimentalsys.UnimplementedFS - - dir string - // cleanedDir is for easier OS-specific concatenation, as it always has - // a trailing path separator. - cleanedDir string -} - -// String implements fmt.Stringer -func (d *dirFS) String() string { - return d.dir -} - -// OpenFile implements the same method as documented on sys.FS -func (d *dirFS) OpenFile(path string, flag experimentalsys.Oflag, perm fs.FileMode) (experimentalsys.File, experimentalsys.Errno) { - return OpenOSFile(d.join(path), flag, perm) -} - -// Lstat implements the same method as documented on sys.FS -func (d *dirFS) Lstat(path string) (sys.Stat_t, experimentalsys.Errno) { - return lstat(d.join(path)) -} - -// Stat implements the same method as documented on sys.FS -func (d *dirFS) Stat(path string) (sys.Stat_t, experimentalsys.Errno) { - return stat(d.join(path)) -} - -// Mkdir implements the same method as documented on sys.FS -func (d *dirFS) Mkdir(path string, perm fs.FileMode) (errno experimentalsys.Errno) { - err := os.Mkdir(d.join(path), perm) - if errno = experimentalsys.UnwrapOSError(err); errno == experimentalsys.ENOTDIR { - errno = experimentalsys.ENOENT - } - return -} - -// Readlink implements the same method as documented on sys.FS -func (d *dirFS) Readlink(path string) (string, experimentalsys.Errno) { - // Note: do not use syscall.Readlink as that causes race on Windows. - // In any case, syscall.Readlink does almost the same logic as os.Readlink. - dst, err := os.Readlink(d.join(path)) - if err != nil { - return "", experimentalsys.UnwrapOSError(err) - } - return platform.ToPosixPath(dst), 0 -} - -// Rmdir implements the same method as documented on sys.FS -func (d *dirFS) Rmdir(path string) experimentalsys.Errno { - return rmdir(d.join(path)) -} - -// Utimens implements the same method as documented on sys.FS -func (d *dirFS) Utimens(path string, atim, mtim int64) experimentalsys.Errno { - return utimens(d.join(path), atim, mtim) -} - -func (d *dirFS) join(path string) string { - switch path { - case "", ".", "/": - if d.cleanedDir == "/" { - return "/" - } - // cleanedDir includes an unnecessary delimiter for the root path. - return d.cleanedDir[:len(d.cleanedDir)-1] - } - // TODO: Enforce similar to safefilepath.FromFS(path), but be careful as - // relative path inputs are allowed. e.g. dir or path == ../ - return d.cleanedDir + path -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/dirfs_supported.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/dirfs_supported.go deleted file mode 100644 index a949bd54d..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/dirfs_supported.go +++ /dev/null @@ -1,48 +0,0 @@ -//go:build !tinygo - -package sysfs - -import ( - "io/fs" - "os" - "path" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" -) - -// Link implements the same method as documented on sys.FS -func (d *dirFS) Link(oldName, newName string) experimentalsys.Errno { - err := os.Link(d.join(oldName), d.join(newName)) - return experimentalsys.UnwrapOSError(err) -} - -// Unlink implements the same method as documented on sys.FS -func (d *dirFS) Unlink(path string) (err experimentalsys.Errno) { - return unlink(d.join(path)) -} - -// Rename implements the same method as documented on sys.FS -func (d *dirFS) Rename(from, to string) experimentalsys.Errno { - from, to = d.join(from), d.join(to) - return rename(from, to) -} - -// Chmod implements the same method as documented on sys.FS -func (d *dirFS) Chmod(path string, perm fs.FileMode) experimentalsys.Errno { - err := os.Chmod(d.join(path), perm) - return experimentalsys.UnwrapOSError(err) -} - -// Symlink implements the same method as documented on sys.FS -func (d *dirFS) Symlink(oldName, link string) experimentalsys.Errno { - // Creating a symlink with an absolute path string fails with a "not permitted" error. - // https://github.com/WebAssembly/wasi-filesystem/blob/v0.2.0/path-resolution.md#symlinks - if path.IsAbs(oldName) { - return experimentalsys.EPERM - } - // Note: do not resolve `oldName` relative to this dirFS. The link result is always resolved - // when dereference the `link` on its usage (e.g. readlink, read, etc). - // https://github.com/bytecodealliance/cap-std/blob/v1.0.4/cap-std/src/fs/dir.rs#L404-L409 - err := os.Symlink(oldName, d.join(link)) - return experimentalsys.UnwrapOSError(err) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/dirfs_unsupported.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/dirfs_unsupported.go deleted file mode 100644 index 98b1a3b84..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/dirfs_unsupported.go +++ /dev/null @@ -1,34 +0,0 @@ -//go:build tinygo - -package sysfs - -import ( - "io/fs" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" -) - -// Link implements the same method as documented on sys.FS -func (d *dirFS) Link(oldName, newName string) experimentalsys.Errno { - return experimentalsys.ENOSYS -} - -// Unlink implements the same method as documented on sys.FS -func (d *dirFS) Unlink(path string) (err experimentalsys.Errno) { - return experimentalsys.ENOSYS -} - -// Rename implements the same method as documented on sys.FS -func (d *dirFS) Rename(from, to string) experimentalsys.Errno { - return experimentalsys.ENOSYS -} - -// Chmod implements the same method as documented on sys.FS -func (d *dirFS) Chmod(path string, perm fs.FileMode) experimentalsys.Errno { - return experimentalsys.ENOSYS -} - -// Symlink implements the same method as documented on sys.FS -func (d *dirFS) Symlink(oldName, link string) experimentalsys.Errno { - return experimentalsys.ENOSYS -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/file.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/file.go deleted file mode 100644 index 1b6d5f3de..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/file.go +++ /dev/null @@ -1,523 +0,0 @@ -package sysfs - -import ( - "io" - "io/fs" - "os" - "time" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/internal/fsapi" - "github.com/tetratelabs/wazero/sys" -) - -func NewStdioFile(stdin bool, f fs.File) (fsapi.File, error) { - // Return constant stat, which has fake times, but keep the underlying - // file mode. Fake times are needed to pass wasi-testsuite. - // https://github.com/WebAssembly/wasi-testsuite/blob/af57727/tests/rust/src/bin/fd_filestat_get.rs#L1-L19 - var mode fs.FileMode - if st, err := f.Stat(); err != nil { - return nil, err - } else { - mode = st.Mode() - } - var flag experimentalsys.Oflag - if stdin { - flag = experimentalsys.O_RDONLY - } else { - flag = experimentalsys.O_WRONLY - } - var file fsapi.File - if of, ok := f.(*os.File); ok { - // This is ok because functions that need path aren't used by stdioFile - file = newOsFile("", flag, 0, of) - } else { - file = &fsFile{file: f} - } - return &stdioFile{File: file, st: sys.Stat_t{Mode: mode, Nlink: 1}}, nil -} - -func OpenFile(path string, flag experimentalsys.Oflag, perm fs.FileMode) (*os.File, experimentalsys.Errno) { - return openFile(path, flag, perm) -} - -func OpenOSFile(path string, flag experimentalsys.Oflag, perm fs.FileMode) (experimentalsys.File, experimentalsys.Errno) { - f, errno := OpenFile(path, flag, perm) - if errno != 0 { - return nil, errno - } - return newOsFile(path, flag, perm, f), 0 -} - -func OpenFSFile(fs fs.FS, path string, flag experimentalsys.Oflag, perm fs.FileMode) (experimentalsys.File, experimentalsys.Errno) { - if flag&experimentalsys.O_DIRECTORY != 0 && flag&(experimentalsys.O_WRONLY|experimentalsys.O_RDWR) != 0 { - return nil, experimentalsys.EISDIR // invalid to open a directory writeable - } - f, err := fs.Open(path) - if errno := experimentalsys.UnwrapOSError(err); errno != 0 { - return nil, errno - } - // Don't return an os.File because the path is not absolute. osFile needs - // the path to be real and certain FS.File impls are subrooted. - return &fsFile{fs: fs, name: path, file: f}, 0 -} - -type stdioFile struct { - fsapi.File - st sys.Stat_t -} - -// SetAppend implements File.SetAppend -func (f *stdioFile) SetAppend(bool) experimentalsys.Errno { - // Ignore for stdio. - return 0 -} - -// IsAppend implements File.SetAppend -func (f *stdioFile) IsAppend() bool { - return true -} - -// Stat implements File.Stat -func (f *stdioFile) Stat() (sys.Stat_t, experimentalsys.Errno) { - return f.st, 0 -} - -// Close implements File.Close -func (f *stdioFile) Close() experimentalsys.Errno { - return 0 -} - -// fsFile is used for wrapped fs.File, like os.Stdin or any fs.File -// implementation. Notably, this does not have access to the full file path. -// so certain operations can't be supported, such as inode lookups on Windows. -type fsFile struct { - experimentalsys.UnimplementedFile - - // fs is the file-system that opened the file, or nil when wrapped for - // pre-opens like stdio. - fs fs.FS - - // name is what was used in fs for Open, so it may not be the actual path. - name string - - // file is always set, possibly an os.File like os.Stdin. - file fs.File - - // reopenDir is true if reopen should be called before Readdir. This flag - // is deferred until Readdir to prevent redundant rewinds. This could - // happen if Seek(0) was called twice, or if in Windows, Seek(0) was called - // before Readdir. - reopenDir bool - - // closed is true when closed was called. This ensures proper sys.EBADF - closed bool - - // cachedStat includes fields that won't change while a file is open. - cachedSt *cachedStat -} - -type cachedStat struct { - // dev is the same as sys.Stat_t Dev. - dev uint64 - - // dev is the same as sys.Stat_t Ino. - ino sys.Inode - - // isDir is sys.Stat_t Mode masked with fs.ModeDir - isDir bool -} - -// cachedStat returns the cacheable parts of sys.Stat_t or an error if they -// couldn't be retrieved. -func (f *fsFile) cachedStat() (dev uint64, ino sys.Inode, isDir bool, errno experimentalsys.Errno) { - if f.cachedSt == nil { - if _, errno = f.Stat(); errno != 0 { - return - } - } - return f.cachedSt.dev, f.cachedSt.ino, f.cachedSt.isDir, 0 -} - -// Dev implements the same method as documented on sys.File -func (f *fsFile) Dev() (uint64, experimentalsys.Errno) { - dev, _, _, errno := f.cachedStat() - return dev, errno -} - -// Ino implements the same method as documented on sys.File -func (f *fsFile) Ino() (sys.Inode, experimentalsys.Errno) { - _, ino, _, errno := f.cachedStat() - return ino, errno -} - -// IsDir implements the same method as documented on sys.File -func (f *fsFile) IsDir() (bool, experimentalsys.Errno) { - _, _, isDir, errno := f.cachedStat() - return isDir, errno -} - -// IsAppend implements the same method as documented on sys.File -func (f *fsFile) IsAppend() bool { - return false -} - -// SetAppend implements the same method as documented on sys.File -func (f *fsFile) SetAppend(bool) (errno experimentalsys.Errno) { - return fileError(f, f.closed, experimentalsys.ENOSYS) -} - -// Stat implements the same method as documented on sys.File -func (f *fsFile) Stat() (sys.Stat_t, experimentalsys.Errno) { - if f.closed { - return sys.Stat_t{}, experimentalsys.EBADF - } - - st, errno := statFile(f.file) - switch errno { - case 0: - f.cachedSt = &cachedStat{dev: st.Dev, ino: st.Ino, isDir: st.Mode&fs.ModeDir == fs.ModeDir} - case experimentalsys.EIO: - errno = experimentalsys.EBADF - } - return st, errno -} - -// Read implements the same method as documented on sys.File -func (f *fsFile) Read(buf []byte) (n int, errno experimentalsys.Errno) { - if n, errno = read(f.file, buf); errno != 0 { - // Defer validation overhead until we've already had an error. - errno = fileError(f, f.closed, errno) - } - return -} - -// Pread implements the same method as documented on sys.File -func (f *fsFile) Pread(buf []byte, off int64) (n int, errno experimentalsys.Errno) { - if ra, ok := f.file.(io.ReaderAt); ok { - if n, errno = pread(ra, buf, off); errno != 0 { - // Defer validation overhead until we've already had an error. - errno = fileError(f, f.closed, errno) - } - return - } - - // See /RATIONALE.md "fd_pread: io.Seeker fallback when io.ReaderAt is not supported" - if rs, ok := f.file.(io.ReadSeeker); ok { - // Determine the current position in the file, as we need to revert it. - currentOffset, err := rs.Seek(0, io.SeekCurrent) - if err != nil { - return 0, fileError(f, f.closed, experimentalsys.UnwrapOSError(err)) - } - - // Put the read position back when complete. - defer func() { _, _ = rs.Seek(currentOffset, io.SeekStart) }() - - // If the current offset isn't in sync with this reader, move it. - if off != currentOffset { - if _, err = rs.Seek(off, io.SeekStart); err != nil { - return 0, fileError(f, f.closed, experimentalsys.UnwrapOSError(err)) - } - } - - n, err = rs.Read(buf) - if errno = experimentalsys.UnwrapOSError(err); errno != 0 { - // Defer validation overhead until we've already had an error. - errno = fileError(f, f.closed, errno) - } - } else { - errno = experimentalsys.ENOSYS // unsupported - } - return -} - -// Seek implements the same method as documented on sys.File -func (f *fsFile) Seek(offset int64, whence int) (newOffset int64, errno experimentalsys.Errno) { - // If this is a directory, and we're attempting to seek to position zero, - // we have to re-open the file to ensure the directory state is reset. - var isDir bool - if offset == 0 && whence == io.SeekStart { - if isDir, errno = f.IsDir(); errno == 0 && isDir { - f.reopenDir = true - return - } - } - - if s, ok := f.file.(io.Seeker); ok { - if newOffset, errno = seek(s, offset, whence); errno != 0 { - // Defer validation overhead until we've already had an error. - errno = fileError(f, f.closed, errno) - } - } else { - errno = experimentalsys.ENOSYS // unsupported - } - return -} - -// Readdir implements the same method as documented on sys.File -// -// Notably, this uses readdirFile or fs.ReadDirFile if available. This does not -// return inodes on windows. -func (f *fsFile) Readdir(n int) (dirents []experimentalsys.Dirent, errno experimentalsys.Errno) { - // Windows lets you Readdir after close, FS.File also may not implement - // close in a meaningful way. read our closed field to return consistent - // results. - if f.closed { - errno = experimentalsys.EBADF - return - } - - if f.reopenDir { // re-open the directory if needed. - f.reopenDir = false - if errno = adjustReaddirErr(f, f.closed, f.rewindDir()); errno != 0 { - return - } - } - - if of, ok := f.file.(readdirFile); ok { - // We can't use f.name here because it is the path up to the sys.FS, - // not necessarily the real path. For this reason, Windows may not be - // able to populate inodes. However, Darwin and Linux will. - if dirents, errno = readdir(of, "", n); errno != 0 { - errno = adjustReaddirErr(f, f.closed, errno) - } - return - } - - // Try with FS.ReadDirFile which is available on api.FS implementations - // like embed:FS. - if rdf, ok := f.file.(fs.ReadDirFile); ok { - entries, e := rdf.ReadDir(n) - if errno = adjustReaddirErr(f, f.closed, e); errno != 0 { - return - } - dirents = make([]experimentalsys.Dirent, 0, len(entries)) - for _, e := range entries { - // By default, we don't attempt to read inode data - dirents = append(dirents, experimentalsys.Dirent{Name: e.Name(), Type: e.Type()}) - } - } else { - errno = experimentalsys.EBADF // not a directory - } - return -} - -// Write implements the same method as documented on sys.File. -func (f *fsFile) Write(buf []byte) (n int, errno experimentalsys.Errno) { - if w, ok := f.file.(io.Writer); ok { - if n, errno = write(w, buf); errno != 0 { - // Defer validation overhead until we've already had an error. - errno = fileError(f, f.closed, errno) - } - } else { - errno = experimentalsys.ENOSYS // unsupported - } - return -} - -// Pwrite implements the same method as documented on sys.File. -func (f *fsFile) Pwrite(buf []byte, off int64) (n int, errno experimentalsys.Errno) { - if wa, ok := f.file.(io.WriterAt); ok { - if n, errno = pwrite(wa, buf, off); errno != 0 { - // Defer validation overhead until we've already had an error. - errno = fileError(f, f.closed, errno) - } - } else { - errno = experimentalsys.ENOSYS // unsupported - } - return -} - -// Close implements the same method as documented on sys.File. -func (f *fsFile) Close() experimentalsys.Errno { - if f.closed { - return 0 - } - f.closed = true - return f.close() -} - -func (f *fsFile) close() experimentalsys.Errno { - return experimentalsys.UnwrapOSError(f.file.Close()) -} - -// IsNonblock implements the same method as documented on fsapi.File -func (f *fsFile) IsNonblock() bool { - return false -} - -// SetNonblock implements the same method as documented on fsapi.File -func (f *fsFile) SetNonblock(bool) experimentalsys.Errno { - return experimentalsys.ENOSYS -} - -// Poll implements the same method as documented on fsapi.File -func (f *fsFile) Poll(fsapi.Pflag, int32) (ready bool, errno experimentalsys.Errno) { - return false, experimentalsys.ENOSYS -} - -// dirError is used for commands that work against a directory, but not a file. -func dirError(f experimentalsys.File, isClosed bool, errno experimentalsys.Errno) experimentalsys.Errno { - if vErrno := validate(f, isClosed, false, true); vErrno != 0 { - return vErrno - } - return errno -} - -// fileError is used for commands that work against a file, but not a directory. -func fileError(f experimentalsys.File, isClosed bool, errno experimentalsys.Errno) experimentalsys.Errno { - if vErrno := validate(f, isClosed, true, false); vErrno != 0 { - return vErrno - } - return errno -} - -// validate is used to making syscalls which will fail. -func validate(f experimentalsys.File, isClosed, wantFile, wantDir bool) experimentalsys.Errno { - if isClosed { - return experimentalsys.EBADF - } - - isDir, errno := f.IsDir() - if errno != 0 { - return errno - } - - if wantFile && isDir { - return experimentalsys.EISDIR - } else if wantDir && !isDir { - return experimentalsys.ENOTDIR - } - return 0 -} - -func read(r io.Reader, buf []byte) (n int, errno experimentalsys.Errno) { - if len(buf) == 0 { - return 0, 0 // less overhead on zero-length reads. - } - - n, err := r.Read(buf) - return n, experimentalsys.UnwrapOSError(err) -} - -func pread(ra io.ReaderAt, buf []byte, off int64) (n int, errno experimentalsys.Errno) { - if len(buf) == 0 { - return 0, 0 // less overhead on zero-length reads. - } - - n, err := ra.ReadAt(buf, off) - return n, experimentalsys.UnwrapOSError(err) -} - -func seek(s io.Seeker, offset int64, whence int) (int64, experimentalsys.Errno) { - if uint(whence) > io.SeekEnd { - return 0, experimentalsys.EINVAL // negative or exceeds the largest valid whence - } - - newOffset, err := s.Seek(offset, whence) - return newOffset, experimentalsys.UnwrapOSError(err) -} - -func (f *fsFile) rewindDir() experimentalsys.Errno { - // Reopen the directory to rewind it. - file, err := f.fs.Open(f.name) - if err != nil { - return experimentalsys.UnwrapOSError(err) - } - fi, err := file.Stat() - if err != nil { - return experimentalsys.UnwrapOSError(err) - } - // Can't check if it's still the same file, - // but is it still a directory, at least? - if !fi.IsDir() { - return experimentalsys.ENOTDIR - } - // Only update f on success. - _ = f.file.Close() - f.file = file - return 0 -} - -// readdirFile allows masking the `Readdir` function on os.File. -type readdirFile interface { - Readdir(n int) ([]fs.FileInfo, error) -} - -// readdir uses readdirFile.Readdir, special casing windows when path !="". -func readdir(f readdirFile, path string, n int) (dirents []experimentalsys.Dirent, errno experimentalsys.Errno) { - fis, e := f.Readdir(n) - if errno = experimentalsys.UnwrapOSError(e); errno != 0 { - return - } - - dirents = make([]experimentalsys.Dirent, 0, len(fis)) - - // linux/darwin won't have to fan out to lstat, but windows will. - var ino sys.Inode - for fi := range fis { - t := fis[fi] - // inoFromFileInfo is more efficient than sys.NewStat_t, as it gets the - // inode without allocating an instance and filling other fields. - if ino, errno = inoFromFileInfo(path, t); errno != 0 { - return - } - dirents = append(dirents, experimentalsys.Dirent{Name: t.Name(), Ino: ino, Type: t.Mode().Type()}) - } - return -} - -func write(w io.Writer, buf []byte) (n int, errno experimentalsys.Errno) { - if len(buf) == 0 { - return 0, 0 // less overhead on zero-length writes. - } - - n, err := w.Write(buf) - return n, experimentalsys.UnwrapOSError(err) -} - -func pwrite(w io.WriterAt, buf []byte, off int64) (n int, errno experimentalsys.Errno) { - if len(buf) == 0 { - return 0, 0 // less overhead on zero-length writes. - } - - n, err := w.WriteAt(buf, off) - return n, experimentalsys.UnwrapOSError(err) -} - -func chtimes(path string, atim, mtim int64) (errno experimentalsys.Errno) { //nolint:unused - // When both inputs are omitted, there is nothing to change. - if atim == experimentalsys.UTIME_OMIT && mtim == experimentalsys.UTIME_OMIT { - return - } - - // UTIME_OMIT is expensive until progress is made in Go, as it requires a - // stat to read-back the value to re-apply. - // - https://github.com/golang/go/issues/32558. - // - https://go-review.googlesource.com/c/go/+/219638 (unmerged) - var st sys.Stat_t - if atim == experimentalsys.UTIME_OMIT || mtim == experimentalsys.UTIME_OMIT { - if st, errno = stat(path); errno != 0 { - return - } - } - - var atime, mtime time.Time - if atim == experimentalsys.UTIME_OMIT { - atime = epochNanosToTime(st.Atim) - mtime = epochNanosToTime(mtim) - } else if mtim == experimentalsys.UTIME_OMIT { - atime = epochNanosToTime(atim) - mtime = epochNanosToTime(st.Mtim) - } else { - atime = epochNanosToTime(atim) - mtime = epochNanosToTime(mtim) - } - return experimentalsys.UnwrapOSError(os.Chtimes(path, atime, mtime)) -} - -func epochNanosToTime(epochNanos int64) time.Time { //nolint:unused - seconds := epochNanos / 1e9 - nanos := epochNanos % 1e9 - return time.Unix(seconds, nanos) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/file_unix.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/file_unix.go deleted file mode 100644 index f201e813d..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/file_unix.go +++ /dev/null @@ -1,39 +0,0 @@ -//go:build unix && !tinygo - -package sysfs - -import ( - "syscall" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -const ( - nonBlockingFileReadSupported = true - nonBlockingFileWriteSupported = true -) - -func rmdir(path string) sys.Errno { - err := syscall.Rmdir(path) - return sys.UnwrapOSError(err) -} - -// readFd exposes syscall.Read. -func readFd(fd uintptr, buf []byte) (int, sys.Errno) { - if len(buf) == 0 { - return 0, 0 // Short-circuit 0-len reads. - } - n, err := syscall.Read(int(fd), buf) - errno := sys.UnwrapOSError(err) - return n, errno -} - -// writeFd exposes syscall.Write. -func writeFd(fd uintptr, buf []byte) (int, sys.Errno) { - if len(buf) == 0 { - return 0, 0 // Short-circuit 0-len writes. - } - n, err := syscall.Write(int(fd), buf) - errno := sys.UnwrapOSError(err) - return n, errno -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/file_unsupported.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/file_unsupported.go deleted file mode 100644 index a028b9479..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/file_unsupported.go +++ /dev/null @@ -1,28 +0,0 @@ -//go:build !(unix || windows) || tinygo - -package sysfs - -import ( - "os" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -const ( - nonBlockingFileReadSupported = false - nonBlockingFileWriteSupported = false -) - -func rmdir(path string) sys.Errno { - return sys.UnwrapOSError(os.Remove(path)) -} - -// readFd returns ENOSYS on unsupported platforms. -func readFd(fd uintptr, buf []byte) (int, sys.Errno) { - return -1, sys.ENOSYS -} - -// writeFd returns ENOSYS on unsupported platforms. -func writeFd(fd uintptr, buf []byte) (int, sys.Errno) { - return -1, sys.ENOSYS -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/file_windows.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/file_windows.go deleted file mode 100644 index 37870ea36..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/file_windows.go +++ /dev/null @@ -1,175 +0,0 @@ -package sysfs - -import ( - "errors" - "syscall" - "unsafe" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -const ( - nonBlockingFileReadSupported = true - nonBlockingFileWriteSupported = false - - _ERROR_IO_INCOMPLETE = syscall.Errno(996) -) - -var kernel32 = syscall.NewLazyDLL("kernel32.dll") - -// procPeekNamedPipe is the syscall.LazyProc in kernel32 for PeekNamedPipe -var ( - // procPeekNamedPipe is the syscall.LazyProc in kernel32 for PeekNamedPipe - procPeekNamedPipe = kernel32.NewProc("PeekNamedPipe") - // procGetOverlappedResult is the syscall.LazyProc in kernel32 for GetOverlappedResult - procGetOverlappedResult = kernel32.NewProc("GetOverlappedResult") - // procCreateEventW is the syscall.LazyProc in kernel32 for CreateEventW - procCreateEventW = kernel32.NewProc("CreateEventW") -) - -// readFd returns ENOSYS on unsupported platforms. -// -// PeekNamedPipe: https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-peeknamedpipe -// "GetFileType can assist in determining what device type the handle refers to. A console handle presents as FILE_TYPE_CHAR." -// https://learn.microsoft.com/en-us/windows/console/console-handles -func readFd(fd uintptr, buf []byte) (int, sys.Errno) { - handle := syscall.Handle(fd) - fileType, err := syscall.GetFileType(handle) - if err != nil { - return 0, sys.UnwrapOSError(err) - } - if fileType&syscall.FILE_TYPE_CHAR == 0 { - return -1, sys.ENOSYS - } - n, errno := peekNamedPipe(handle) - if errno == syscall.ERROR_BROKEN_PIPE { - return 0, 0 - } - if n == 0 { - return -1, sys.EAGAIN - } - un, err := syscall.Read(handle, buf[0:n]) - return un, sys.UnwrapOSError(err) -} - -func writeFd(fd uintptr, buf []byte) (int, sys.Errno) { - return -1, sys.ENOSYS -} - -func readSocket(h uintptr, buf []byte) (int, sys.Errno) { - // Poll the socket to ensure that we never perform a blocking/overlapped Read. - // - // When the socket is closed by the remote peer, wsaPoll will return n=1 and - // errno=0, and syscall.ReadFile will return n=0 and errno=0 -- which indicates - // io.EOF. - if n, errno := wsaPoll( - []pollFd{newPollFd(h, _POLLIN, 0)}, 0); !errors.Is(errno, sys.Errno(0)) { - return 0, sys.UnwrapOSError(errno) - } else if n <= 0 { - return 0, sys.EAGAIN - } - - // Properly use overlapped result. - // - // If hFile was opened with FILE_FLAG_OVERLAPPED, the following conditions are in effect: - // - The lpOverlapped parameter must point to a valid and unique OVERLAPPED structure, - // otherwise the function can incorrectly report that the read operation is complete. - // - The lpNumberOfBytesRead parameter should be set to NULL. Use the GetOverlappedResult - // function to get the actual number of bytes read. If the hFile parameter is associated - // with an I/O completion port, you can also get the number of bytes read by calling the - // GetQueuedCompletionStatus function. - // - // We are currently skipping checking if hFile was opened with FILE_FLAG_OVERLAPPED but using - // both lpOverlapped and lpNumberOfBytesRead. - var overlapped syscall.Overlapped - - // Create an event to wait on. - if hEvent, err := createEventW(nil, true, false, nil); err != 0 { - return 0, sys.UnwrapOSError(err) - } else { - overlapped.HEvent = syscall.Handle(hEvent) - } - - var done uint32 - errno := syscall.ReadFile(syscall.Handle(h), buf, &done, &overlapped) - if errors.Is(errno, syscall.ERROR_IO_PENDING) { - errno = syscall.CancelIo(syscall.Handle(h)) - if errno != nil { - return 0, sys.UnwrapOSError(errno) // This is a fatal error. CancelIo failed. - } - - done, errno = getOverlappedResult(syscall.Handle(h), &overlapped, true) // wait for I/O to complete(cancel or finish). Overwrite done and errno. - if errors.Is(errno, syscall.ERROR_OPERATION_ABORTED) { - return int(done), sys.EAGAIN // This is one of the expected behavior, I/O was cancelled(completed) before finished. - } - } - - return int(done), sys.UnwrapOSError(errno) -} - -func writeSocket(fd uintptr, buf []byte) (int, sys.Errno) { - var done uint32 - var overlapped syscall.Overlapped - errno := syscall.WriteFile(syscall.Handle(fd), buf, &done, &overlapped) - if errors.Is(errno, syscall.ERROR_IO_PENDING) { - errno = syscall.EAGAIN - } - return int(done), sys.UnwrapOSError(errno) -} - -// peekNamedPipe partially exposes PeekNamedPipe from the Win32 API -// see https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-peeknamedpipe -func peekNamedPipe(handle syscall.Handle) (uint32, syscall.Errno) { - var totalBytesAvail uint32 - totalBytesPtr := unsafe.Pointer(&totalBytesAvail) - _, _, errno := syscall.SyscallN( - procPeekNamedPipe.Addr(), - uintptr(handle), // [in] HANDLE hNamedPipe, - 0, // [out, optional] LPVOID lpBuffer, - 0, // [in] DWORD nBufferSize, - 0, // [out, optional] LPDWORD lpBytesRead - uintptr(totalBytesPtr), // [out, optional] LPDWORD lpTotalBytesAvail, - 0) // [out, optional] LPDWORD lpBytesLeftThisMessage - return totalBytesAvail, errno -} - -func rmdir(path string) sys.Errno { - err := syscall.Rmdir(path) - return sys.UnwrapOSError(err) -} - -func getOverlappedResult(handle syscall.Handle, overlapped *syscall.Overlapped, wait bool) (uint32, syscall.Errno) { - var totalBytesAvail uint32 - var bwait uintptr - if wait { - bwait = 0xFFFFFFFF - } - totalBytesPtr := unsafe.Pointer(&totalBytesAvail) - _, _, errno := syscall.SyscallN( - procGetOverlappedResult.Addr(), - uintptr(handle), // [in] HANDLE hFile, - uintptr(unsafe.Pointer(overlapped)), // [in] LPOVERLAPPED lpOverlapped, - uintptr(totalBytesPtr), // [out] LPDWORD lpNumberOfBytesTransferred, - bwait) // [in] BOOL bWait - return totalBytesAvail, errno -} - -func createEventW(lpEventAttributes *syscall.SecurityAttributes, bManualReset bool, bInitialState bool, lpName *uint16) (uintptr, syscall.Errno) { - var manualReset uintptr - var initialState uintptr - if bManualReset { - manualReset = 1 - } - if bInitialState { - initialState = 1 - } - handle, _, errno := syscall.SyscallN( - procCreateEventW.Addr(), - uintptr(unsafe.Pointer(lpEventAttributes)), // [in] LPSECURITY_ATTRIBUTES lpEventAttributes, - manualReset, // [in] BOOL bManualReset, - initialState, // [in] BOOL bInitialState, - uintptr(unsafe.Pointer(lpName)), // [in, opt]LPCWSTR lpName, - ) - - return handle, errno -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens.go deleted file mode 100644 index 7f6b11094..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens.go +++ /dev/null @@ -1,37 +0,0 @@ -//go:build (linux || darwin) && !tinygo - -package sysfs - -import ( - "syscall" - "unsafe" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func timesToPtr(times *[2]syscall.Timespec) unsafe.Pointer { //nolint:unused - if times != nil { - return unsafe.Pointer(×[0]) - } - return unsafe.Pointer(nil) -} - -func timesToTimespecs(atim int64, mtim int64) (times *[2]syscall.Timespec) { - // When both inputs are omitted, there is nothing to change. - if atim == sys.UTIME_OMIT && mtim == sys.UTIME_OMIT { - return - } - - times = &[2]syscall.Timespec{} - if atim == sys.UTIME_OMIT { - times[0] = syscall.Timespec{Nsec: _UTIME_OMIT} - times[1] = syscall.NsecToTimespec(mtim) - } else if mtim == sys.UTIME_OMIT { - times[0] = syscall.NsecToTimespec(atim) - times[1] = syscall.Timespec{Nsec: _UTIME_OMIT} - } else { - times[0] = syscall.NsecToTimespec(atim) - times[1] = syscall.NsecToTimespec(mtim) - } - return -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_darwin.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_darwin.go deleted file mode 100644 index 88e4008f0..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_darwin.go +++ /dev/null @@ -1,51 +0,0 @@ -package sysfs - -import ( - "syscall" - _ "unsafe" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" -) - -const ( - _AT_FDCWD = -0x2 - _AT_SYMLINK_NOFOLLOW = 0x0020 - _UTIME_OMIT = -2 -) - -//go:noescape -//go:linkname utimensat syscall.utimensat -func utimensat(dirfd int, path string, times *[2]syscall.Timespec, flags int) error - -func utimens(path string, atim, mtim int64) experimentalsys.Errno { - times := timesToTimespecs(atim, mtim) - if times == nil { - return 0 - } - var flags int - return experimentalsys.UnwrapOSError(utimensat(_AT_FDCWD, path, times, flags)) -} - -func futimens(fd uintptr, atim, mtim int64) experimentalsys.Errno { - times := timesToTimespecs(atim, mtim) - if times == nil { - return 0 - } - _p0 := timesToPtr(times) - - // Warning: futimens only exists since High Sierra (10.13). - _, _, e1 := syscall_syscall6(libc_futimens_trampoline_addr, fd, uintptr(_p0), 0, 0, 0, 0) - return experimentalsys.UnwrapOSError(e1) -} - -// libc_futimens_trampoline_addr is the address of the -// `libc_futimens_trampoline` symbol, defined in `futimens_darwin.s`. -// -// We use this to invoke the syscall through syscall_syscall6 imported below. -var libc_futimens_trampoline_addr uintptr - -// Imports the futimens symbol from libc as `libc_futimens`. -// -// Note: CGO mechanisms are used in darwin regardless of the CGO_ENABLED value -// or the "cgo" build flag. See /RATIONALE.md for why. -//go:cgo_import_dynamic libc_futimens futimens "/usr/lib/libSystem.B.dylib" diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_darwin.s b/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_darwin.s deleted file mode 100644 index b86aecdf0..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_darwin.s +++ /dev/null @@ -1,8 +0,0 @@ -// lifted from golang.org/x/sys unix -#include "textflag.h" - -TEXT libc_futimens_trampoline<>(SB), NOSPLIT, $0-0 - JMP libc_futimens(SB) - -GLOBL ·libc_futimens_trampoline_addr(SB), RODATA, $8 -DATA ·libc_futimens_trampoline_addr(SB)/8, $libc_futimens_trampoline<>(SB) diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_linux.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_linux.go deleted file mode 100644 index db3b1b8b6..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_linux.go +++ /dev/null @@ -1,49 +0,0 @@ -//go:build !tinygo - -package sysfs - -import ( - "syscall" - "unsafe" - _ "unsafe" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" -) - -const ( - _AT_FDCWD = -0x64 - _UTIME_OMIT = (1 << 30) - 2 -) - -func utimens(path string, atim, mtim int64) experimentalsys.Errno { - times := timesToTimespecs(atim, mtim) - if times == nil { - return 0 - } - - var flags int - var _p0 *byte - _p0, err := syscall.BytePtrFromString(path) - if err == nil { - err = utimensat(_AT_FDCWD, uintptr(unsafe.Pointer(_p0)), times, flags) - } - return experimentalsys.UnwrapOSError(err) -} - -// On linux, implement futimens via utimensat with the NUL path. -func futimens(fd uintptr, atim, mtim int64) experimentalsys.Errno { - times := timesToTimespecs(atim, mtim) - if times == nil { - return 0 - } - return experimentalsys.UnwrapOSError(utimensat(int(fd), 0 /* NUL */, times, 0)) -} - -// utimensat is like syscall.utimensat special-cased to accept a NUL string for the path value. -func utimensat(dirfd int, strPtr uintptr, times *[2]syscall.Timespec, flags int) (err error) { - _, _, e1 := syscall.Syscall6(syscall.SYS_UTIMENSAT, uintptr(dirfd), strPtr, uintptr(unsafe.Pointer(times)), uintptr(flags), 0, 0) - if e1 != 0 { - err = e1 - } - return -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_unsupported.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_unsupported.go deleted file mode 100644 index 69d564942..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_unsupported.go +++ /dev/null @@ -1,18 +0,0 @@ -//go:build (!windows && !linux && !darwin) || tinygo - -package sysfs - -import ( - "github.com/tetratelabs/wazero/experimental/sys" -) - -func utimens(path string, atim, mtim int64) sys.Errno { - return chtimes(path, atim, mtim) -} - -func futimens(fd uintptr, atim, mtim int64) error { - // Go exports syscall.Futimes, which is microsecond granularity, and - // WASI tests expect nanosecond. We don't yet have a way to invoke the - // futimens syscall portably. - return sys.ENOSYS -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_windows.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_windows.go deleted file mode 100644 index e0c89f303..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/futimens_windows.go +++ /dev/null @@ -1,42 +0,0 @@ -package sysfs - -import ( - "syscall" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func utimens(path string, atim, mtim int64) sys.Errno { - return chtimes(path, atim, mtim) -} - -func futimens(fd uintptr, atim, mtim int64) error { - // Per docs, zero isn't a valid timestamp as it cannot be differentiated - // from nil. In both cases, it is a marker like sys.UTIME_OMIT. - // See https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-setfiletime - a, w := timespecToFiletime(atim, mtim) - - if a == nil && w == nil { - return nil // both omitted, so nothing to change - } - - // Attempt to get the stat by handle, which works for normal files - h := syscall.Handle(fd) - - // Note: This returns ERROR_ACCESS_DENIED when the input is a directory. - return syscall.SetFileTime(h, nil, a, w) -} - -func timespecToFiletime(atim, mtim int64) (a, w *syscall.Filetime) { - a = timespecToFileTime(atim) - w = timespecToFileTime(mtim) - return -} - -func timespecToFileTime(tim int64) *syscall.Filetime { - if tim == sys.UTIME_OMIT { - return nil - } - ft := syscall.NsecToFiletime(tim) - return &ft -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/ino.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/ino.go deleted file mode 100644 index 8344cd16f..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/ino.go +++ /dev/null @@ -1,22 +0,0 @@ -//go:build !windows && !plan9 && !tinygo - -package sysfs - -import ( - "io/fs" - "syscall" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/sys" -) - -func inoFromFileInfo(_ string, info fs.FileInfo) (sys.Inode, experimentalsys.Errno) { - switch v := info.Sys().(type) { - case *sys.Stat_t: - return v.Ino, 0 - case *syscall.Stat_t: - return v.Ino, 0 - default: - return 0, 0 - } -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/ino_plan9.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/ino_plan9.go deleted file mode 100644 index 9c669a475..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/ino_plan9.go +++ /dev/null @@ -1,15 +0,0 @@ -package sysfs - -import ( - "io/fs" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/sys" -) - -func inoFromFileInfo(_ string, info fs.FileInfo) (sys.Inode, experimentalsys.Errno) { - if v, ok := info.Sys().(*sys.Stat_t); ok { - return v.Ino, 0 - } - return 0, 0 -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/ino_tinygo.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/ino_tinygo.go deleted file mode 100644 index 2099231cf..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/ino_tinygo.go +++ /dev/null @@ -1,14 +0,0 @@ -//go:build tinygo - -package sysfs - -import ( - "io/fs" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/sys" -) - -func inoFromFileInfo(_ string, info fs.FileInfo) (sys.Inode, experimentalsys.Errno) { - return 0, experimentalsys.ENOTSUP -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/ino_windows.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/ino_windows.go deleted file mode 100644 index d163b3601..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/ino_windows.go +++ /dev/null @@ -1,28 +0,0 @@ -package sysfs - -import ( - "io/fs" - "path" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/sys" -) - -// inoFromFileInfo uses stat to get the inode information of the file. -func inoFromFileInfo(dirPath string, info fs.FileInfo) (ino sys.Inode, errno experimentalsys.Errno) { - if v, ok := info.Sys().(*sys.Stat_t); ok { - return v.Ino, 0 - } - if dirPath == "" { - // This is a FS.File backed implementation which doesn't have access to - // the original file path. - return - } - // Ino is no not in Win32FileAttributeData - inoPath := path.Clean(path.Join(dirPath, info.Name())) - var st sys.Stat_t - if st, errno = lstat(inoPath); errno == 0 { - ino = st.Ino - } - return -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/nonblock_unix.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/nonblock_unix.go deleted file mode 100644 index 4477ee977..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/nonblock_unix.go +++ /dev/null @@ -1,17 +0,0 @@ -//go:build !windows && !plan9 && !tinygo - -package sysfs - -import ( - "syscall" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func setNonblock(fd uintptr, enable bool) sys.Errno { - return sys.UnwrapOSError(syscall.SetNonblock(int(fd), enable)) -} - -func isNonblock(f *osFile) bool { - return f.flag&sys.O_NONBLOCK == sys.O_NONBLOCK -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/nonblock_unsupported.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/nonblock_unsupported.go deleted file mode 100644 index 3e141a7b5..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/nonblock_unsupported.go +++ /dev/null @@ -1,13 +0,0 @@ -//go:build plan9 || tinygo - -package sysfs - -import "github.com/tetratelabs/wazero/experimental/sys" - -func setNonblock(fd uintptr, enable bool) sys.Errno { - return sys.ENOSYS -} - -func isNonblock(f *osFile) bool { - return false -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/nonblock_windows.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/nonblock_windows.go deleted file mode 100644 index eb38ea5af..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/nonblock_windows.go +++ /dev/null @@ -1,23 +0,0 @@ -package sysfs - -import ( - "io/fs" - "syscall" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func setNonblock(fd uintptr, enable bool) sys.Errno { - // We invoke the syscall, but this is currently no-op. - return sys.UnwrapOSError(syscall.SetNonblock(syscall.Handle(fd), enable)) -} - -func isNonblock(f *osFile) bool { - // On Windows, we support non-blocking reads only on named pipes. - isValid := false - st, errno := f.Stat() - if errno == 0 { - isValid = st.Mode&fs.ModeNamedPipe != 0 - } - return isValid && f.flag&sys.O_NONBLOCK == sys.O_NONBLOCK -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/oflag.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/oflag.go deleted file mode 100644 index be6d2c35f..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/oflag.go +++ /dev/null @@ -1,38 +0,0 @@ -package sysfs - -import ( - "os" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -// toOsOpenFlag converts the input to the flag parameter of os.OpenFile -func toOsOpenFlag(oflag sys.Oflag) (flag int) { - // First flags are exclusive - switch oflag & (sys.O_RDONLY | sys.O_RDWR | sys.O_WRONLY) { - case sys.O_RDONLY: - flag |= os.O_RDONLY - case sys.O_RDWR: - flag |= os.O_RDWR - case sys.O_WRONLY: - flag |= os.O_WRONLY - } - - // Run down the flags defined in the os package - if oflag&sys.O_APPEND != 0 { - flag |= os.O_APPEND - } - if oflag&sys.O_CREAT != 0 { - flag |= os.O_CREATE - } - if oflag&sys.O_EXCL != 0 { - flag |= os.O_EXCL - } - if oflag&sys.O_SYNC != 0 { - flag |= os.O_SYNC - } - if oflag&sys.O_TRUNC != 0 { - flag |= os.O_TRUNC - } - return withSyscallOflag(oflag, flag) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_darwin.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_darwin.go deleted file mode 100644 index a4f54ca2c..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_darwin.go +++ /dev/null @@ -1,26 +0,0 @@ -package sysfs - -import ( - "syscall" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -const supportedSyscallOflag = sys.O_DIRECTORY | sys.O_DSYNC | sys.O_NOFOLLOW | sys.O_NONBLOCK - -func withSyscallOflag(oflag sys.Oflag, flag int) int { - if oflag&sys.O_DIRECTORY != 0 { - flag |= syscall.O_DIRECTORY - } - if oflag&sys.O_DSYNC != 0 { - flag |= syscall.O_DSYNC - } - if oflag&sys.O_NOFOLLOW != 0 { - flag |= syscall.O_NOFOLLOW - } - if oflag&sys.O_NONBLOCK != 0 { - flag |= syscall.O_NONBLOCK - } - // syscall.O_RSYNC not defined on darwin - return flag -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_freebsd.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_freebsd.go deleted file mode 100644 index 42adaa214..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_freebsd.go +++ /dev/null @@ -1,24 +0,0 @@ -package sysfs - -import ( - "syscall" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -const supportedSyscallOflag = sys.O_DIRECTORY | sys.O_NOFOLLOW | sys.O_NONBLOCK - -func withSyscallOflag(oflag sys.Oflag, flag int) int { - if oflag&sys.O_DIRECTORY != 0 { - flag |= syscall.O_DIRECTORY - } - // syscall.O_DSYNC not defined on darwin - if oflag&sys.O_NOFOLLOW != 0 { - flag |= syscall.O_NOFOLLOW - } - if oflag&sys.O_NONBLOCK != 0 { - flag |= syscall.O_NONBLOCK - } - // syscall.O_RSYNC not defined on darwin - return flag -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_linux.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_linux.go deleted file mode 100644 index 3fe2bb6e1..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_linux.go +++ /dev/null @@ -1,30 +0,0 @@ -//go:build !tinygo - -package sysfs - -import ( - "syscall" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -const supportedSyscallOflag = sys.O_DIRECTORY | sys.O_DSYNC | sys.O_NOFOLLOW | sys.O_NONBLOCK | sys.O_RSYNC - -func withSyscallOflag(oflag sys.Oflag, flag int) int { - if oflag&sys.O_DIRECTORY != 0 { - flag |= syscall.O_DIRECTORY - } - if oflag&sys.O_DSYNC != 0 { - flag |= syscall.O_DSYNC - } - if oflag&sys.O_NOFOLLOW != 0 { - flag |= syscall.O_NOFOLLOW - } - if oflag&sys.O_NONBLOCK != 0 { - flag |= syscall.O_NONBLOCK - } - if oflag&sys.O_RSYNC != 0 { - flag |= syscall.O_RSYNC - } - return flag -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_notwindows.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_notwindows.go deleted file mode 100644 index 670e35910..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_notwindows.go +++ /dev/null @@ -1,20 +0,0 @@ -//go:build !windows && !tinygo - -package sysfs - -import ( - "io/fs" - "os" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -// openFile is like os.OpenFile except it accepts a sys.Oflag and returns -// sys.Errno. A zero sys.Errno is success. -func openFile(path string, oflag sys.Oflag, perm fs.FileMode) (*os.File, sys.Errno) { - f, err := os.OpenFile(path, toOsOpenFlag(oflag), perm) - // Note: This does not return a sys.File because sys.FS that returns - // one may want to hide the real OS path. For example, this is needed for - // pre-opens. - return f, sys.UnwrapOSError(err) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_sun.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_sun.go deleted file mode 100644 index bdf7dd84d..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_sun.go +++ /dev/null @@ -1,31 +0,0 @@ -//go:build illumos || solaris - -package sysfs - -import ( - "syscall" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -const supportedSyscallOflag = sys.O_DIRECTORY | sys.O_DSYNC | sys.O_NOFOLLOW | sys.O_NONBLOCK | sys.O_RSYNC - -func withSyscallOflag(oflag sys.Oflag, flag int) int { - if oflag&sys.O_DIRECTORY != 0 { - // See https://github.com/illumos/illumos-gate/blob/edd580643f2cf1434e252cd7779e83182ea84945/usr/src/uts/common/sys/fcntl.h#L90 - flag |= 0x1000000 - } - if oflag&sys.O_DSYNC != 0 { - flag |= syscall.O_DSYNC - } - if oflag&sys.O_NOFOLLOW != 0 { - flag |= syscall.O_NOFOLLOW - } - if oflag&sys.O_NONBLOCK != 0 { - flag |= syscall.O_NONBLOCK - } - if oflag&sys.O_RSYNC != 0 { - flag |= syscall.O_RSYNC - } - return flag -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_tinygo.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_tinygo.go deleted file mode 100644 index ccf6847c0..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_tinygo.go +++ /dev/null @@ -1,25 +0,0 @@ -//go:build tinygo - -package sysfs - -import ( - "io/fs" - "os" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -const supportedSyscallOflag = sys.Oflag(0) - -func withSyscallOflag(oflag sys.Oflag, flag int) int { - // O_DIRECTORY not defined - // O_DSYNC not defined - // O_NOFOLLOW not defined - // O_NONBLOCK not defined - // O_RSYNC not defined - return flag -} - -func openFile(path string, oflag sys.Oflag, perm fs.FileMode) (*os.File, sys.Errno) { - return nil, sys.ENOSYS -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_unsupported.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_unsupported.go deleted file mode 100644 index 9f7a6d088..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_unsupported.go +++ /dev/null @@ -1,18 +0,0 @@ -//go:build !darwin && !linux && !windows && !illumos && !solaris && !freebsd - -package sysfs - -import ( - "github.com/tetratelabs/wazero/experimental/sys" -) - -const supportedSyscallOflag = sys.Oflag(0) - -func withSyscallOflag(oflag sys.Oflag, flag int) int { - // O_DIRECTORY not defined - // O_DSYNC not defined - // O_NOFOLLOW not defined - // O_NONBLOCK not defined - // O_RSYNC not defined - return flag -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_windows.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_windows.go deleted file mode 100644 index 717f8598a..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/open_file_windows.go +++ /dev/null @@ -1,161 +0,0 @@ -package sysfs - -import ( - "io/fs" - "os" - "strings" - "syscall" - "unsafe" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func openFile(path string, oflag sys.Oflag, perm fs.FileMode) (*os.File, sys.Errno) { - isDir := oflag&sys.O_DIRECTORY > 0 - flag := toOsOpenFlag(oflag) - - // TODO: document why we are opening twice - fd, err := open(path, flag|syscall.O_CLOEXEC, uint32(perm)) - if err == nil { - return os.NewFile(uintptr(fd), path), 0 - } - - // TODO: Set FILE_SHARE_DELETE for directory as well. - f, err := os.OpenFile(path, flag, perm) - errno := sys.UnwrapOSError(err) - if errno == 0 { - return f, 0 - } - - switch errno { - case sys.EINVAL: - // WASI expects ENOTDIR for a file path with a trailing slash. - if strings.HasSuffix(path, "/") { - errno = sys.ENOTDIR - } - // To match expectations of WASI, e.g. TinyGo TestStatBadDir, return - // ENOENT, not ENOTDIR. - case sys.ENOTDIR: - errno = sys.ENOENT - case sys.ENOENT: - if isSymlink(path) { - // Either symlink or hard link not found. We change the returned - // errno depending on if it is symlink or not to have consistent - // behavior across OSes. - if isDir { - // Dangling symlink dir must raise ENOTDIR. - errno = sys.ENOTDIR - } else { - errno = sys.ELOOP - } - } - } - return f, errno -} - -const supportedSyscallOflag = sys.O_NONBLOCK - -// Map to synthetic values here https://github.com/golang/go/blob/go1.20/src/syscall/types_windows.go#L34-L48 -func withSyscallOflag(oflag sys.Oflag, flag int) int { - // O_DIRECTORY not defined in windows - // O_DSYNC not defined in windows - // O_NOFOLLOW not defined in windows - if oflag&sys.O_NONBLOCK != 0 { - flag |= syscall.O_NONBLOCK - } - // O_RSYNC not defined in windows - return flag -} - -func isSymlink(path string) bool { - if st, e := os.Lstat(path); e == nil && st.Mode()&os.ModeSymlink != 0 { - return true - } - return false -} - -// # Differences from syscall.Open -// -// This code is based on syscall.Open from the below link with some differences -// https://github.com/golang/go/blame/go1.20/src/syscall/syscall_windows.go#L308-L379 -// -// - syscall.O_CREAT doesn't imply syscall.GENERIC_WRITE as that breaks -// flag expectations in wasi. -// - add support for setting FILE_SHARE_DELETE. -func open(path string, mode int, perm uint32) (fd syscall.Handle, err error) { - if len(path) == 0 { - return syscall.InvalidHandle, syscall.ERROR_FILE_NOT_FOUND - } - pathp, err := syscall.UTF16PtrFromString(path) - if err != nil { - return syscall.InvalidHandle, err - } - var access uint32 - switch mode & (syscall.O_RDONLY | syscall.O_WRONLY | syscall.O_RDWR) { - case syscall.O_RDONLY: - access = syscall.GENERIC_READ - case syscall.O_WRONLY: - access = syscall.GENERIC_WRITE - case syscall.O_RDWR: - access = syscall.GENERIC_READ | syscall.GENERIC_WRITE - } - if mode&syscall.O_APPEND != 0 { - access &^= syscall.GENERIC_WRITE - access |= syscall.FILE_APPEND_DATA - } - sharemode := uint32(syscall.FILE_SHARE_READ | syscall.FILE_SHARE_WRITE | syscall.FILE_SHARE_DELETE) - var sa *syscall.SecurityAttributes - if mode&syscall.O_CLOEXEC == 0 { - var _sa syscall.SecurityAttributes - _sa.Length = uint32(unsafe.Sizeof(sa)) - _sa.InheritHandle = 1 - sa = &_sa - } - var createmode uint32 - switch { - case mode&(syscall.O_CREAT|syscall.O_EXCL) == (syscall.O_CREAT | syscall.O_EXCL): - createmode = syscall.CREATE_NEW - case mode&(syscall.O_CREAT|syscall.O_TRUNC) == (syscall.O_CREAT | syscall.O_TRUNC): - createmode = syscall.CREATE_ALWAYS - case mode&syscall.O_CREAT == syscall.O_CREAT: - createmode = syscall.OPEN_ALWAYS - case mode&syscall.O_TRUNC == syscall.O_TRUNC: - createmode = syscall.TRUNCATE_EXISTING - default: - createmode = syscall.OPEN_EXISTING - } - var attrs uint32 = syscall.FILE_ATTRIBUTE_NORMAL - if perm&syscall.S_IWRITE == 0 { - attrs = syscall.FILE_ATTRIBUTE_READONLY - if createmode == syscall.CREATE_ALWAYS { - // We have been asked to create a read-only file. - // If the file already exists, the semantics of - // the Unix open system call is to preserve the - // existing permissions. If we pass CREATE_ALWAYS - // and FILE_ATTRIBUTE_READONLY to CreateFile, - // and the file already exists, CreateFile will - // change the file permissions. - // Avoid that to preserve the Unix semantics. - h, e := syscall.CreateFile(pathp, access, sharemode, sa, syscall.TRUNCATE_EXISTING, syscall.FILE_ATTRIBUTE_NORMAL, 0) - switch e { - case syscall.ERROR_FILE_NOT_FOUND, syscall.ERROR_PATH_NOT_FOUND: - // File does not exist. These are the same - // errors as Errno.Is checks for ErrNotExist. - // Carry on to create the file. - default: - // Success or some different error. - return h, e - } - } - } - - // This shouldn't be included before 1.20 to have consistent behavior. - // https://github.com/golang/go/commit/0f0aa5d8a6a0253627d58b3aa083b24a1091933f - if createmode == syscall.OPEN_EXISTING && access == syscall.GENERIC_READ { - // Necessary for opening directory handles. - attrs |= syscall.FILE_FLAG_BACKUP_SEMANTICS - } - - h, e := syscall.CreateFile(pathp, access, sharemode, sa, createmode, attrs, 0) - return h, e -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/osfile.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/osfile.go deleted file mode 100644 index a9b01eb6a..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/osfile.go +++ /dev/null @@ -1,311 +0,0 @@ -package sysfs - -import ( - "io" - "io/fs" - "os" - "runtime" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/internal/fsapi" - "github.com/tetratelabs/wazero/sys" -) - -func newOsFile(path string, flag experimentalsys.Oflag, perm fs.FileMode, f *os.File) fsapi.File { - // Windows cannot read files written to a directory after it was opened. - // This was noticed in #1087 in zig tests. Use a flag instead of a - // different type. - reopenDir := runtime.GOOS == "windows" - return &osFile{path: path, flag: flag, perm: perm, reopenDir: reopenDir, file: f, fd: f.Fd()} -} - -// osFile is a file opened with this package, and uses os.File or syscalls to -// implement api.File. -type osFile struct { - path string - flag experimentalsys.Oflag - perm fs.FileMode - file *os.File - fd uintptr - - // reopenDir is true if reopen should be called before Readdir. This flag - // is deferred until Readdir to prevent redundant rewinds. This could - // happen if Seek(0) was called twice, or if in Windows, Seek(0) was called - // before Readdir. - reopenDir bool - - // closed is true when closed was called. This ensures proper sys.EBADF - closed bool - - // cachedStat includes fields that won't change while a file is open. - cachedSt *cachedStat -} - -// cachedStat returns the cacheable parts of sys.Stat_t or an error if they -// couldn't be retrieved. -func (f *osFile) cachedStat() (dev uint64, ino sys.Inode, isDir bool, errno experimentalsys.Errno) { - if f.cachedSt == nil { - if _, errno = f.Stat(); errno != 0 { - return - } - } - return f.cachedSt.dev, f.cachedSt.ino, f.cachedSt.isDir, 0 -} - -// Dev implements the same method as documented on sys.File -func (f *osFile) Dev() (uint64, experimentalsys.Errno) { - dev, _, _, errno := f.cachedStat() - return dev, errno -} - -// Ino implements the same method as documented on sys.File -func (f *osFile) Ino() (sys.Inode, experimentalsys.Errno) { - _, ino, _, errno := f.cachedStat() - return ino, errno -} - -// IsDir implements the same method as documented on sys.File -func (f *osFile) IsDir() (bool, experimentalsys.Errno) { - _, _, isDir, errno := f.cachedStat() - return isDir, errno -} - -// IsAppend implements File.IsAppend -func (f *osFile) IsAppend() bool { - return f.flag&experimentalsys.O_APPEND == experimentalsys.O_APPEND -} - -// SetAppend implements the same method as documented on sys.File -func (f *osFile) SetAppend(enable bool) (errno experimentalsys.Errno) { - if enable { - f.flag |= experimentalsys.O_APPEND - } else { - f.flag &= ^experimentalsys.O_APPEND - } - - // appendMode cannot be changed later, so we have to re-open the file - // https://github.com/golang/go/blob/go1.23/src/os/file_unix.go#L60 - return fileError(f, f.closed, f.reopen()) -} - -func (f *osFile) reopen() (errno experimentalsys.Errno) { - var ( - isDir bool - offset int64 - err error - ) - - isDir, errno = f.IsDir() - if errno != 0 { - return errno - } - - if !isDir { - offset, err = f.file.Seek(0, io.SeekCurrent) - if err != nil { - return experimentalsys.UnwrapOSError(err) - } - } - - // Clear any create or trunc flag, as we are re-opening, not re-creating. - flag := f.flag &^ (experimentalsys.O_CREAT | experimentalsys.O_TRUNC) - file, errno := OpenFile(f.path, flag, f.perm) - if errno != 0 { - return errno - } - errno = f.checkSameFile(file) - if errno != 0 { - return errno - } - - if !isDir { - _, err = file.Seek(offset, io.SeekStart) - if err != nil { - _ = file.Close() - return experimentalsys.UnwrapOSError(err) - } - } - - // Only update f on success. - _ = f.file.Close() - f.file = file - f.fd = file.Fd() - return 0 -} - -func (f *osFile) checkSameFile(osf *os.File) experimentalsys.Errno { - fi1, err := f.file.Stat() - if err != nil { - return experimentalsys.UnwrapOSError(err) - } - fi2, err := osf.Stat() - if err != nil { - return experimentalsys.UnwrapOSError(err) - } - if os.SameFile(fi1, fi2) { - return 0 - } - return experimentalsys.ENOENT -} - -// IsNonblock implements the same method as documented on fsapi.File -func (f *osFile) IsNonblock() bool { - return isNonblock(f) -} - -// SetNonblock implements the same method as documented on fsapi.File -func (f *osFile) SetNonblock(enable bool) (errno experimentalsys.Errno) { - if enable { - f.flag |= experimentalsys.O_NONBLOCK - } else { - f.flag &= ^experimentalsys.O_NONBLOCK - } - if errno = setNonblock(f.fd, enable); errno != 0 { - return fileError(f, f.closed, errno) - } - return 0 -} - -// Stat implements the same method as documented on sys.File -func (f *osFile) Stat() (sys.Stat_t, experimentalsys.Errno) { - if f.closed { - return sys.Stat_t{}, experimentalsys.EBADF - } - - st, errno := statFile(f.file) - switch errno { - case 0: - f.cachedSt = &cachedStat{dev: st.Dev, ino: st.Ino, isDir: st.Mode&fs.ModeDir == fs.ModeDir} - case experimentalsys.EIO: - errno = experimentalsys.EBADF - } - return st, errno -} - -// Read implements the same method as documented on sys.File -func (f *osFile) Read(buf []byte) (n int, errno experimentalsys.Errno) { - if len(buf) == 0 { - return 0, 0 // Short-circuit 0-len reads. - } - if nonBlockingFileReadSupported && f.IsNonblock() { - n, errno = readFd(f.fd, buf) - } else { - n, errno = read(f.file, buf) - } - if errno != 0 { - // Defer validation overhead until we've already had an error. - errno = fileError(f, f.closed, errno) - } - return -} - -// Pread implements the same method as documented on sys.File -func (f *osFile) Pread(buf []byte, off int64) (n int, errno experimentalsys.Errno) { - if n, errno = pread(f.file, buf, off); errno != 0 { - // Defer validation overhead until we've already had an error. - errno = fileError(f, f.closed, errno) - } - return -} - -// Seek implements the same method as documented on sys.File -func (f *osFile) Seek(offset int64, whence int) (newOffset int64, errno experimentalsys.Errno) { - if newOffset, errno = seek(f.file, offset, whence); errno != 0 { - // Defer validation overhead until we've already had an error. - errno = fileError(f, f.closed, errno) - - // If the error was trying to rewind a directory, re-open it. Notably, - // seeking to zero on a directory doesn't work on Windows with Go 1.19. - if errno == experimentalsys.EISDIR && offset == 0 && whence == io.SeekStart { - errno = 0 - f.reopenDir = true - } - } - return -} - -// Poll implements the same method as documented on fsapi.File -func (f *osFile) Poll(flag fsapi.Pflag, timeoutMillis int32) (ready bool, errno experimentalsys.Errno) { - return poll(f.fd, flag, timeoutMillis) -} - -// Readdir implements File.Readdir. Notably, this uses "Readdir", not -// "ReadDir", from os.File. -func (f *osFile) Readdir(n int) (dirents []experimentalsys.Dirent, errno experimentalsys.Errno) { - if f.reopenDir { // re-open the directory if needed. - f.reopenDir = false - if errno = adjustReaddirErr(f, f.closed, f.reopen()); errno != 0 { - return - } - } - - if dirents, errno = readdir(f.file, f.path, n); errno != 0 { - errno = adjustReaddirErr(f, f.closed, errno) - } - return -} - -// Write implements the same method as documented on sys.File -func (f *osFile) Write(buf []byte) (n int, errno experimentalsys.Errno) { - if len(buf) == 0 { - return 0, 0 // Short-circuit 0-len writes. - } - if nonBlockingFileWriteSupported && f.IsNonblock() { - n, errno = writeFd(f.fd, buf) - } else if n, errno = write(f.file, buf); errno != 0 { - // Defer validation overhead until we've already had an error. - errno = fileError(f, f.closed, errno) - } - return -} - -// Pwrite implements the same method as documented on sys.File -func (f *osFile) Pwrite(buf []byte, off int64) (n int, errno experimentalsys.Errno) { - if n, errno = pwrite(f.file, buf, off); errno != 0 { - // Defer validation overhead until we've already had an error. - errno = fileError(f, f.closed, errno) - } - return -} - -// Truncate implements the same method as documented on sys.File -func (f *osFile) Truncate(size int64) (errno experimentalsys.Errno) { - if errno = experimentalsys.UnwrapOSError(f.file.Truncate(size)); errno != 0 { - // Defer validation overhead until we've already had an error. - errno = fileError(f, f.closed, errno) - } - return -} - -// Sync implements the same method as documented on sys.File -func (f *osFile) Sync() experimentalsys.Errno { - return fsync(f.file) -} - -// Datasync implements the same method as documented on sys.File -func (f *osFile) Datasync() experimentalsys.Errno { - return datasync(f.file) -} - -// Utimens implements the same method as documented on sys.File -func (f *osFile) Utimens(atim, mtim int64) experimentalsys.Errno { - if f.closed { - return experimentalsys.EBADF - } - - err := futimens(f.fd, atim, mtim) - return experimentalsys.UnwrapOSError(err) -} - -// Close implements the same method as documented on sys.File -func (f *osFile) Close() experimentalsys.Errno { - if f.closed { - return 0 - } - f.closed = true - return f.close() -} - -func (f *osFile) close() experimentalsys.Errno { - return experimentalsys.UnwrapOSError(f.file.Close()) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll.go deleted file mode 100644 index a2e1103e0..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll.go +++ /dev/null @@ -1,18 +0,0 @@ -//go:build windows || (linux && !tinygo) || darwin - -package sysfs - -import ( - "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/internal/fsapi" -) - -// poll implements `Poll` as documented on sys.File via a file descriptor. -func poll(fd uintptr, flag fsapi.Pflag, timeoutMillis int32) (ready bool, errno sys.Errno) { - if flag != fsapi.POLLIN { - return false, sys.ENOTSUP - } - fds := []pollFd{newPollFd(fd, _POLLIN, 0)} - count, errno := _poll(fds, timeoutMillis) - return count > 0, errno -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_darwin.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_darwin.go deleted file mode 100644 index 1f7f89093..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_darwin.go +++ /dev/null @@ -1,55 +0,0 @@ -package sysfs - -import ( - "unsafe" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -// pollFd is the struct to query for file descriptor events using poll. -type pollFd struct { - // fd is the file descriptor. - fd int32 - // events is a bitmap containing the requested events. - events int16 - // revents is a bitmap containing the returned events. - revents int16 -} - -// newPollFd is a constructor for pollFd that abstracts the platform-specific type of file descriptors. -func newPollFd(fd uintptr, events, revents int16) pollFd { - return pollFd{fd: int32(fd), events: events, revents: revents} -} - -// _POLLIN subscribes a notification when any readable data is available. -const _POLLIN = 0x0001 - -// _poll implements poll on Darwin via the corresponding libc function. -func _poll(fds []pollFd, timeoutMillis int32) (n int, errno sys.Errno) { - var fdptr *pollFd - nfds := len(fds) - if nfds > 0 { - fdptr = &fds[0] - } - n1, _, err := syscall_syscall6( - libc_poll_trampoline_addr, - uintptr(unsafe.Pointer(fdptr)), - uintptr(nfds), - uintptr(int(timeoutMillis)), - uintptr(unsafe.Pointer(nil)), - uintptr(unsafe.Pointer(nil)), - uintptr(unsafe.Pointer(nil))) - return int(n1), sys.UnwrapOSError(err) -} - -// libc_poll_trampoline_addr is the address of the -// `libc_poll_trampoline` symbol, defined in `poll_darwin.s`. -// -// We use this to invoke the syscall through syscall_syscall6 imported below. -var libc_poll_trampoline_addr uintptr - -// Imports the select symbol from libc as `libc_poll`. -// -// Note: CGO mechanisms are used in darwin regardless of the CGO_ENABLED value -// or the "cgo" build flag. See /RATIONALE.md for why. -//go:cgo_import_dynamic libc_poll poll "/usr/lib/libSystem.B.dylib" diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_darwin.s b/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_darwin.s deleted file mode 100644 index e04fca583..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_darwin.s +++ /dev/null @@ -1,8 +0,0 @@ -// lifted from golang.org/x/sys unix -#include "textflag.h" - -TEXT libc_poll_trampoline<>(SB), NOSPLIT, $0-0 - JMP libc_poll(SB) - -GLOBL ·libc_poll_trampoline_addr(SB), RODATA, $8 -DATA ·libc_poll_trampoline_addr(SB)/8, $libc_poll_trampoline<>(SB) diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_linux.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_linux.go deleted file mode 100644 index 49bf4fd06..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_linux.go +++ /dev/null @@ -1,59 +0,0 @@ -//go:build !tinygo - -package sysfs - -import ( - "syscall" - "time" - "unsafe" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -// pollFd is the struct to query for file descriptor events using poll. -type pollFd struct { - // fd is the file descriptor. - fd int32 - // events is a bitmap containing the requested events. - events int16 - // revents is a bitmap containing the returned events. - revents int16 -} - -// newPollFd is a constructor for pollFd that abstracts the platform-specific type of file descriptors. -func newPollFd(fd uintptr, events, revents int16) pollFd { - return pollFd{fd: int32(fd), events: events, revents: revents} -} - -// _POLLIN subscribes a notification when any readable data is available. -const _POLLIN = 0x0001 - -// _poll implements poll on Linux via ppoll. -func _poll(fds []pollFd, timeoutMillis int32) (n int, errno sys.Errno) { - var ts syscall.Timespec - if timeoutMillis >= 0 { - ts = syscall.NsecToTimespec(int64(time.Duration(timeoutMillis) * time.Millisecond)) - } - return ppoll(fds, &ts) -} - -// ppoll is a poll variant that allows to subscribe to a mask of signals. -// However, we do not need such mask, so the corresponding argument is always nil. -func ppoll(fds []pollFd, timespec *syscall.Timespec) (n int, err sys.Errno) { - var fdptr *pollFd - nfd := len(fds) - if nfd != 0 { - fdptr = &fds[0] - } - - n1, _, errno := syscall.Syscall6( - uintptr(syscall.SYS_PPOLL), - uintptr(unsafe.Pointer(fdptr)), - uintptr(nfd), - uintptr(unsafe.Pointer(timespec)), - uintptr(unsafe.Pointer(nil)), // sigmask is currently always ignored - uintptr(unsafe.Pointer(nil)), - uintptr(unsafe.Pointer(nil))) - - return int(n1), sys.UnwrapOSError(errno) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_unsupported.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_unsupported.go deleted file mode 100644 index 2301a067e..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_unsupported.go +++ /dev/null @@ -1,13 +0,0 @@ -//go:build !(linux || darwin || windows) || tinygo - -package sysfs - -import ( - "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/internal/fsapi" -) - -// poll implements `Poll` as documented on fsapi.File via a file descriptor. -func poll(uintptr, fsapi.Pflag, int32) (bool, sys.Errno) { - return false, sys.ENOSYS -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_windows.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_windows.go deleted file mode 100644 index 82c8b2baf..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/poll_windows.go +++ /dev/null @@ -1,224 +0,0 @@ -package sysfs - -import ( - "syscall" - "time" - "unsafe" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -var ( - procWSAPoll = modws2_32.NewProc("WSAPoll") - procGetNamedPipeInfo = kernel32.NewProc("GetNamedPipeInfo") -) - -const ( - // _POLLRDNORM subscribes to normal data for read. - _POLLRDNORM = 0x0100 - // _POLLRDBAND subscribes to priority band (out-of-band) data for read. - _POLLRDBAND = 0x0200 - // _POLLIN subscribes a notification when any readable data is available. - _POLLIN = (_POLLRDNORM | _POLLRDBAND) -) - -// pollFd is the struct to query for file descriptor events using poll. -type pollFd struct { - // fd is the file descriptor. - fd uintptr - // events is a bitmap containing the requested events. - events int16 - // revents is a bitmap containing the returned events. - revents int16 -} - -// newPollFd is a constructor for pollFd that abstracts the platform-specific type of file descriptors. -func newPollFd(fd uintptr, events, revents int16) pollFd { - return pollFd{fd: fd, events: events, revents: revents} -} - -// pollInterval is the interval between each calls to peekNamedPipe in selectAllHandles -const pollInterval = 100 * time.Millisecond - -// _poll implements poll on Windows, for a subset of cases. -// -// fds may contain any number of file handles, but regular files and pipes are only processed for _POLLIN. -// Stdin is a pipe, thus it is checked for readiness when present. Pipes are checked using PeekNamedPipe. -// Regular files always immediately reported as ready, regardless their actual state and timeouts. -// -// If n==0 it will wait for the given timeout duration, but it will return sys.ENOSYS if timeout is nil, -// i.e. it won't block indefinitely. The given ctx is used to allow for cancellation, -// and it is currently used only in tests. -// -// The implementation actually polls every 100 milliseconds (pollInterval) until it reaches the -// given timeout (in millis). -// -// The duration may be negative, in which case it will wait indefinitely. The given ctx is -// used to allow for cancellation, and it is currently used only in tests. -func _poll(fds []pollFd, timeoutMillis int32) (n int, errno sys.Errno) { - if fds == nil { - return -1, sys.ENOSYS - } - - regular, pipes, sockets, errno := partionByFtype(fds) - nregular := len(regular) - if errno != 0 { - return -1, errno - } - - // Ticker that emits at every pollInterval. - tick := time.NewTicker(pollInterval) - tickCh := tick.C - defer tick.Stop() - - // Timer that expires after the given duration. - // Initialize afterCh as nil: the select below will wait forever. - var afterCh <-chan time.Time - if timeoutMillis >= 0 { - // If duration is not nil, instantiate the timer. - after := time.NewTimer(time.Duration(timeoutMillis) * time.Millisecond) - defer after.Stop() - afterCh = after.C - } - - npipes, nsockets, errno := peekAll(pipes, sockets) - if errno != 0 { - return -1, errno - } - count := nregular + npipes + nsockets - if count > 0 { - return count, 0 - } - - for { - select { - case <-afterCh: - return 0, 0 - case <-tickCh: - npipes, nsockets, errno := peekAll(pipes, sockets) - if errno != 0 { - return -1, errno - } - count = nregular + npipes + nsockets - if count > 0 { - return count, 0 - } - } - } -} - -func peekAll(pipes, sockets []pollFd) (npipes, nsockets int, errno sys.Errno) { - npipes, errno = peekPipes(pipes) - if errno != 0 { - return - } - - // Invoke wsaPoll with a 0-timeout to avoid blocking. - // Timeouts are handled in pollWithContext instead. - nsockets, errno = wsaPoll(sockets, 0) - if errno != 0 { - return - } - - count := npipes + nsockets - if count > 0 { - return - } - - return -} - -func peekPipes(fds []pollFd) (n int, errno sys.Errno) { - for _, fd := range fds { - bytes, errno := peekNamedPipe(syscall.Handle(fd.fd)) - if errno != 0 { - return -1, sys.UnwrapOSError(errno) - } - if bytes > 0 { - n++ - } - } - return -} - -// wsaPoll is the WSAPoll function from winsock2. -// -// See https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsapoll -func wsaPoll(fds []pollFd, timeout int) (n int, errno sys.Errno) { - if len(fds) > 0 { - sockptr := &fds[0] - ns, _, e := syscall.SyscallN( - procWSAPoll.Addr(), - uintptr(unsafe.Pointer(sockptr)), - uintptr(len(fds)), - uintptr(timeout)) - if e != 0 { - return -1, sys.UnwrapOSError(e) - } - n = int(ns) - } - return -} - -// ftype is a type of file that can be handled by poll. -type ftype uint8 - -const ( - ftype_regular ftype = iota - ftype_pipe - ftype_socket -) - -// partionByFtype checks the type of each fd in fds and returns 3 distinct partitions -// for regular files, named pipes and sockets. -func partionByFtype(fds []pollFd) (regular, pipe, socket []pollFd, errno sys.Errno) { - for _, pfd := range fds { - t, errno := ftypeOf(pfd.fd) - if errno != 0 { - return nil, nil, nil, errno - } - switch t { - case ftype_regular: - regular = append(regular, pfd) - case ftype_pipe: - pipe = append(pipe, pfd) - case ftype_socket: - socket = append(socket, pfd) - } - } - return -} - -// ftypeOf checks the type of fd and return the corresponding ftype. -func ftypeOf(fd uintptr) (ftype, sys.Errno) { - h := syscall.Handle(fd) - t, err := syscall.GetFileType(h) - if err != nil { - return 0, sys.UnwrapOSError(err) - } - switch t { - case syscall.FILE_TYPE_CHAR, syscall.FILE_TYPE_DISK: - return ftype_regular, 0 - case syscall.FILE_TYPE_PIPE: - if isSocket(h) { - return ftype_socket, 0 - } else { - return ftype_pipe, 0 - } - default: - return ftype_regular, 0 - } -} - -// isSocket returns true if the given file handle -// is a pipe. -func isSocket(fd syscall.Handle) bool { - r, _, errno := syscall.SyscallN( - procGetNamedPipeInfo.Addr(), - uintptr(fd), - uintptr(unsafe.Pointer(nil)), - uintptr(unsafe.Pointer(nil)), - uintptr(unsafe.Pointer(nil)), - uintptr(unsafe.Pointer(nil))) - return r == 0 || errno != 0 -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/readfs.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/readfs.go deleted file mode 100644 index 59e331a29..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/readfs.go +++ /dev/null @@ -1,117 +0,0 @@ -package sysfs - -import ( - "io/fs" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" -) - -type ReadFS struct { - experimentalsys.FS -} - -// OpenFile implements the same method as documented on sys.FS -func (r *ReadFS) OpenFile(path string, flag experimentalsys.Oflag, perm fs.FileMode) (experimentalsys.File, experimentalsys.Errno) { - // Mask the mutually exclusive bits as they determine write mode. - switch flag & (experimentalsys.O_RDONLY | experimentalsys.O_WRONLY | experimentalsys.O_RDWR) { - case experimentalsys.O_WRONLY, experimentalsys.O_RDWR: - // Return the correct error if a directory was opened for write. - if flag&experimentalsys.O_DIRECTORY != 0 { - return nil, experimentalsys.EISDIR - } - return nil, experimentalsys.ENOSYS - default: // sys.O_RDONLY (integer zero) so we are ok! - } - - f, errno := r.FS.OpenFile(path, flag, perm) - if errno != 0 { - return nil, errno - } - return &readFile{f}, 0 -} - -// Mkdir implements the same method as documented on sys.FS -func (r *ReadFS) Mkdir(path string, perm fs.FileMode) experimentalsys.Errno { - return experimentalsys.EROFS -} - -// Chmod implements the same method as documented on sys.FS -func (r *ReadFS) Chmod(path string, perm fs.FileMode) experimentalsys.Errno { - return experimentalsys.EROFS -} - -// Rename implements the same method as documented on sys.FS -func (r *ReadFS) Rename(from, to string) experimentalsys.Errno { - return experimentalsys.EROFS -} - -// Rmdir implements the same method as documented on sys.FS -func (r *ReadFS) Rmdir(path string) experimentalsys.Errno { - return experimentalsys.EROFS -} - -// Link implements the same method as documented on sys.FS -func (r *ReadFS) Link(_, _ string) experimentalsys.Errno { - return experimentalsys.EROFS -} - -// Symlink implements the same method as documented on sys.FS -func (r *ReadFS) Symlink(_, _ string) experimentalsys.Errno { - return experimentalsys.EROFS -} - -// Unlink implements the same method as documented on sys.FS -func (r *ReadFS) Unlink(path string) experimentalsys.Errno { - return experimentalsys.EROFS -} - -// Utimens implements the same method as documented on sys.FS -func (r *ReadFS) Utimens(path string, atim, mtim int64) experimentalsys.Errno { - return experimentalsys.EROFS -} - -// compile-time check to ensure readFile implements api.File. -var _ experimentalsys.File = (*readFile)(nil) - -type readFile struct { - experimentalsys.File -} - -// Write implements the same method as documented on sys.File. -func (r *readFile) Write([]byte) (int, experimentalsys.Errno) { - return 0, r.writeErr() -} - -// Pwrite implements the same method as documented on sys.File. -func (r *readFile) Pwrite([]byte, int64) (n int, errno experimentalsys.Errno) { - return 0, r.writeErr() -} - -// Truncate implements the same method as documented on sys.File. -func (r *readFile) Truncate(int64) experimentalsys.Errno { - return r.writeErr() -} - -// Sync implements the same method as documented on sys.File. -func (r *readFile) Sync() experimentalsys.Errno { - return experimentalsys.EBADF -} - -// Datasync implements the same method as documented on sys.File. -func (r *readFile) Datasync() experimentalsys.Errno { - return experimentalsys.EBADF -} - -// Utimens implements the same method as documented on sys.File. -func (r *readFile) Utimens(int64, int64) experimentalsys.Errno { - return experimentalsys.EBADF -} - -func (r *readFile) writeErr() experimentalsys.Errno { - if isDir, errno := r.IsDir(); errno != 0 { - return errno - } else if isDir { - return experimentalsys.EISDIR - } - return experimentalsys.EBADF -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/rename.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/rename.go deleted file mode 100644 index 37c53571d..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/rename.go +++ /dev/null @@ -1,16 +0,0 @@ -//go:build !windows && !plan9 && !tinygo - -package sysfs - -import ( - "syscall" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func rename(from, to string) sys.Errno { - if from == to { - return 0 - } - return sys.UnwrapOSError(syscall.Rename(from, to)) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/rename_plan9.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/rename_plan9.go deleted file mode 100644 index 474cc7595..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/rename_plan9.go +++ /dev/null @@ -1,14 +0,0 @@ -package sysfs - -import ( - "os" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func rename(from, to string) sys.Errno { - if from == to { - return 0 - } - return sys.UnwrapOSError(os.Rename(from, to)) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/rename_windows.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/rename_windows.go deleted file mode 100644 index 5e8102239..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/rename_windows.go +++ /dev/null @@ -1,55 +0,0 @@ -package sysfs - -import ( - "os" - "syscall" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func rename(from, to string) sys.Errno { - if from == to { - return 0 - } - - var fromIsDir, toIsDir bool - if fromStat, errno := stat(from); errno != 0 { - return errno // failed to stat from - } else { - fromIsDir = fromStat.Mode.IsDir() - } - if toStat, errno := stat(to); errno == sys.ENOENT { - return syscallRename(from, to) // file or dir to not-exist is ok - } else if errno != 0 { - return errno // failed to stat to - } else { - toIsDir = toStat.Mode.IsDir() - } - - // Now, handle known cases - switch { - case !fromIsDir && toIsDir: // file to dir - return sys.EISDIR - case !fromIsDir && !toIsDir: // file to file - // Use os.Rename instead of syscall.Rename to overwrite a file. - // This uses MoveFileEx instead of MoveFile (used by syscall.Rename). - return sys.UnwrapOSError(os.Rename(from, to)) - case fromIsDir && !toIsDir: // dir to file - return sys.ENOTDIR - default: // dir to dir - - // We can't tell if a directory is empty or not, via stat information. - // Reading the directory is expensive, as it can buffer large amounts - // of data on fail. Instead, speculatively try to remove the directory. - // This is only one syscall and won't buffer anything. - if errno := rmdir(to); errno == 0 || errno == sys.ENOENT { - return syscallRename(from, to) - } else { - return errno - } - } -} - -func syscallRename(from string, to string) sys.Errno { - return sys.UnwrapOSError(syscall.Rename(from, to)) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/sock.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/sock.go deleted file mode 100644 index ab9bb1ffa..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/sock.go +++ /dev/null @@ -1,187 +0,0 @@ -package sysfs - -import ( - "net" - "os" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/internal/fsapi" - socketapi "github.com/tetratelabs/wazero/internal/sock" - "github.com/tetratelabs/wazero/sys" -) - -// NewTCPListenerFile creates a socketapi.TCPSock for a given *net.TCPListener. -func NewTCPListenerFile(tl *net.TCPListener) socketapi.TCPSock { - return newTCPListenerFile(tl) -} - -// baseSockFile implements base behavior for all TCPSock, TCPConn files, -// regardless the platform. -type baseSockFile struct { - experimentalsys.UnimplementedFile -} - -var _ experimentalsys.File = (*baseSockFile)(nil) - -// IsDir implements the same method as documented on File.IsDir -func (*baseSockFile) IsDir() (bool, experimentalsys.Errno) { - // We need to override this method because WASI-libc prestats the FD - // and the default impl returns ENOSYS otherwise. - return false, 0 -} - -// Stat implements the same method as documented on File.Stat -func (f *baseSockFile) Stat() (fs sys.Stat_t, errno experimentalsys.Errno) { - // The mode is not really important, but it should be neither a regular file nor a directory. - fs.Mode = os.ModeIrregular - return -} - -var _ socketapi.TCPSock = (*tcpListenerFile)(nil) - -type tcpListenerFile struct { - baseSockFile - - tl *net.TCPListener - closed bool - nonblock bool -} - -// newTCPListenerFile is a constructor for a socketapi.TCPSock. -// -// The current strategy is to wrap a net.TCPListener -// and invoking raw syscalls using syscallConnControl: -// this internal calls RawConn.Control(func(fd)), making sure -// that the underlying file descriptor is valid throughout -// the duration of the syscall. -func newDefaultTCPListenerFile(tl *net.TCPListener) socketapi.TCPSock { - return &tcpListenerFile{tl: tl} -} - -// Close implements the same method as documented on experimentalsys.File -func (f *tcpListenerFile) Close() experimentalsys.Errno { - if !f.closed { - return experimentalsys.UnwrapOSError(f.tl.Close()) - } - return 0 -} - -// Addr is exposed for testing. -func (f *tcpListenerFile) Addr() *net.TCPAddr { - return f.tl.Addr().(*net.TCPAddr) -} - -// IsNonblock implements the same method as documented on fsapi.File -func (f *tcpListenerFile) IsNonblock() bool { - return f.nonblock -} - -// Poll implements the same method as documented on fsapi.File -func (f *tcpListenerFile) Poll(flag fsapi.Pflag, timeoutMillis int32) (ready bool, errno experimentalsys.Errno) { - return false, experimentalsys.ENOSYS -} - -var _ socketapi.TCPConn = (*tcpConnFile)(nil) - -type tcpConnFile struct { - baseSockFile - - tc *net.TCPConn - - // nonblock is true when the underlying connection is flagged as non-blocking. - // This ensures that reads and writes return experimentalsys.EAGAIN without blocking the caller. - nonblock bool - // closed is true when closed was called. This ensures proper experimentalsys.EBADF - closed bool -} - -func newTcpConn(tc *net.TCPConn) socketapi.TCPConn { - return &tcpConnFile{tc: tc} -} - -// Read implements the same method as documented on experimentalsys.File -func (f *tcpConnFile) Read(buf []byte) (n int, errno experimentalsys.Errno) { - if len(buf) == 0 { - return 0, 0 // Short-circuit 0-len reads. - } - if nonBlockingFileReadSupported && f.IsNonblock() { - n, errno = syscallConnControl(f.tc, func(fd uintptr) (int, experimentalsys.Errno) { - n, err := readSocket(fd, buf) - errno = experimentalsys.UnwrapOSError(err) - errno = fileError(f, f.closed, errno) - return n, errno - }) - } else { - n, errno = read(f.tc, buf) - } - if errno != 0 { - // Defer validation overhead until we've already had an error. - errno = fileError(f, f.closed, errno) - } - return -} - -// Write implements the same method as documented on experimentalsys.File -func (f *tcpConnFile) Write(buf []byte) (n int, errno experimentalsys.Errno) { - if nonBlockingFileWriteSupported && f.IsNonblock() { - return syscallConnControl(f.tc, func(fd uintptr) (int, experimentalsys.Errno) { - n, err := writeSocket(fd, buf) - errno = experimentalsys.UnwrapOSError(err) - errno = fileError(f, f.closed, errno) - return n, errno - }) - } else { - n, errno = write(f.tc, buf) - } - if errno != 0 { - // Defer validation overhead until we've already had an error. - errno = fileError(f, f.closed, errno) - } - return -} - -// Recvfrom implements the same method as documented on socketapi.TCPConn -func (f *tcpConnFile) Recvfrom(p []byte, flags int) (n int, errno experimentalsys.Errno) { - if flags != MSG_PEEK { - errno = experimentalsys.EINVAL - return - } - return syscallConnControl(f.tc, func(fd uintptr) (int, experimentalsys.Errno) { - n, err := recvfrom(fd, p, MSG_PEEK) - errno = experimentalsys.UnwrapOSError(err) - errno = fileError(f, f.closed, errno) - return n, errno - }) -} - -// Close implements the same method as documented on experimentalsys.File -func (f *tcpConnFile) Close() experimentalsys.Errno { - return f.close() -} - -func (f *tcpConnFile) close() experimentalsys.Errno { - if f.closed { - return 0 - } - f.closed = true - return f.Shutdown(socketapi.SHUT_RDWR) -} - -// SetNonblock implements the same method as documented on fsapi.File -func (f *tcpConnFile) SetNonblock(enabled bool) (errno experimentalsys.Errno) { - f.nonblock = enabled - _, errno = syscallConnControl(f.tc, func(fd uintptr) (int, experimentalsys.Errno) { - return 0, experimentalsys.UnwrapOSError(setNonblockSocket(fd, enabled)) - }) - return -} - -// IsNonblock implements the same method as documented on fsapi.File -func (f *tcpConnFile) IsNonblock() bool { - return f.nonblock -} - -// Poll implements the same method as documented on fsapi.File -func (f *tcpConnFile) Poll(flag fsapi.Pflag, timeoutMillis int32) (ready bool, errno experimentalsys.Errno) { - return false, experimentalsys.ENOSYS -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/sock_supported.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/sock_supported.go deleted file mode 100644 index 6c976fb86..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/sock_supported.go +++ /dev/null @@ -1,77 +0,0 @@ -//go:build (linux || darwin || windows) && !tinygo - -package sysfs - -import ( - "net" - "syscall" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/internal/fsapi" - socketapi "github.com/tetratelabs/wazero/internal/sock" -) - -// Accept implements the same method as documented on socketapi.TCPSock -func (f *tcpListenerFile) Accept() (socketapi.TCPConn, experimentalsys.Errno) { - // Ensure we have an incoming connection, otherwise return immediately. - if f.nonblock { - if ready, errno := _pollSock(f.tl, fsapi.POLLIN, 0); !ready || errno != 0 { - return nil, experimentalsys.EAGAIN - } - } - - // Accept normally blocks goroutines, but we - // made sure that we have an incoming connection, - // so we should be safe. - if conn, err := f.tl.Accept(); err != nil { - return nil, experimentalsys.UnwrapOSError(err) - } else { - return newTcpConn(conn.(*net.TCPConn)), 0 - } -} - -// SetNonblock implements the same method as documented on fsapi.File -func (f *tcpListenerFile) SetNonblock(enabled bool) (errno experimentalsys.Errno) { - f.nonblock = enabled - _, errno = syscallConnControl(f.tl, func(fd uintptr) (int, experimentalsys.Errno) { - return 0, setNonblockSocket(fd, enabled) - }) - return -} - -// Shutdown implements the same method as documented on experimentalsys.Conn -func (f *tcpConnFile) Shutdown(how int) experimentalsys.Errno { - // FIXME: can userland shutdown listeners? - var err error - switch how { - case socketapi.SHUT_RD: - err = f.tc.CloseRead() - case socketapi.SHUT_WR: - err = f.tc.CloseWrite() - case socketapi.SHUT_RDWR: - return f.close() - default: - return experimentalsys.EINVAL - } - return experimentalsys.UnwrapOSError(err) -} - -// syscallConnControl extracts a syscall.RawConn from the given syscall.Conn and applies -// the given fn to a file descriptor, returning an integer or a nonzero syscall.Errno on failure. -// -// syscallConnControl streamlines the pattern of extracting the syscall.Rawconn, -// invoking its syscall.RawConn.Control method, then handling properly the errors that may occur -// within fn or returned by syscall.RawConn.Control itself. -func syscallConnControl(conn syscall.Conn, fn func(fd uintptr) (int, experimentalsys.Errno)) (n int, errno experimentalsys.Errno) { - syscallConn, err := conn.SyscallConn() - if err != nil { - return 0, experimentalsys.UnwrapOSError(err) - } - // Prioritize the inner errno over Control - if controlErr := syscallConn.Control(func(fd uintptr) { - n, errno = fn(fd) - }); errno == 0 { - errno = experimentalsys.UnwrapOSError(controlErr) - } - return -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/sock_unix.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/sock_unix.go deleted file mode 100644 index 99ef018a4..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/sock_unix.go +++ /dev/null @@ -1,49 +0,0 @@ -//go:build (linux || darwin) && !tinygo - -package sysfs - -import ( - "net" - "syscall" - - "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/internal/fsapi" - socketapi "github.com/tetratelabs/wazero/internal/sock" -) - -// MSG_PEEK is the constant syscall.MSG_PEEK -const MSG_PEEK = syscall.MSG_PEEK - -func newTCPListenerFile(tl *net.TCPListener) socketapi.TCPSock { - return newDefaultTCPListenerFile(tl) -} - -func _pollSock(conn syscall.Conn, flag fsapi.Pflag, timeoutMillis int32) (bool, sys.Errno) { - n, errno := syscallConnControl(conn, func(fd uintptr) (int, sys.Errno) { - if ready, errno := poll(fd, fsapi.POLLIN, 0); !ready || errno != 0 { - return -1, errno - } else { - return 0, errno - } - }) - return n >= 0, errno -} - -func setNonblockSocket(fd uintptr, enabled bool) sys.Errno { - return sys.UnwrapOSError(setNonblock(fd, enabled)) -} - -func readSocket(fd uintptr, buf []byte) (int, sys.Errno) { - n, err := syscall.Read(int(fd), buf) - return n, sys.UnwrapOSError(err) -} - -func writeSocket(fd uintptr, buf []byte) (int, sys.Errno) { - n, err := syscall.Write(int(fd), buf) - return n, sys.UnwrapOSError(err) -} - -func recvfrom(fd uintptr, buf []byte, flags int32) (n int, errno sys.Errno) { - n, _, err := syscall.Recvfrom(int(fd), buf, int(flags)) - return n, sys.UnwrapOSError(err) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/sock_unsupported.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/sock_unsupported.go deleted file mode 100644 index 8c27fed7f..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/sock_unsupported.go +++ /dev/null @@ -1,81 +0,0 @@ -//go:build (!linux && !darwin && !windows) || tinygo - -package sysfs - -import ( - "net" - "syscall" - - "github.com/tetratelabs/wazero/experimental/sys" - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/internal/fsapi" - socketapi "github.com/tetratelabs/wazero/internal/sock" -) - -// MSG_PEEK is a filler value. -const MSG_PEEK = 0x2 - -func newTCPListenerFile(tl *net.TCPListener) socketapi.TCPSock { - return &unsupportedSockFile{} -} - -type unsupportedSockFile struct { - baseSockFile -} - -// Accept implements the same method as documented on socketapi.TCPSock -func (f *unsupportedSockFile) Accept() (socketapi.TCPConn, sys.Errno) { - return nil, sys.ENOSYS -} - -func _pollSock(conn syscall.Conn, flag fsapi.Pflag, timeoutMillis int32) (bool, sys.Errno) { - return false, sys.ENOTSUP -} - -func setNonblockSocket(fd uintptr, enabled bool) sys.Errno { - return sys.ENOTSUP -} - -func readSocket(fd uintptr, buf []byte) (int, sys.Errno) { - return -1, sys.ENOTSUP -} - -func writeSocket(fd uintptr, buf []byte) (int, sys.Errno) { - return -1, sys.ENOTSUP -} - -func recvfrom(fd uintptr, buf []byte, flags int32) (n int, errno sys.Errno) { - return -1, sys.ENOTSUP -} - -// syscallConnControl extracts a syscall.RawConn from the given syscall.Conn and applies -// the given fn to a file descriptor, returning an integer or a nonzero syscall.Errno on failure. -// -// syscallConnControl streamlines the pattern of extracting the syscall.Rawconn, -// invoking its syscall.RawConn.Control method, then handling properly the errors that may occur -// within fn or returned by syscall.RawConn.Control itself. -func syscallConnControl(conn syscall.Conn, fn func(fd uintptr) (int, experimentalsys.Errno)) (n int, errno sys.Errno) { - return -1, sys.ENOTSUP -} - -// Accept implements the same method as documented on socketapi.TCPSock -func (f *tcpListenerFile) Accept() (socketapi.TCPConn, experimentalsys.Errno) { - return nil, experimentalsys.ENOSYS -} - -// Shutdown implements the same method as documented on experimentalsys.Conn -func (f *tcpConnFile) Shutdown(how int) experimentalsys.Errno { - // FIXME: can userland shutdown listeners? - var err error - switch how { - case socketapi.SHUT_RD: - err = f.tc.Close() - case socketapi.SHUT_WR: - err = f.tc.Close() - case socketapi.SHUT_RDWR: - return f.close() - default: - return experimentalsys.EINVAL - } - return experimentalsys.UnwrapOSError(err) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/sock_windows.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/sock_windows.go deleted file mode 100644 index 703df42fc..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/sock_windows.go +++ /dev/null @@ -1,80 +0,0 @@ -//go:build windows - -package sysfs - -import ( - "net" - "syscall" - "unsafe" - - "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/internal/fsapi" - socketapi "github.com/tetratelabs/wazero/internal/sock" -) - -const ( - // MSG_PEEK is the flag PEEK for syscall.Recvfrom on Windows. - // This constant is not exported on this platform. - MSG_PEEK = 0x2 - // _FIONBIO is the flag to set the O_NONBLOCK flag on socket handles using ioctlsocket. - _FIONBIO = 0x8004667e -) - -var ( - // modws2_32 is WinSock. - modws2_32 = syscall.NewLazyDLL("ws2_32.dll") - // procrecvfrom exposes recvfrom from WinSock. - procrecvfrom = modws2_32.NewProc("recvfrom") - // procioctlsocket exposes ioctlsocket from WinSock. - procioctlsocket = modws2_32.NewProc("ioctlsocket") -) - -func newTCPListenerFile(tl *net.TCPListener) socketapi.TCPSock { - return newDefaultTCPListenerFile(tl) -} - -// recvfrom exposes the underlying syscall in Windows. -// -// Note: since we are only using this to expose MSG_PEEK, -// we do not need really need all the parameters that are actually -// allowed in WinSock. -// We ignore `from *sockaddr` and `fromlen *int`. -func recvfrom(s uintptr, buf []byte, flags int32) (n int, errno sys.Errno) { - var _p0 *byte - if len(buf) > 0 { - _p0 = &buf[0] - } - r0, _, e1 := syscall.SyscallN( - procrecvfrom.Addr(), - s, - uintptr(unsafe.Pointer(_p0)), - uintptr(len(buf)), - uintptr(flags), - 0, // from *sockaddr (optional) - 0) // fromlen *int (optional) - return int(r0), sys.UnwrapOSError(e1) -} - -func setNonblockSocket(fd uintptr, enabled bool) sys.Errno { - opt := uint64(0) - if enabled { - opt = 1 - } - // ioctlsocket(fd, FIONBIO, &opt) - _, _, errno := syscall.SyscallN( - procioctlsocket.Addr(), - uintptr(fd), - uintptr(_FIONBIO), - uintptr(unsafe.Pointer(&opt))) - return sys.UnwrapOSError(errno) -} - -func _pollSock(conn syscall.Conn, flag fsapi.Pflag, timeoutMillis int32) (bool, sys.Errno) { - if flag != fsapi.POLLIN { - return false, sys.ENOTSUP - } - n, errno := syscallConnControl(conn, func(fd uintptr) (int, sys.Errno) { - return _poll([]pollFd{newPollFd(fd, _POLLIN, 0)}, timeoutMillis) - }) - return n > 0, errno -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/stat.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/stat.go deleted file mode 100644 index 2d973b16c..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/stat.go +++ /dev/null @@ -1,16 +0,0 @@ -package sysfs - -import ( - "io/fs" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/sys" -) - -func defaultStatFile(f fs.File) (sys.Stat_t, experimentalsys.Errno) { - if info, err := f.Stat(); err != nil { - return sys.Stat_t{}, experimentalsys.UnwrapOSError(err) - } else { - return sys.NewStat_t(info), 0 - } -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/stat_bsd.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/stat_bsd.go deleted file mode 100644 index 254e204cd..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/stat_bsd.go +++ /dev/null @@ -1,37 +0,0 @@ -//go:build (amd64 || arm64) && (darwin || freebsd) - -package sysfs - -import ( - "io/fs" - "os" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/sys" -) - -// dirNlinkIncludesDot is true because even though os.File filters out dot -// entries, the underlying syscall.Stat includes them. -// -// Note: this is only used in tests -const dirNlinkIncludesDot = true - -func lstat(path string) (sys.Stat_t, experimentalsys.Errno) { - if info, err := os.Lstat(path); err != nil { - return sys.Stat_t{}, experimentalsys.UnwrapOSError(err) - } else { - return sys.NewStat_t(info), 0 - } -} - -func stat(path string) (sys.Stat_t, experimentalsys.Errno) { - if info, err := os.Stat(path); err != nil { - return sys.Stat_t{}, experimentalsys.UnwrapOSError(err) - } else { - return sys.NewStat_t(info), 0 - } -} - -func statFile(f fs.File) (sys.Stat_t, experimentalsys.Errno) { - return defaultStatFile(f) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/stat_linux.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/stat_linux.go deleted file mode 100644 index fd289756d..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/stat_linux.go +++ /dev/null @@ -1,40 +0,0 @@ -//go:build (amd64 || arm64 || riscv64) && linux - -// Note: This expression is not the same as compiler support, even if it looks -// similar. Platform functions here are used in interpreter mode as well. - -package sysfs - -import ( - "io/fs" - "os" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/sys" -) - -// dirNlinkIncludesDot is true because even though os.File filters out dot -// entries, the underlying syscall.Stat includes them. -// -// Note: this is only used in tests -const dirNlinkIncludesDot = true - -func lstat(path string) (sys.Stat_t, experimentalsys.Errno) { - if info, err := os.Lstat(path); err != nil { - return sys.Stat_t{}, experimentalsys.UnwrapOSError(err) - } else { - return sys.NewStat_t(info), 0 - } -} - -func stat(path string) (sys.Stat_t, experimentalsys.Errno) { - if info, err := os.Stat(path); err != nil { - return sys.Stat_t{}, experimentalsys.UnwrapOSError(err) - } else { - return sys.NewStat_t(info), 0 - } -} - -func statFile(f fs.File) (sys.Stat_t, experimentalsys.Errno) { - return defaultStatFile(f) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/stat_unsupported.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/stat_unsupported.go deleted file mode 100644 index 4b05a8977..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/stat_unsupported.go +++ /dev/null @@ -1,40 +0,0 @@ -//go:build (!((amd64 || arm64 || riscv64) && linux) && !((amd64 || arm64) && (darwin || freebsd)) && !((amd64 || arm64) && windows)) || js - -package sysfs - -import ( - "io/fs" - "os" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/sys" -) - -// Note: go:build constraints must be the same as /sys.stat_unsupported.go for -// the same reasons. - -// dirNlinkIncludesDot might be true for some operating systems, which can have -// new stat_XX.go files as necessary. -// -// Note: this is only used in tests -const dirNlinkIncludesDot = false - -func lstat(path string) (sys.Stat_t, experimentalsys.Errno) { - if info, err := os.Lstat(path); err != nil { - return sys.Stat_t{}, experimentalsys.UnwrapOSError(err) - } else { - return sys.NewStat_t(info), 0 - } -} - -func stat(path string) (sys.Stat_t, experimentalsys.Errno) { - if info, err := os.Stat(path); err != nil { - return sys.Stat_t{}, experimentalsys.UnwrapOSError(err) - } else { - return sys.NewStat_t(info), 0 - } -} - -func statFile(f fs.File) (sys.Stat_t, experimentalsys.Errno) { - return defaultStatFile(f) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/stat_windows.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/stat_windows.go deleted file mode 100644 index 4456dd782..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/stat_windows.go +++ /dev/null @@ -1,120 +0,0 @@ -//go:build (amd64 || arm64) && windows - -package sysfs - -import ( - "io/fs" - "syscall" - - experimentalsys "github.com/tetratelabs/wazero/experimental/sys" - "github.com/tetratelabs/wazero/sys" -) - -// dirNlinkIncludesDot is false because Windows does not return dot entries. -// -// Note: this is only used in tests -const dirNlinkIncludesDot = false - -func lstat(path string) (sys.Stat_t, experimentalsys.Errno) { - attrs := uint32(syscall.FILE_FLAG_BACKUP_SEMANTICS) - // Use FILE_FLAG_OPEN_REPARSE_POINT, otherwise CreateFile will follow symlink. - // See https://docs.microsoft.com/en-us/windows/desktop/FileIO/symbolic-link-effects-on-file-systems-functions#createfile-and-createfiletransacted - attrs |= syscall.FILE_FLAG_OPEN_REPARSE_POINT - return statPath(attrs, path) -} - -func stat(path string) (sys.Stat_t, experimentalsys.Errno) { - attrs := uint32(syscall.FILE_FLAG_BACKUP_SEMANTICS) - return statPath(attrs, path) -} - -func statPath(createFileAttrs uint32, path string) (sys.Stat_t, experimentalsys.Errno) { - if len(path) == 0 { - return sys.Stat_t{}, experimentalsys.ENOENT - } - pathp, err := syscall.UTF16PtrFromString(path) - if err != nil { - return sys.Stat_t{}, experimentalsys.EINVAL - } - - // open the file handle - h, err := syscall.CreateFile(pathp, 0, 0, nil, - syscall.OPEN_EXISTING, createFileAttrs, 0) - if err != nil { - errno := experimentalsys.UnwrapOSError(err) - // To match expectations of WASI, e.g. TinyGo TestStatBadDir, return - // ENOENT, not ENOTDIR. - if errno == experimentalsys.ENOTDIR { - errno = experimentalsys.ENOENT - } - return sys.Stat_t{}, errno - } - defer syscall.CloseHandle(h) - - return statHandle(h) -} - -// fdFile allows masking the `Fd` function on os.File. -type fdFile interface { - Fd() uintptr -} - -func statFile(f fs.File) (sys.Stat_t, experimentalsys.Errno) { - if osF, ok := f.(fdFile); ok { - // Attempt to get the stat by handle, which works for normal files - st, err := statHandle(syscall.Handle(osF.Fd())) - - // ERROR_INVALID_HANDLE happens before Go 1.20. Don't fail as we only - // use that approach to fill in inode data, which is not critical. - // - // Note: statHandle uses UnwrapOSError which coerces - // ERROR_INVALID_HANDLE to EBADF. - if err != experimentalsys.EBADF { - return st, err - } - } - return defaultStatFile(f) -} - -func statHandle(h syscall.Handle) (sys.Stat_t, experimentalsys.Errno) { - winFt, err := syscall.GetFileType(h) - if err != nil { - return sys.Stat_t{}, experimentalsys.UnwrapOSError(err) - } - - var fi syscall.ByHandleFileInformation - if err = syscall.GetFileInformationByHandle(h, &fi); err != nil { - return sys.Stat_t{}, experimentalsys.UnwrapOSError(err) - } - - var m fs.FileMode - if fi.FileAttributes&syscall.FILE_ATTRIBUTE_READONLY != 0 { - m |= 0o444 - } else { - m |= 0o666 - } - - switch { // check whether this is a symlink first - case fi.FileAttributes&syscall.FILE_ATTRIBUTE_REPARSE_POINT != 0: - m |= fs.ModeSymlink - case winFt == syscall.FILE_TYPE_PIPE: - m |= fs.ModeNamedPipe - case winFt == syscall.FILE_TYPE_CHAR: - m |= fs.ModeDevice | fs.ModeCharDevice - case fi.FileAttributes&syscall.FILE_ATTRIBUTE_DIRECTORY != 0: - m |= fs.ModeDir | 0o111 // e.g. 0o444 -> 0o555 - } - - st := sys.Stat_t{} - // FileIndex{High,Low} can be combined and used as a unique identifier like inode. - // https://learn.microsoft.com/en-us/windows/win32/api/fileapi/ns-fileapi-by_handle_file_information - st.Dev = uint64(fi.VolumeSerialNumber) - st.Ino = (uint64(fi.FileIndexHigh) << 32) | uint64(fi.FileIndexLow) - st.Mode = m - st.Nlink = uint64(fi.NumberOfLinks) - st.Size = int64(fi.FileSizeHigh)<<32 + int64(fi.FileSizeLow) - st.Atim = fi.LastAccessTime.Nanoseconds() - st.Mtim = fi.LastWriteTime.Nanoseconds() - st.Ctim = fi.CreationTime.Nanoseconds() - return st, 0 -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/sync.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/sync.go deleted file mode 100644 index 86f9a0865..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/sync.go +++ /dev/null @@ -1,13 +0,0 @@ -//go:build !windows - -package sysfs - -import ( - "os" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func fsync(f *os.File) sys.Errno { - return sys.UnwrapOSError(f.Sync()) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/sync_windows.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/sync_windows.go deleted file mode 100644 index f288eb25b..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/sync_windows.go +++ /dev/null @@ -1,20 +0,0 @@ -package sysfs - -import ( - "os" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func fsync(f *os.File) sys.Errno { - errno := sys.UnwrapOSError(f.Sync()) - // Coerce error performing stat on a directory to 0, as it won't work - // on Windows. - switch errno { - case sys.EACCES /* Go 1.20 */, sys.EBADF /* Go 1.19 */ : - if st, err := f.Stat(); err == nil && st.IsDir() { - errno = 0 - } - } - return errno -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/syscall6_darwin.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/syscall6_darwin.go deleted file mode 100644 index 9fde5baa5..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/syscall6_darwin.go +++ /dev/null @@ -1,13 +0,0 @@ -package sysfs - -import ( - "syscall" - _ "unsafe" -) - -// syscall_syscall6 is a private symbol that we link below. We need to use this -// instead of syscall.Syscall6 because the public syscall.Syscall6 won't work -// when fn is an address. -// -//go:linkname syscall_syscall6 syscall.syscall6 -func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/sysfs.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/sysfs.go deleted file mode 100644 index dd0a8882e..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/sysfs.go +++ /dev/null @@ -1,6 +0,0 @@ -// Package sysfs includes a low-level filesystem interface and utilities needed -// for WebAssembly host functions (ABI) such as WASI. -// -// 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 diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/unlink.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/unlink.go deleted file mode 100644 index e3f051008..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/unlink.go +++ /dev/null @@ -1,17 +0,0 @@ -//go:build !windows && !plan9 && !tinygo - -package sysfs - -import ( - "syscall" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func unlink(name string) (errno sys.Errno) { - err := syscall.Unlink(name) - if errno = sys.UnwrapOSError(err); errno == sys.EPERM { - errno = sys.EISDIR - } - return errno -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/unlink_plan9.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/unlink_plan9.go deleted file mode 100644 index 16ed06ab2..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/unlink_plan9.go +++ /dev/null @@ -1,12 +0,0 @@ -package sysfs - -import ( - "syscall" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func unlink(name string) sys.Errno { - err := syscall.Remove(name) - return sys.UnwrapOSError(err) -} diff --git a/vendor/github.com/tetratelabs/wazero/internal/sysfs/unlink_windows.go b/vendor/github.com/tetratelabs/wazero/internal/sysfs/unlink_windows.go deleted file mode 100644 index be31c7b91..000000000 --- a/vendor/github.com/tetratelabs/wazero/internal/sysfs/unlink_windows.go +++ /dev/null @@ -1,25 +0,0 @@ -package sysfs - -import ( - "os" - "syscall" - - "github.com/tetratelabs/wazero/experimental/sys" -) - -func unlink(name string) sys.Errno { - err := syscall.Unlink(name) - if err == nil { - return 0 - } - errno := sys.UnwrapOSError(err) - if errno == sys.EBADF { - lstat, errLstat := os.Lstat(name) - if errLstat == nil && lstat.Mode()&os.ModeSymlink != 0 { - errno = sys.UnwrapOSError(os.Remove(name)) - } else { - errno = sys.EISDIR - } - } - return errno -} |