Struct KernelVm 

pub struct KernelVm<F> { /* private fields */ }

Implementations

impl<F: VirtualFileSystem + 'static> KernelVm<F>

pub fn new(filesystem: F, config: KernelVmConfig) -> Self

pub fn vm_id(&self) -> &str

pub fn state(&self) -> LifecycleState

pub fn commands(&self) -> BTreeMap<String, String>

pub fn filesystem(&self) -> &PermissionedFileSystem<DeviceLayer<F>>

pub fn filesystem_mut(&mut self) -> &mut PermissionedFileSystem<DeviceLayer<F>>

pub fn user_manager(&self) -> &UserManager

pub fn environment(&self) -> &BTreeMap<String, String>

pub fn process_identity( &self, requester_driver: &str, pid: u32, ) -> KernelResult<ProcessIdentity>

pub fn user_profile(&self) -> UserManager

pub fn getuid(&self, requester_driver: &str, pid: u32) -> KernelResult<u32>

pub fn getgid(&self, requester_driver: &str, pid: u32) -> KernelResult<u32>

pub fn geteuid(&self, requester_driver: &str, pid: u32) -> KernelResult<u32>

pub fn getegid(&self, requester_driver: &str, pid: u32) -> KernelResult<u32>

pub fn getgroups( &self, requester_driver: &str, pid: u32, ) -> KernelResult<Vec<u32>>

pub fn getpwuid(&self, uid: u32) -> KernelResult<String>

pub fn getgrgid(&self, gid: u32) -> KernelResult<String>

pub fn resource_snapshot(&self) -> ResourceSnapshot

pub fn resource_limits(&self) -> &ResourceLimits

pub fn set_permissions(&mut self, permissions: Permissions)

pub fn set_loopback_exempt_ports(&mut self, ports: BTreeSet<u16>)

pub fn extend_loopback_exempt_ports( &mut self, ports: impl IntoIterator<Item = u16>, )

pub fn resolve_dns( &self, hostname: &str, policy: DnsLookupPolicy, ) -> KernelResult<DnsResolution>

pub fn resolve_dns_records( &self, hostname: &str, record_type: RecordType, policy: DnsLookupPolicy, ) -> KernelResult<DnsRecordResolution>

pub fn register_driver(&mut self, driver: CommandDriver) -> KernelResult<()>

pub fn exec( &mut self, command: &str, options: ExecOptions, ) -> KernelResult<KernelProcessHandle>

pub fn open_shell( &mut self, options: OpenShellOptions, ) -> KernelResult<OpenShellHandle>

pub fn read_file(&mut self, path: &str) -> KernelResult<Vec<u8>>

pub fn pread_file( &mut self, path: &str, offset: u64, length: usize, ) -> KernelResult<Vec<u8>>

pub fn read_file_for_process( &mut self, requester_driver: &str, pid: u32, path: &str, ) -> KernelResult<Vec<u8>>

pub fn write_file( &mut self, path: &str, content: impl Into<Vec<u8>>, ) -> KernelResult<()>

pub fn pwrite_file( &mut self, path: &str, offset: u64, content: impl Into<Vec<u8>>, ) -> KernelResult<()>

Writes content at offset within an existing file, growing (and zero-filling) it as needed. This is the positional counterpart to Self::pread_file: it lets a descriptor-based caller (the shared WASI runner over the browser wire, which has no kernel fd offsets) write a region without the lossy, non-atomic read-modify-write it would otherwise have to do client-side. Enforcement matches write_file: read-only paths are rejected and the resulting file size is charged against the resource limits before the write.

pub fn write_file_for_process( &mut self, requester_driver: &str, pid: u32, path: &str, content: impl Into<Vec<u8>>, mode: Option<u32>, ) -> KernelResult<()>

pub fn create_dir(&mut self, path: &str) -> KernelResult<()>

pub fn create_dir_for_process( &mut self, requester_driver: &str, pid: u32, path: &str, mode: Option<u32>, ) -> KernelResult<()>

