wasi

type Child struct {
	// contains filtered or unexported fields
}

type Config struct {
	Args, Env []string
	FS        *rootfs.FS
	// Mounts are further trees, each preopened under its own path after
	// "/" (fd 4 onwards), as wasmtime's --dir host::guest does: a guest
	// resolves an absolute path against the longest matching preopen.
	Mounts         []Mount
	Stdin          io.Reader
	Stdout, Stderr io.Writer
	// Now is the realtime clock (default time.Now).
	Now func() time.Time
	// Rand is the randomness source (default crypto/rand).
	Rand io.Reader
	// Net is the container's place on a network; nil means no network
	// (sock_open fails with ENOTSUP).
	Net netdriver.Endpoint
	// Modules are the host modules served beside wasi_snapshot_preview1,
	// in the order of the import table (Imports); an executor passes the
	// same list it defined the imports from.
	Modules []HostModule
	// Caps are the capabilities the process was started with ("gpu").
	Caps []string
	// Parent is the process that started this one, if any.
	Parent *Proc
	// FDs, when set, is the initial descriptor table (a spawned child's,
	// from CloneFDs) instead of stdio, "/" and the mounts.
	FDs *FDTable
	// Group is the container's process tree (pids, limits, kill); nil
	// makes a group of this process alone.
	Group *Group
	// Spawner starts child processes (the executor's); nil refuses them.
	Spawner Spawner
	// Terminal describes the container's terminal, if any.
	Terminal *Terminal
	// MemoryLimitBytes is this process's linear-memory limit, reserved
	// in the group's memory budget.
	MemoryLimitBytes int64
	// Admitted says Group.Admit already reserved this process's room (a
	// Spawner sets it).
	Admitted bool
	// Label names the process's container (runtime.Spec.ID): host modules
	// report it with what they show of the process (a surface's pane).
	Label string
}

type ExitStatus struct {
	// Code is the proc_exit code (the full u32; WASIX reports its low 16
	// bits, so 0..255 survive), when Signal is 0.
	Code uint32
	// Signal is 9 (SIGKILL) for a process killed or timed out, 6
	// (SIGABRT) for one that trapped, 0 for a normal exit.
	Signal int
}

type FDOp struct {
	Kind    FDOpKind
	FD, To  uint32
	Path    string
	OFlags  uint32 // preview 1 oflags (creat, directory, excl, trunc)
	FDFlags uint32 // preview 1 fdflags (append, nonblock)
	Write   bool
}

type FDOpKind int

type FDTable struct {
	Cwd string
	// contains filtered or unexported fields
}

type Func struct {
	Name   string
	Params string // one of I32/I64 per parameter
	// NoResult is set for proc_exit; every other function returns an errno.
	NoResult bool
}

type Group struct {
	// contains filtered or unexported fields
}

type GroupLimits struct {
	// MaxProcs bounds the processes alive at once (default 64).
	MaxProcs int
	// MaxMemoryBytes bounds the sum of their memory limits (default: no
	// bound beyond MaxProcs).
	MaxMemoryBytes int64
	// SpawnRate and SpawnBurst bound spawns per second, as a token bucket
	// (defaults 32 per second, bursts of 64).
	SpawnRate  float64
	SpawnBurst int
}

type HostFunc struct {
	Name string
	// Params has one of I32, I64, F32, F64 per parameter.
	Params string
	// Result is "" (no result) or one of I32, I64, F32, F64. The value is
	// Result.Ret; an F32 or F64 travels as its IEEE-754 bits.
	Result string
}

type HostModule interface {
	// Module is the import module name, e.g. "wasi_ephemeral_nn".
	Module() string
	// Funcs lists the functions, in an order the module indexes by.
	Funcs() []HostFunc
	// Open makes the module's state for process p, at p's first call into
	// it. It never fails: a process denied the module (no capability) gets
	// an Instance that answers with the module's own error values.
	Open(p *Proc) Instance
}

type Import struct {
	Module, Name   string
	Params, Result string
}

type Instance interface {
	// Call runs function fn of Funcs with one value per parameter (I32
	// in the low 32 bits, F32/F64 as bits).
	Call(fn int, args []uint64, m Memory) Result
	// Close releases the state when the process ends. It may run while a
	// Wait the instance returned is still pending; a later Resume must
	// then fail rather than touch released state.
	Close()
}

type Memory interface {
	Read(off, n uint32) ([]byte, bool)
	Write(off uint32, b []byte) bool
}

type Mount struct {
	Path     string
	FS       *rootfs.FS
	ReadOnly bool
}

type Proc struct {
	// contains filtered or unexported fields
}

type Realloc struct {
	Align, Size uint32
	Then        func(ptr uint32, m Memory) Result
}

type Result struct {
	Errno uint32
	// Sleep asks the host to block the guest this long before returning
	// (poll_oneoff on clocks). The host may cut it short on a kill.
	Sleep time.Duration
	// Wait, when set, asks the host to block until Wait is closed, Sleep
	// (if not zero) has passed, or the process is killed, and then to
	// return what Resume returns instead (which may ask to wait again).
	// The call itself never blocks: sockets wait this way.
	Wait   <-chan struct{}
	Resume func(m Memory) Result
	// Exit is set by proc_exit, with Code.
	Exit bool
	Code uint32
	// Ret is a host-module function's result (HostFunc.Result); the
	// wasi_snapshot_preview1 functions return Errno instead.
	Ret uint64
	// Realloc, when set, asks the host to allocate in the guest first
	// (see Realloc); Wait and Realloc are never both set.
	Realloc *Realloc
	// Trap, when not empty, ends the guest with a trap of that message (a
	// host module's answer to a call the canonical ABI says must trap).
	Trap string
}

type SpawnSpec struct {
	// Path is the module's absolute guest path in the container.
	Path string
	// Argv is argv, argv[0] included (it need not be Path).
	Argv []string
	// Env is "KEY=value" entries.
	Env []string
	// FDs is the child's table and cwd (CloneFDs); Spawn takes it over,
	// and releases it on failure.
	FDs *FDTable
}

type Spawner interface {
	Spawn(parent *Proc, spec SpawnSpec) (*Child, uint32)
}

type Terminal struct {

	// TTY says which of fds 0, 1, 2 are the terminal.
	TTY [3]bool
	// contains filtered or unexported fields
}