| // Copyright 2023 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| //go:build wasip1 |
| |
| package syscall |
| |
| import ( |
| "errors" |
| "internal/itoa" |
| "internal/oserror" |
| "unsafe" |
| ) |
| |
| type Dircookie = uint64 |
| |
| type Filetype = uint8 |
| |
| const ( |
| FILETYPE_UNKNOWN Filetype = iota |
| FILETYPE_BLOCK_DEVICE |
| FILETYPE_CHARACTER_DEVICE |
| FILETYPE_DIRECTORY |
| FILETYPE_REGULAR_FILE |
| FILETYPE_SOCKET_DGRAM |
| FILETYPE_SOCKET_STREAM |
| FILETYPE_SYMBOLIC_LINK |
| ) |
| |
| type Dirent struct { |
| // The offset of the next directory entry stored in this directory. |
| Next Dircookie |
| // The serial number of the file referred to by this directory entry. |
| Ino uint64 |
| // The length of the name of the directory entry. |
| Namlen uint32 |
| // The type of the file referred to by this directory entry. |
| Type Filetype |
| // Name of the directory entry. |
| Name *byte |
| } |
| |
| func direntIno(buf []byte) (uint64, bool) { |
| return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino)) |
| } |
| |
| func direntReclen(buf []byte) (uint64, bool) { |
| namelen, ok := direntNamlen(buf) |
| return 24 + namelen, ok |
| } |
| |
| func direntNamlen(buf []byte) (uint64, bool) { |
| return readInt(buf, unsafe.Offsetof(Dirent{}.Namlen), unsafe.Sizeof(Dirent{}.Namlen)) |
| } |
| |
| // An Errno is an unsigned number describing an error condition. |
| // It implements the error interface. The zero Errno is by convention |
| // a non-error, so code to convert from Errno to error should use: |
| // |
| // var err = nil |
| // if errno != 0 { |
| // err = errno |
| // } |
| type Errno uint32 |
| |
| func (e Errno) Error() string { |
| if 0 <= int(e) && int(e) < len(errorstr) { |
| s := errorstr[e] |
| if s != "" { |
| return s |
| } |
| } |
| return "errno " + itoa.Itoa(int(e)) |
| } |
| |
| func (e Errno) Is(target error) bool { |
| switch target { |
| case oserror.ErrPermission: |
| return e == EACCES || e == EPERM |
| case oserror.ErrExist: |
| return e == EEXIST || e == ENOTEMPTY |
| case oserror.ErrNotExist: |
| return e == ENOENT |
| case errors.ErrUnsupported: |
| return e == ENOSYS |
| } |
| return false |
| } |
| |
| func (e Errno) Temporary() bool { |
| return e == EINTR || e == EMFILE || e.Timeout() |
| } |
| |
| func (e Errno) Timeout() bool { |
| return e == EAGAIN || e == ETIMEDOUT |
| } |
| |
| // A Signal is a number describing a process signal. |
| // It implements the [os.Signal] interface. |
| type Signal uint8 |
| |
| const ( |
| SIGNONE Signal = iota |
| SIGHUP |
| SIGINT |
| SIGQUIT |
| SIGILL |
| SIGTRAP |
| SIGABRT |
| SIGBUS |
| SIGFPE |
| SIGKILL |
| SIGUSR1 |
| SIGSEGV |
| SIGUSR2 |
| SIGPIPE |
| SIGALRM |
| SIGTERM |
| SIGCHLD |
| SIGCONT |
| SIGSTOP |
| SIGTSTP |
| SIGTTIN |
| SIGTTOU |
| SIGURG |
| SIGXCPU |
| SIGXFSZ |
| SIGVTARLM |
| SIGPROF |
| SIGWINCH |
| SIGPOLL |
| SIGPWR |
| SIGSYS |
| ) |
| |
| func (s Signal) Signal() {} |
| |
| func (s Signal) String() string { |
| switch s { |
| case SIGNONE: |
| return "no signal" |
| case SIGHUP: |
| return "hangup" |
| case SIGINT: |
| return "interrupt" |
| case SIGQUIT: |
| return "quit" |
| case SIGILL: |
| return "illegal instruction" |
| case SIGTRAP: |
| return "trace/breakpoint trap" |
| case SIGABRT: |
| return "abort" |
| case SIGBUS: |
| return "bus error" |
| case SIGFPE: |
| return "floating point exception" |
| case SIGKILL: |
| return "killed" |
| case SIGUSR1: |
| return "user defined signal 1" |
| case SIGSEGV: |
| return "segmentation fault" |
| case SIGUSR2: |
| return "user defined signal 2" |
| case SIGPIPE: |
| return "broken pipe" |
| case SIGALRM: |
| return "alarm clock" |
| case SIGTERM: |
| return "terminated" |
| case SIGCHLD: |
| return "child exited" |
| case SIGCONT: |
| return "continued" |
| case SIGSTOP: |
| return "stopped (signal)" |
| case SIGTSTP: |
| return "stopped" |
| case SIGTTIN: |
| return "stopped (tty input)" |
| case SIGTTOU: |
| return "stopped (tty output)" |
| case SIGURG: |
| return "urgent I/O condition" |
| case SIGXCPU: |
| return "CPU time limit exceeded" |
| case SIGXFSZ: |
| return "file size limit exceeded" |
| case SIGVTARLM: |
| return "virtual timer expired" |
| case SIGPROF: |
| return "profiling timer expired" |
| case SIGWINCH: |
| return "window changed" |
| case SIGPOLL: |
| return "I/O possible" |
| case SIGPWR: |
| return "power failure" |
| case SIGSYS: |
| return "bad system call" |
| default: |
| return "signal " + itoa.Itoa(int(s)) |
| } |
| } |
| |
| const ( |
| Stdin = 0 |
| Stdout = 1 |
| Stderr = 2 |
| ) |
| |
| const ( |
| O_RDONLY = 0 |
| O_WRONLY = 1 |
| O_RDWR = 2 |
| |
| O_CREAT = 0100 |
| O_CREATE = O_CREAT |
| O_TRUNC = 01000 |
| O_APPEND = 02000 |
| O_EXCL = 0200 |
| O_SYNC = 010000 |
| |
| O_CLOEXEC = 0 |
| ) |
| |
| const ( |
| F_DUPFD = 0 |
| F_GETFD = 1 |
| F_SETFD = 2 |
| F_GETFL = 3 |
| F_SETFL = 4 |
| F_GETOWN = 5 |
| F_SETOWN = 6 |
| F_GETLK = 7 |
| F_SETLK = 8 |
| F_SETLKW = 9 |
| F_RGETLK = 10 |
| F_RSETLK = 11 |
| F_CNVT = 12 |
| F_RSETLKW = 13 |
| |
| F_RDLCK = 1 |
| F_WRLCK = 2 |
| F_UNLCK = 3 |
| F_UNLKSYS = 4 |
| ) |
| |
| const ( |
| S_IFMT = 0000370000 |
| S_IFSHM_SYSV = 0000300000 |
| S_IFSEMA = 0000270000 |
| S_IFCOND = 0000260000 |
| S_IFMUTEX = 0000250000 |
| S_IFSHM = 0000240000 |
| S_IFBOUNDSOCK = 0000230000 |
| S_IFSOCKADDR = 0000220000 |
| S_IFDSOCK = 0000210000 |
| |
| S_IFSOCK = 0000140000 |
| S_IFLNK = 0000120000 |
| S_IFREG = 0000100000 |
| S_IFBLK = 0000060000 |
| S_IFDIR = 0000040000 |
| S_IFCHR = 0000020000 |
| S_IFIFO = 0000010000 |
| |
| S_UNSUP = 0000370000 |
| |
| S_ISUID = 0004000 |
| S_ISGID = 0002000 |
| S_ISVTX = 0001000 |
| |
| S_IREAD = 0400 |
| S_IWRITE = 0200 |
| S_IEXEC = 0100 |
| |
| S_IRWXU = 0700 |
| S_IRUSR = 0400 |
| S_IWUSR = 0200 |
| S_IXUSR = 0100 |
| |
| S_IRWXG = 070 |
| S_IRGRP = 040 |
| S_IWGRP = 020 |
| S_IXGRP = 010 |
| |
| S_IRWXO = 07 |
| S_IROTH = 04 |
| S_IWOTH = 02 |
| S_IXOTH = 01 |
| ) |
| |
| type WaitStatus uint32 |
| |
| func (w WaitStatus) Exited() bool { return false } |
| func (w WaitStatus) ExitStatus() int { return 0 } |
| func (w WaitStatus) Signaled() bool { return false } |
| func (w WaitStatus) Signal() Signal { return 0 } |
| func (w WaitStatus) CoreDump() bool { return false } |
| func (w WaitStatus) Stopped() bool { return false } |
| func (w WaitStatus) Continued() bool { return false } |
| func (w WaitStatus) StopSignal() Signal { return 0 } |
| func (w WaitStatus) TrapCause() int { return 0 } |
| |
| // Rusage is a placeholder to allow compilation of the [os/exec] package |
| // because we need Go programs to be portable across platforms. WASI does |
| // not have a mechanism to to spawn processes so there is no reason for an |
| // application to take a dependency on this type. |
| type Rusage struct { |
| Utime Timeval |
| Stime Timeval |
| } |
| |
| // ProcAttr is a placeholder to allow compilation of the [os/exec] package |
| // because we need Go programs to be portable across platforms. WASI does |
| // not have a mechanism to to spawn processes so there is no reason for an |
| // application to take a dependency on this type. |
| type ProcAttr struct { |
| Dir string |
| Env []string |
| Files []uintptr |
| Sys *SysProcAttr |
| } |
| |
| type SysProcAttr struct { |
| } |
| |
| func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) { |
| return 0, 0, ENOSYS |
| } |
| |
| func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) { |
| return 0, 0, ENOSYS |
| } |
| |
| func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) { |
| return 0, 0, ENOSYS |
| } |
| |
| func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) { |
| return 0, 0, ENOSYS |
| } |
| |
| func Sysctl(key string) (string, error) { |
| if key == "kern.hostname" { |
| return "wasip1", nil |
| } |
| return "", ENOSYS |
| } |
| |
| func Getuid() int { |
| return 1 |
| } |
| |
| func Getgid() int { |
| return 1 |
| } |
| |
| func Geteuid() int { |
| return 1 |
| } |
| |
| func Getegid() int { |
| return 1 |
| } |
| |
| func Getgroups() ([]int, error) { |
| return []int{1}, nil |
| } |
| |
| func Getpid() int { |
| return 3 |
| } |
| |
| func Getppid() int { |
| return 2 |
| } |
| |
| func Gettimeofday(tv *Timeval) error { |
| var time timestamp |
| if errno := clock_time_get(clockRealtime, 1e3, unsafe.Pointer(&time)); errno != 0 { |
| return errno |
| } |
| tv.setTimestamp(time) |
| return nil |
| } |
| |
| func Kill(pid int, signum Signal) error { |
| // WASI does not have the notion of processes nor signal handlers. |
| // |
| // Any signal that the application raises to the process itself will |
| // be interpreted as being cause for termination. |
| if pid > 0 && pid != Getpid() { |
| return ESRCH |
| } |
| ProcExit(128 + int32(signum)) |
| return nil |
| } |
| |
| func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { |
| return 0, ENOSYS |
| } |
| |
| func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle uintptr, err error) { |
| return 0, 0, ENOSYS |
| } |
| |
| func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { |
| return 0, ENOSYS |
| } |
| |
| func Umask(mask int) int { |
| return 0 |
| } |
| |
| type Timespec struct { |
| Sec int64 |
| Nsec int64 |
| } |
| |
| func (ts *Timespec) timestamp() timestamp { |
| return timestamp(ts.Sec*1e9) + timestamp(ts.Nsec) |
| } |
| |
| func (ts *Timespec) setTimestamp(t timestamp) { |
| ts.Sec = int64(t / 1e9) |
| ts.Nsec = int64(t % 1e9) |
| } |
| |
| type Timeval struct { |
| Sec int64 |
| Usec int64 |
| } |
| |
| func (tv *Timeval) timestamp() timestamp { |
| return timestamp(tv.Sec*1e9) + timestamp(tv.Usec*1e3) |
| } |
| |
| func (tv *Timeval) setTimestamp(t timestamp) { |
| tv.Sec = int64(t / 1e9) |
| tv.Usec = int64((t % 1e9) / 1e3) |
| } |
| |
| func setTimespec(sec, nsec int64) Timespec { |
| return Timespec{Sec: sec, Nsec: nsec} |
| } |
| |
| func setTimeval(sec, usec int64) Timeval { |
| return Timeval{Sec: sec, Usec: usec} |
| } |
| |
| type clockid = uint32 |
| |
| const ( |
| clockRealtime clockid = iota |
| clockMonotonic |
| clockProcessCPUTimeID |
| clockThreadCPUTimeID |
| ) |
| |
| //go:wasmimport wasi_snapshot_preview1 clock_time_get |
| //go:noescape |
| func clock_time_get(id clockid, precision timestamp, time unsafe.Pointer) Errno |
| |
| func SetNonblock(fd int, nonblocking bool) error { |
| flags, err := fd_fdstat_get_flags(fd) |
| if err != nil { |
| return err |
| } |
| if nonblocking { |
| flags |= FDFLAG_NONBLOCK |
| } else { |
| flags &^= FDFLAG_NONBLOCK |
| } |
| errno := fd_fdstat_set_flags(int32(fd), flags) |
| return errnoErr(errno) |
| } |
| |
| type Rlimit struct { |
| Cur uint64 |
| Max uint64 |
| } |
| |
| const ( |
| RLIMIT_NOFILE = iota |
| ) |
| |
| func Getrlimit(which int, lim *Rlimit) error { |
| return ENOSYS |
| } |