pub fn mkdir(&mut self, path: &str, recursive: bool) -> KernelResult<()>

pub fn mkdir_for_process( &mut self, requester_driver: &str, pid: u32, path: &str, recursive: bool, mode: Option<u32>, ) -> KernelResult<()>

pub fn umask( &self, requester_driver: &str, pid: u32, new_mask: Option<u32>, ) -> KernelResult<u32>

pub fn exists(&self, path: &str) -> KernelResult<bool>

pub fn exists_for_process( &self, requester_driver: &str, pid: u32, path: &str, ) -> KernelResult<bool>

pub fn stat(&mut self, path: &str) -> KernelResult<VirtualStat>

pub fn stat_for_process( &mut self, requester_driver: &str, pid: u32, path: &str, ) -> KernelResult<VirtualStat>

pub fn lstat(&self, path: &str) -> KernelResult<VirtualStat>

pub fn lstat_for_process( &self, requester_driver: &str, pid: u32, path: &str, ) -> KernelResult<VirtualStat>

pub fn read_link(&self, path: &str) -> KernelResult<String>

pub fn read_link_for_process( &self, requester_driver: &str, pid: u32, path: &str, ) -> KernelResult<String>

pub fn read_dir(&mut self, path: &str) -> KernelResult<Vec<String>>

pub fn read_dir_for_process( &mut self, requester_driver: &str, pid: u32, path: &str, ) -> KernelResult<Vec<String>>

pub fn read_dir_with_types_for_process( &mut self, requester_driver: &str, pid: u32, path: &str, ) -> KernelResult<Vec<VirtualDirEntry>>

pub fn read_dir_with_types( &mut self, path: &str, ) -> KernelResult<Vec<VirtualDirEntry>>

Lists a directory with each child’s file type in one call. This is the typed counterpart to Self::read_dir: it lets a descriptor-based caller recover Dirent kinds (readdir({ withFileTypes })) without an extra lstat round-trip per entry. Reuses read_dir_internal so proc, the readdir-entry limit, and read-permission checks behave identically; the per-entry lstat is in-process (no wire hops).

pub fn read_dir_recursive( &mut self, path: &str, max_depth: Option<usize>, ) -> KernelResult<Vec<RecursiveDirEntry>>

pub fn copy_path( &mut self, from: &str, to: &str, recursive: bool, ) -> KernelResult<()>

pub fn remove_path(&mut self, path: &str, recursive: bool) -> KernelResult<()>

pub fn move_path(&mut self, from: &str, to: &str) -> KernelResult<()>

pub fn remove_file(&mut self, path: &str) -> KernelResult<()>

pub fn remove_dir(&mut self, path: &str) -> KernelResult<()>

pub fn rename(&mut self, old_path: &str, new_path: &str) -> KernelResult<()>

pub fn realpath(&self, path: &str) -> KernelResult<String>

pub fn realpath_for_process( &self, requester_driver: &str, pid: u32, path: &str, ) -> KernelResult<String>

pub fn symlink(&mut self, target: &str, link_path: &str) -> KernelResult<()>

pub fn chmod(&mut self, path: &str, mode: u32) -> KernelResult<()>

pub fn link(&mut self, old_path: &str, new_path: &str) -> KernelResult<()>

pub fn chown(&mut self, path: &str, uid: u32, gid: u32) -> KernelResult<()>

pub fn utimes( &mut self, path: &str, atime_ms: u64, mtime_ms: u64, ) -> KernelResult<()>

pub fn utimes_spec( &mut self, path: &str, atime: VirtualUtimeSpec, mtime: VirtualUtimeSpec, ) -> KernelResult<()>

pub fn lutimes( &mut self, path: &str, atime: VirtualUtimeSpec, mtime: VirtualUtimeSpec, ) -> KernelResult<()>

pub fn futimes( &mut self, requester_driver: &str, pid: u32, fd: u32, atime: VirtualUtimeSpec, mtime: VirtualUtimeSpec, ) -> KernelResult<()>

pub fn truncate(&mut self, path: &str, length: u64) -> KernelResult<()>

pub fn list_processes(&self) -> BTreeMap<u32, ProcessInfo>

pub fn zombie_timer_count(&self) -> usize

pub fn spawn_process( &mut self, command: &str, args: Vec<String>, options: SpawnOptions, ) -> KernelResult<KernelProcessHandle>

pub fn create_virtual_process( &mut self, requester_driver: &str, driver: &str, command: &str, args: Vec<String>, options: VirtualProcessOptions, ) -> KernelResult<KernelProcessHandle>

pub fn read_process_stdin( &mut self, requester_driver: &str, pid: u32, length: usize, timeout: Option<Duration>, ) -> KernelResult<Option<Vec<u8>>>

pub fn write_process_stdout( &mut self, requester_driver: &str, pid: u32, data: &[u8], ) -> KernelResult<usize>

pub fn write_process_stderr( &mut self, requester_driver: &str, pid: u32, data: &[u8], ) -> KernelResult<usize>

pub fn exit_process( &mut self, requester_driver: &str, pid: u32, exit_code: i32, ) -> KernelResult<()>

pub fn waitpid(&mut self, pid: u32) -> KernelResult<WaitPidResult>

pub fn waitpid_with_options( &mut self, requester_driver: &str, waiter_pid: u32, pid: i32, flags: WaitPidFlags, ) -> KernelResult<Option<WaitPidEventResult>>

pub fn wait_and_reap(&mut self, pid: u32) -> KernelResult<(u32, i32)>

pub fn open_pipe( &mut self, requester_driver: &str, pid: u32, ) -> KernelResult<(u32, u32)>

pub fn open_pty( &mut self, requester_driver: &str, pid: u32, ) -> KernelResult<(u32, u32, String)>

pub fn socket_create( &mut self, requester_driver: &str, pid: u32, spec: SocketSpec, ) -> KernelResult<SocketId>

pub fn set_socket_readiness_sink<S>(&mut self, sink: Option<S>)

where S: Fn(SocketReadiness) + Send + Sync + 'static,

pub fn socket_get(&self, socket_id: SocketId) -> Option<SocketRecord>

pub fn socket_records_for_pid(&self, pid: u32) -> Vec<SocketRecord>

pub fn socket_bind_inet( &mut self, requester_driver: &str, pid: u32, socket_id: SocketId, address: InetSocketAddress, ) -> KernelResult<()>

pub fn socket_bind_unix( &mut self, requester_driver: &str, pid: u32, socket_id: SocketId, path: impl Into<String>, ) -> KernelResult<()>

pub fn socket_listen( &mut self, requester_driver: &str, pid: u32, socket_id: SocketId, backlog: usize, ) -> KernelResult<()>

pub fn socket_queue_incoming_tcp_connection( &mut self, requester_driver: &str, pid: u32, listener_socket_id: SocketId, peer_address: InetSocketAddress, ) -> KernelResult<()>

pub fn socket_accept( &mut self, requester_driver: &str, pid: u32, listener_socket_id: SocketId, ) -> KernelResult<SocketId>

pub fn socket_connect_pair( &mut self, requester_driver: &str, pid: u32, socket_id: SocketId, peer_socket_id: SocketId, ) -> KernelResult<()>

pub fn socket_connect_unix( &mut self, requester_driver: &str, pid: u32, socket_id: SocketId, target_path: impl Into<String>, ) -> KernelResult<()>

pub fn socket_connect_inet_loopback( &mut self, requester_driver: &str, pid: u32, socket_id: SocketId, target_address: InetSocketAddress, ) -> KernelResult<()>

pub fn socket_send_to_inet_loopback( &mut self, requester_driver: &str, pid: u32, socket_id: SocketId, target_address: InetSocketAddress, data: &[u8], ) -> KernelResult<usize>

pub fn socket_recv_datagram( &mut self, requester_driver: &str, pid: u32, socket_id: SocketId, max_bytes: usize, ) -> KernelResult<Option<ReceivedDatagram>>

pub fn socket_set_datagram_option( &mut self, requester_driver: &str, pid: u32, socket_id: SocketId, option: DatagramSocketOption, enabled: bool, ) -> KernelResult<()>

pub fn socket_add_membership( &mut self, requester_driver: &str, pid: u32, socket_id: SocketId, membership: SocketMulticastMembership, ) -> KernelResult<()>

pub fn socket_drop_membership( &mut self, requester_driver: &str, pid: u32, socket_id: SocketId, membership: SocketMulticastMembership, ) -> KernelResult<()>

pub fn socket_set_state( &mut self, requester_driver: &str, pid: u32, socket_id: SocketId, state: SocketState, ) -> KernelResult<()>

pub fn socket_write( &mut self, requester_driver: &str, pid: u32, socket_id: SocketId, data: &[u8], ) -> KernelResult<usize>

pub fn socket_read( &mut self, requester_driver: &str, pid: u32, socket_id: SocketId, max_bytes: usize, ) -> KernelResult<Option<Vec<u8>>>

pub fn socket_shutdown( &mut self, requester_driver: &str, pid: u32, socket_id: SocketId, how: SocketShutdown, ) -> KernelResult<()>

pub fn socket_close( &mut self, requester_driver: &str, pid: u32, socket_id: SocketId, ) -> KernelResult<()>

pub fn fd_open( &mut self, requester_driver: &str, pid: u32, path: &str, flags: u32, mode: Option<u32>, ) -> KernelResult<u32>

pub fn fd_read( &mut self, requester_driver: &str, pid: u32, fd: u32, length: usize, ) -> KernelResult<Vec<u8>>

pub fn fd_read_with_timeout_result( &mut self, requester_driver: &str, pid: u32, fd: u32, length: usize, timeout: Option<Duration>, ) -> KernelResult<Option<Vec<u8>>>

pub fn fd_write( &mut self, requester_driver: &str, pid: u32, fd: u32, data: &[u8], ) -> KernelResult<usize>

pub fn poll_fds( &self, requester_driver: &str, pid: u32, fds: Vec<PollFd>, timeout_ms: i32, ) -> KernelResult<PollResult>

pub fn poll_wait_handle(&self) -> PollWaitHandle

A cloneable, Send handle for waiting on kernel poll-state changes off the kernel owner’s thread. Pair with a zero-timeout poll_fds / fd_read_with_timeout_result re-check on the owning thread.

pub fn poll_targets( &self, requester_driver: &str, pid: u32, targets: Vec<PollTargetEntry>, timeout_ms: i32, ) -> KernelResult<PollTargetResult>

pub fn fd_seek( &mut self, requester_driver: &str, pid: u32, fd: u32, offset: i64, whence: u8, ) -> KernelResult<u64>

pub fn fd_pread( &mut self, requester_driver: &str, pid: u32, fd: u32, length: usize, offset: u64, ) -> KernelResult<Vec<u8>>

pub fn fd_pwrite( &mut self, requester_driver: &str, pid: u32, fd: u32, data: &[u8], offset: u64, ) -> KernelResult<usize>

pub fn fd_dup( &mut self, requester_driver: &str, pid: u32, fd: u32, ) -> KernelResult<u32>

pub fn fd_dup2( &mut self, requester_driver: &str, pid: u32, old_fd: u32, new_fd: u32, ) -> KernelResult<()>

pub fn fd_close( &mut self, requester_driver: &str, pid: u32, fd: u32, ) -> KernelResult<()>

pub fn fd_fcntl( &mut self, requester_driver: &str, pid: u32, fd: u32, command: u32, arg: u32, ) -> KernelResult<u32>

pub fn fd_flock( &self, requester_driver: &str, pid: u32, fd: u32, operation: u32, ) -> KernelResult<()>

pub fn fd_stat( &self, requester_driver: &str, pid: u32, fd: u32, ) -> KernelResult<FdStat>

pub fn fd_path( &self, requester_driver: &str, pid: u32, fd: u32, ) -> KernelResult<String>

pub fn isatty( &self, requester_driver: &str, pid: u32, fd: u32, ) -> KernelResult<bool>

pub fn pty_window_size( &self, requester_driver: &str, pid: u32, fd: u32, ) -> KernelResult<PtyWindowSize>

pub fn pty_set_discipline( &self, requester_driver: &str, pid: u32, fd: u32, config: LineDisciplineConfig, ) -> KernelResult<()>

pub fn pty_set_raw_mode( &self, requester_driver: &str, pid: u32, fd: u32, enabled: bool, ) -> KernelResult<Option<u64>>

Toggle PTY raw mode and, when the caller belongs to the terminal’s foreground process group, create a generation-scoped recovery lease. The lease can be released during process cleanup without overwriting a newer terminal mutation from another process.

pub fn pty_release_raw_mode( &self, requester_driver: &str, descriptor_owner_pid: u32, fd: u32, raw_mode_owner_pid: u32, generation: u64, ) -> KernelResult<bool>

Release a raw-mode recovery lease through any descriptor for the same PTY. fd normally belongs to the terminal owner because the exiting child may already have closed its own descriptor zero.

pub fn pty_set_foreground_pgid( &self, requester_driver: &str, pid: u32, fd: u32, pgid: u32, ) -> KernelResult<()>

pub fn tcgetattr( &self, requester_driver: &str, pid: u32, fd: u32, ) -> KernelResult<Termios>

pub fn tcsetattr( &self, requester_driver: &str, pid: u32, fd: u32, termios: PartialTermios, ) -> KernelResult<()>

pub fn tcgetpgrp( &self, requester_driver: &str, pid: u32, fd: u32, ) -> KernelResult<u32>

pub fn pty_resize( &self, requester_driver: &str, pid: u32, fd: u32, cols: u16, rows: u16, ) -> KernelResult<()>

pub fn signal_process( &self, requester_driver: &str, pid: i32, signal: i32, ) -> KernelResult<()>

pub fn kill_process( &self, requester_driver: &str, pid: u32, signal: i32, ) -> KernelResult<()>

pub fn setpgid( &self, requester_driver: &str, pid: u32, pgid: u32, ) -> KernelResult<()>

pub fn getpgid(&self, requester_driver: &str, pid: u32) -> KernelResult<u32>

pub fn getpid(&self, requester_driver: &str, pid: u32) -> KernelResult<u32>

pub fn sigprocmask( &self, requester_driver: &str, pid: u32, how: SigmaskHow, set: SignalSet, ) -> KernelResult<SignalSet>

pub fn sigpending( &self, requester_driver: &str, pid: u32, ) -> KernelResult<SignalSet>

pub fn getppid(&self, requester_driver: &str, pid: u32) -> KernelResult<u32>

pub fn setsid(&self, requester_driver: &str, pid: u32) -> KernelResult<u32>

pub fn getsid(&self, requester_driver: &str, pid: u32) -> KernelResult<u32>

pub fn dev_fd_read_dir( &self, requester_driver: &str, pid: u32, ) -> KernelResult<Vec<String>>

pub fn dev_fd_stat( &mut self, requester_driver: &str, pid: u32, fd: u32, ) -> KernelResult<VirtualStat>

pub fn dispose(&mut self) -> KernelResult<()>

impl KernelVm<MountTable>

pub fn mount_filesystem( &mut self, path: &str, filesystem: impl VirtualFileSystem + 'static, options: MountOptions, ) -> KernelResult<()>

pub fn mount_boxed_filesystem( &mut self, path: &str, filesystem: Box<dyn MountedFileSystem>, options: MountOptions, ) -> KernelResult<()>

pub fn unmount_filesystem(&mut self, path: &str) -> KernelResult<()>

pub fn mounted_filesystems(&self) -> Vec<MountEntry>

pub fn root_filesystem_mut(&mut self) -> Option<&mut RootFileSystem>

pub fn snapshot_root_filesystem( &mut self, ) -> KernelResult<RootFilesystemSnapshot>

Trait Implementations

impl<F> Drop for KernelVm<F>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.