mirror of
https://github.com/marcoallegretti/WEFT_OS.git
synced 2026-11-22 08:13:59 +00:00
Merge fix/runtime-resource-limits: bound component memory and app messages in the runtime (#27)
This commit is contained in:
commit
0c527dfada
9 changed files with 425 additions and 66 deletions
|
|
@ -185,6 +185,8 @@ const SYSTEMD_SCOPE_ARGS: &[&str] = &[
|
||||||
"CPUQuota=200%",
|
"CPUQuota=200%",
|
||||||
"-p",
|
"-p",
|
||||||
"MemoryMax=512M",
|
"MemoryMax=512M",
|
||||||
|
"-p",
|
||||||
|
"TasksMax=512",
|
||||||
];
|
];
|
||||||
|
|
||||||
fn systemd_cgroup_available() -> bool {
|
fn systemd_cgroup_available() -> bool {
|
||||||
|
|
|
||||||
226
crates/weft-runtime/src/ipc.rs
Normal file
226
crates/weft-runtime/src/ipc.rs
Normal file
|
|
@ -0,0 +1,226 @@
|
||||||
|
//! The component's connection to its session's IPC relay in weft-appd.
|
||||||
|
//!
|
||||||
|
//! Messages are single lines. A message is at most `MAX_MESSAGE` bytes, the
|
||||||
|
//! limit weft-appd applies to app messages, and cannot contain a line break,
|
||||||
|
//! which would split it into several messages. Received data is buffered
|
||||||
|
//! up to one message; a peer that sends a longer line, or closes the
|
||||||
|
//! connection, ends it for good.
|
||||||
|
|
||||||
|
use std::io::{Read, Write};
|
||||||
|
use std::os::unix::net::UnixStream;
|
||||||
|
|
||||||
|
/// The longest message in either direction, in bytes.
|
||||||
|
pub const MAX_MESSAGE: usize = 64 * 1024;
|
||||||
|
/// How long one write of a message may block before the connection is
|
||||||
|
/// given up.
|
||||||
|
const SEND_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
|
||||||
|
|
||||||
|
/// Checks a message the component wants to send.
|
||||||
|
pub fn check_payload(payload: &str) -> Result<(), String> {
|
||||||
|
if payload.len() > MAX_MESSAGE {
|
||||||
|
return Err(format!("message exceeds {MAX_MESSAGE} bytes"));
|
||||||
|
}
|
||||||
|
if payload.contains(['\n', '\r']) {
|
||||||
|
return Err("message contains a line break".to_owned());
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub struct IpcState {
|
||||||
|
socket: UnixStream,
|
||||||
|
recv_buf: Vec<u8>,
|
||||||
|
/// Why the connection ended, once it has.
|
||||||
|
closed: Option<&'static str>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl IpcState {
|
||||||
|
pub fn connect(path: &str) -> Option<Self> {
|
||||||
|
let socket = UnixStream::connect(path).ok()?;
|
||||||
|
Self::new(socket)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn new(socket: UnixStream) -> Option<Self> {
|
||||||
|
socket.set_nonblocking(true).ok()?;
|
||||||
|
Some(Self {
|
||||||
|
socket,
|
||||||
|
recv_buf: Vec::new(),
|
||||||
|
closed: None,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn send(&mut self, payload: &str) -> Result<(), String> {
|
||||||
|
check_payload(payload)?;
|
||||||
|
if let Some(reason) = self.closed {
|
||||||
|
return Err(format!("IPC connection {reason}"));
|
||||||
|
}
|
||||||
|
let mut line = payload.to_owned();
|
||||||
|
line.push('\n');
|
||||||
|
let result = self
|
||||||
|
.socket
|
||||||
|
.set_nonblocking(false)
|
||||||
|
.and_then(|()| self.socket.set_write_timeout(Some(SEND_TIMEOUT)))
|
||||||
|
.and_then(|()| self.socket.write_all(line.as_bytes()));
|
||||||
|
let restored = self.socket.set_nonblocking(true);
|
||||||
|
match result.and(restored) {
|
||||||
|
Ok(()) => Ok(()),
|
||||||
|
// Part of the line may have been written; anything sent after it
|
||||||
|
// would join it, so the connection ends.
|
||||||
|
Err(e) => {
|
||||||
|
self.close("failed");
|
||||||
|
Err(e.to_string())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The next complete message, if one has arrived.
|
||||||
|
pub fn recv(&mut self) -> Option<String> {
|
||||||
|
if let Some(message) = self.take_line() {
|
||||||
|
return Some(message);
|
||||||
|
}
|
||||||
|
if self.closed.is_some() {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
let mut chunk = [0u8; 4096];
|
||||||
|
loop {
|
||||||
|
match self.socket.read(&mut chunk) {
|
||||||
|
Ok(0) => {
|
||||||
|
self.close("closed by weft-appd");
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
Ok(n) => {
|
||||||
|
self.recv_buf.extend_from_slice(&chunk[..n]);
|
||||||
|
if self.recv_buf.contains(&b'\n') {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if self.recv_buf.len() > MAX_MESSAGE + 2 {
|
||||||
|
self.overlong();
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => break,
|
||||||
|
Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
|
||||||
|
Err(_) => {
|
||||||
|
self.close("failed");
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
self.take_line()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Ends the connection for both sides: weft-appd sees it close and
|
||||||
|
/// ends the session, as it does when the component closes it.
|
||||||
|
fn close(&mut self, reason: &'static str) {
|
||||||
|
tracing::warn!(reason, "IPC connection ended");
|
||||||
|
self.closed = Some(reason);
|
||||||
|
let _ = self.socket.shutdown(std::net::Shutdown::Both);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn overlong(&mut self) {
|
||||||
|
self.close("ended by a message over the size limit");
|
||||||
|
self.recv_buf.clear();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Removes the first complete line from the buffer. A line that is not
|
||||||
|
/// UTF-8 is dropped; one longer than a message ends the connection.
|
||||||
|
fn take_line(&mut self) -> Option<String> {
|
||||||
|
loop {
|
||||||
|
let pos = self.recv_buf.iter().position(|&b| b == b'\n')?;
|
||||||
|
let raw: Vec<u8> = self.recv_buf.drain(..=pos).collect();
|
||||||
|
let text = raw.strip_suffix(b"\n").unwrap_or(&raw);
|
||||||
|
let text = text.strip_suffix(b"\r").unwrap_or(text);
|
||||||
|
if text.len() > MAX_MESSAGE {
|
||||||
|
self.overlong();
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
match String::from_utf8(text.to_vec()) {
|
||||||
|
Ok(message) => return Some(message),
|
||||||
|
Err(_) => tracing::warn!("IPC message that is not UTF-8 dropped"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
fn pair() -> (IpcState, UnixStream) {
|
||||||
|
let (ours, theirs) = UnixStream::pair().unwrap();
|
||||||
|
(IpcState::new(ours).unwrap(), theirs)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn payloads_that_would_break_framing_are_refused() {
|
||||||
|
assert!(check_payload("ok").is_ok());
|
||||||
|
assert!(check_payload("two\nmessages").is_err());
|
||||||
|
assert!(check_payload("carriage\rreturn").is_err());
|
||||||
|
assert!(check_payload(&"x".repeat(MAX_MESSAGE)).is_ok());
|
||||||
|
assert!(check_payload(&"x".repeat(MAX_MESSAGE + 1)).is_err());
|
||||||
|
let (mut ipc, _peer) = pair();
|
||||||
|
assert!(ipc.send("a\nb").is_err());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn messages_arrive_one_at_a_time() {
|
||||||
|
let (mut ipc, mut peer) = pair();
|
||||||
|
assert_eq!(ipc.recv(), None);
|
||||||
|
peer.write_all(b"first\nsecond\r\npart").unwrap();
|
||||||
|
assert_eq!(ipc.recv().as_deref(), Some("first"));
|
||||||
|
assert_eq!(ipc.recv().as_deref(), Some("second"));
|
||||||
|
assert_eq!(ipc.recv(), None);
|
||||||
|
peer.write_all(b"ial\n").unwrap();
|
||||||
|
assert_eq!(ipc.recv().as_deref(), Some("partial"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn an_overlong_line_ends_the_connection_without_unbounded_buffering() {
|
||||||
|
let (mut ipc, mut peer) = pair();
|
||||||
|
peer.write_all(&vec![b'x'; MAX_MESSAGE + 4097]).unwrap();
|
||||||
|
while ipc.closed.is_none() {
|
||||||
|
assert_eq!(ipc.recv(), None);
|
||||||
|
}
|
||||||
|
assert!(ipc.recv_buf.len() <= MAX_MESSAGE + 4096);
|
||||||
|
assert!(ipc.send("after").is_err());
|
||||||
|
// The peer sees the connection end.
|
||||||
|
let mut rest = Vec::new();
|
||||||
|
assert_eq!(peer.read_to_end(&mut rest).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn a_message_at_the_limit_arrives_and_one_over_it_ends_the_connection() {
|
||||||
|
let (mut ipc, mut peer) = pair();
|
||||||
|
let mut at_limit = vec![b'x'; MAX_MESSAGE];
|
||||||
|
at_limit.push(b'\n');
|
||||||
|
peer.write_all(&at_limit).unwrap();
|
||||||
|
let mut received = None;
|
||||||
|
while received.is_none() {
|
||||||
|
received = ipc.recv();
|
||||||
|
}
|
||||||
|
assert_eq!(received.map(|m| m.len()), Some(MAX_MESSAGE));
|
||||||
|
// One byte over, with its newline in the same read.
|
||||||
|
let mut over = vec![b'x'; MAX_MESSAGE + 1];
|
||||||
|
over.extend_from_slice(b"\nnext\n");
|
||||||
|
peer.write_all(&over).unwrap();
|
||||||
|
while ipc.closed.is_none() {
|
||||||
|
assert_eq!(ipc.recv(), None);
|
||||||
|
}
|
||||||
|
assert_eq!(ipc.recv(), None);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn a_line_that_is_not_utf8_is_dropped() {
|
||||||
|
let (mut ipc, mut peer) = pair();
|
||||||
|
peer.write_all(b"\xff\xfe\nafter\n").unwrap();
|
||||||
|
assert_eq!(ipc.recv().as_deref(), Some("after"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn a_closed_connection_is_reported_to_senders() {
|
||||||
|
let (mut ipc, peer) = pair();
|
||||||
|
drop(peer);
|
||||||
|
assert_eq!(ipc.recv(), None);
|
||||||
|
let error = ipc.send("hello").unwrap_err();
|
||||||
|
assert!(error.contains("closed"), "{error}");
|
||||||
|
}
|
||||||
|
}
|
||||||
127
crates/weft-runtime/src/limits.rs
Normal file
127
crates/weft-runtime/src/limits.rs
Normal file
|
|
@ -0,0 +1,127 @@
|
||||||
|
//! The memory and table limits of a component's store.
|
||||||
|
//!
|
||||||
|
//! The limit on linear memory covers all of a component's memories
|
||||||
|
//! together: a component made of several core modules cannot multiply it
|
||||||
|
//! by declaring more memories. A memory or table that would grow past its
|
||||||
|
//! limit does not grow, and the component sees an allocation failure.
|
||||||
|
|
||||||
|
/// The most table elements across all of a component's tables.
|
||||||
|
const MAX_TABLE_ELEMENTS: usize = 1_000_000;
|
||||||
|
/// The most core instances, memories and tables in one store.
|
||||||
|
const MAX_INSTANCES: usize = 1_000;
|
||||||
|
const MAX_MEMORIES: usize = 100;
|
||||||
|
const MAX_TABLES: usize = 1_000;
|
||||||
|
|
||||||
|
pub struct Limits {
|
||||||
|
max_memory: usize,
|
||||||
|
memory: usize,
|
||||||
|
table_elements: usize,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Limits {
|
||||||
|
/// Limits a store's linear memory to `max_memory` bytes in total.
|
||||||
|
pub fn new(max_memory: usize) -> Self {
|
||||||
|
Self {
|
||||||
|
max_memory,
|
||||||
|
memory: 0,
|
||||||
|
table_elements: 0,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Accounts a growth from `current` to `desired` against `used` of `max`.
|
||||||
|
/// A growth past the memory's or table's own `maximum` fails anyway, so it
|
||||||
|
/// is refused without being counted.
|
||||||
|
fn grow(
|
||||||
|
used: &mut usize,
|
||||||
|
max: usize,
|
||||||
|
current: usize,
|
||||||
|
desired: usize,
|
||||||
|
maximum: Option<usize>,
|
||||||
|
) -> bool {
|
||||||
|
if maximum.is_some_and(|m| desired > m) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
let added = desired.saturating_sub(current);
|
||||||
|
match used.checked_add(added) {
|
||||||
|
Some(total) if total <= max => {
|
||||||
|
*used = total;
|
||||||
|
true
|
||||||
|
}
|
||||||
|
_ => false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl wasmtime::ResourceLimiter for Limits {
|
||||||
|
fn memory_growing(
|
||||||
|
&mut self,
|
||||||
|
current: usize,
|
||||||
|
desired: usize,
|
||||||
|
maximum: Option<usize>,
|
||||||
|
) -> anyhow::Result<bool> {
|
||||||
|
Ok(grow(
|
||||||
|
&mut self.memory,
|
||||||
|
self.max_memory,
|
||||||
|
current,
|
||||||
|
desired,
|
||||||
|
maximum,
|
||||||
|
))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn table_growing(
|
||||||
|
&mut self,
|
||||||
|
current: usize,
|
||||||
|
desired: usize,
|
||||||
|
maximum: Option<usize>,
|
||||||
|
) -> anyhow::Result<bool> {
|
||||||
|
Ok(grow(
|
||||||
|
&mut self.table_elements,
|
||||||
|
MAX_TABLE_ELEMENTS,
|
||||||
|
current,
|
||||||
|
desired,
|
||||||
|
maximum,
|
||||||
|
))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn instances(&self) -> usize {
|
||||||
|
MAX_INSTANCES
|
||||||
|
}
|
||||||
|
|
||||||
|
fn memories(&self) -> usize {
|
||||||
|
MAX_MEMORIES
|
||||||
|
}
|
||||||
|
|
||||||
|
fn tables(&self) -> usize {
|
||||||
|
MAX_TABLES
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
use wasmtime::ResourceLimiter;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn the_limit_covers_all_memories_together() {
|
||||||
|
let mut limits = Limits::new(100);
|
||||||
|
assert!(limits.memory_growing(0, 60, None).unwrap());
|
||||||
|
// A second memory gets only what the first left.
|
||||||
|
assert!(!limits.memory_growing(0, 60, None).unwrap());
|
||||||
|
assert!(limits.memory_growing(0, 40, None).unwrap());
|
||||||
|
// Growing the first one further no longer fits.
|
||||||
|
assert!(!limits.memory_growing(60, 61, None).unwrap());
|
||||||
|
assert_eq!(limits.memory, 100);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn a_refused_growth_is_not_counted() {
|
||||||
|
let mut limits = Limits::new(100);
|
||||||
|
assert!(!limits.memory_growing(0, 101, None).unwrap());
|
||||||
|
assert!(limits.memory_growing(0, 100, None).unwrap());
|
||||||
|
assert!(!limits.memory_growing(0, usize::MAX, None).unwrap());
|
||||||
|
// Past a memory's own maximum: refused and not counted.
|
||||||
|
let mut limits = Limits::new(100);
|
||||||
|
assert!(!limits.memory_growing(0, 50, Some(40)).unwrap());
|
||||||
|
assert!(limits.memory_growing(0, 100, None).unwrap());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -3,6 +3,13 @@ use std::path::PathBuf;
|
||||||
use anyhow::Context;
|
use anyhow::Context;
|
||||||
|
|
||||||
mod grants;
|
mod grants;
|
||||||
|
#[cfg(feature = "wasmtime-runtime")]
|
||||||
|
mod ipc;
|
||||||
|
#[cfg(feature = "wasmtime-runtime")]
|
||||||
|
mod limits;
|
||||||
|
|
||||||
|
/// The default limit on a component's linear memory, in MiB.
|
||||||
|
const DEFAULT_MAX_MEMORY_MIB: usize = 256;
|
||||||
|
|
||||||
use grants::{Grants, Preopen};
|
use grants::{Grants, Preopen};
|
||||||
|
|
||||||
|
|
@ -18,7 +25,8 @@ fn main() -> anyhow::Result<()> {
|
||||||
if args.len() < 3 {
|
if args.len() < 3 {
|
||||||
anyhow::bail!(
|
anyhow::bail!(
|
||||||
"usage: weft-runtime <app_id> <session_id> --module PATH \
|
"usage: weft-runtime <app_id> <session_id> --module PATH \
|
||||||
[--preopen HOST::GUEST::ro|rw]... [--grant CAPABILITY]... [--ipc-socket PATH]"
|
[--preopen HOST::GUEST::ro|rw]... [--grant CAPABILITY]... [--ipc-socket PATH] \
|
||||||
|
[--max-memory-mib N]"
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
let app_id = &args[1];
|
let app_id = &args[1];
|
||||||
|
|
@ -30,6 +38,7 @@ fn main() -> anyhow::Result<()> {
|
||||||
let mut grants = Grants::default();
|
let mut grants = Grants::default();
|
||||||
let mut ipc_socket: Option<String> = None;
|
let mut ipc_socket: Option<String> = None;
|
||||||
let mut module: Option<PathBuf> = None;
|
let mut module: Option<PathBuf> = None;
|
||||||
|
let mut max_memory_mib = DEFAULT_MAX_MEMORY_MIB;
|
||||||
|
|
||||||
let mut i = 3usize;
|
let mut i = 3usize;
|
||||||
while i < args.len() {
|
while i < args.len() {
|
||||||
|
|
@ -49,6 +58,17 @@ fn main() -> anyhow::Result<()> {
|
||||||
args.get(i).context("--module requires an argument")?,
|
args.get(i).context("--module requires an argument")?,
|
||||||
));
|
));
|
||||||
}
|
}
|
||||||
|
"--max-memory-mib" => {
|
||||||
|
i += 1;
|
||||||
|
let value = args
|
||||||
|
.get(i)
|
||||||
|
.context("--max-memory-mib requires an argument")?;
|
||||||
|
max_memory_mib = value
|
||||||
|
.parse::<usize>()
|
||||||
|
.ok()
|
||||||
|
.filter(|&mib| mib > 0 && mib <= 1 << 20)
|
||||||
|
.with_context(|| format!("invalid --max-memory-mib: {value}"))?;
|
||||||
|
}
|
||||||
"--ipc-socket" => {
|
"--ipc-socket" => {
|
||||||
i += 1;
|
i += 1;
|
||||||
ipc_socket = Some(
|
ipc_socket = Some(
|
||||||
|
|
@ -72,7 +92,13 @@ fn main() -> anyhow::Result<()> {
|
||||||
let wasm_path = module.context("--module is required")?;
|
let wasm_path = module.context("--module is required")?;
|
||||||
|
|
||||||
tracing::info!(session_id, %app_id, wasm = %wasm_path.display(), "executing module");
|
tracing::info!(session_id, %app_id, wasm = %wasm_path.display(), "executing module");
|
||||||
run_module(&wasm_path, &preopen, grants, ipc_socket.as_deref())?;
|
run_module(
|
||||||
|
&wasm_path,
|
||||||
|
&preopen,
|
||||||
|
grants,
|
||||||
|
ipc_socket.as_deref(),
|
||||||
|
max_memory_mib << 20,
|
||||||
|
)?;
|
||||||
|
|
||||||
tracing::info!(session_id, %app_id, "exiting");
|
tracing::info!(session_id, %app_id, "exiting");
|
||||||
Ok(())
|
Ok(())
|
||||||
|
|
@ -94,6 +120,7 @@ fn run_module(
|
||||||
_preopen: &[Preopen],
|
_preopen: &[Preopen],
|
||||||
_grants: Grants,
|
_grants: Grants,
|
||||||
_ipc_socket: Option<&str>,
|
_ipc_socket: Option<&str>,
|
||||||
|
_max_memory: usize,
|
||||||
) -> anyhow::Result<()> {
|
) -> anyhow::Result<()> {
|
||||||
anyhow::bail!(
|
anyhow::bail!(
|
||||||
"weft-runtime was built without the wasmtime-runtime feature and cannot execute components"
|
"weft-runtime was built without the wasmtime-runtime feature and cannot execute components"
|
||||||
|
|
@ -106,6 +133,7 @@ fn run_module(
|
||||||
preopen: &[Preopen],
|
preopen: &[Preopen],
|
||||||
grants: Grants,
|
grants: Grants,
|
||||||
ipc_socket: Option<&str>,
|
ipc_socket: Option<&str>,
|
||||||
|
max_memory: usize,
|
||||||
) -> anyhow::Result<()> {
|
) -> anyhow::Result<()> {
|
||||||
use std::sync::{Arc, Mutex};
|
use std::sync::{Arc, Mutex};
|
||||||
use wasmtime::{
|
use wasmtime::{
|
||||||
|
|
@ -118,63 +146,10 @@ fn run_module(
|
||||||
};
|
};
|
||||||
use weft_ipc_types::capability::Access;
|
use weft_ipc_types::capability::Access;
|
||||||
|
|
||||||
struct IpcState {
|
|
||||||
socket: std::os::unix::net::UnixStream,
|
|
||||||
recv_buf: Vec<u8>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl IpcState {
|
|
||||||
fn connect(path: &str) -> Option<Self> {
|
|
||||||
let socket = std::os::unix::net::UnixStream::connect(path).ok()?;
|
|
||||||
socket.set_nonblocking(true).ok()?;
|
|
||||||
Some(Self {
|
|
||||||
socket,
|
|
||||||
recv_buf: Vec::new(),
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
fn send(&mut self, payload: &str) -> Result<(), String> {
|
|
||||||
use std::io::Write;
|
|
||||||
let _ = self.socket.set_nonblocking(false);
|
|
||||||
let mut line = payload.to_owned();
|
|
||||||
line.push('\n');
|
|
||||||
let result = self
|
|
||||||
.socket
|
|
||||||
.write_all(line.as_bytes())
|
|
||||||
.map_err(|e| e.to_string());
|
|
||||||
let _ = self.socket.set_nonblocking(true);
|
|
||||||
result
|
|
||||||
}
|
|
||||||
|
|
||||||
fn recv(&mut self) -> Option<String> {
|
|
||||||
use std::io::Read;
|
|
||||||
let mut chunk = [0u8; 4096];
|
|
||||||
loop {
|
|
||||||
match self.socket.read(&mut chunk) {
|
|
||||||
Ok(0) => break,
|
|
||||||
Ok(n) => self.recv_buf.extend_from_slice(&chunk[..n]),
|
|
||||||
Err(e)
|
|
||||||
if e.kind() == std::io::ErrorKind::WouldBlock
|
|
||||||
|| e.kind() == std::io::ErrorKind::TimedOut =>
|
|
||||||
{
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
Err(_) => break,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if let Some(pos) = self.recv_buf.iter().position(|&b| b == b'\n') {
|
|
||||||
let raw: Vec<u8> = self.recv_buf.drain(..=pos).collect();
|
|
||||||
return String::from_utf8(raw)
|
|
||||||
.ok()
|
|
||||||
.map(|s| s.trim_end_matches('\n').trim_end_matches('\r').to_owned());
|
|
||||||
}
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
struct State {
|
struct State {
|
||||||
ctx: WasiCtx,
|
ctx: WasiCtx,
|
||||||
table: ResourceTable,
|
table: ResourceTable,
|
||||||
|
limits: limits::Limits,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl IoView for State {
|
impl IoView for State {
|
||||||
|
|
@ -199,7 +174,7 @@ fn run_module(
|
||||||
let grants = Arc::new(grants);
|
let grants = Arc::new(grants);
|
||||||
let mut linker: Linker<State> = Linker::new(&engine);
|
let mut linker: Linker<State> = Linker::new(&engine);
|
||||||
add_to_linker_sync(&mut linker).context("add WASI to linker")?;
|
add_to_linker_sync(&mut linker).context("add WASI to linker")?;
|
||||||
let ipc_state: Arc<Mutex<Option<IpcState>>> = Arc::new(Mutex::new(None));
|
let ipc_state: Arc<Mutex<Option<ipc::IpcState>>> = Arc::new(Mutex::new(None));
|
||||||
|
|
||||||
{
|
{
|
||||||
let ipc_send = Arc::clone(&ipc_state);
|
let ipc_send = Arc::clone(&ipc_state);
|
||||||
|
|
@ -223,6 +198,9 @@ fn run_module(
|
||||||
move |_: wasmtime::StoreContextMut<'_, State>,
|
move |_: wasmtime::StoreContextMut<'_, State>,
|
||||||
(payload,): (String,)|
|
(payload,): (String,)|
|
||||||
-> wasmtime::Result<(Result<(), String>,)> {
|
-> wasmtime::Result<(Result<(), String>,)> {
|
||||||
|
if let Err(e) = ipc::check_payload(&payload) {
|
||||||
|
return Ok((Err(e),));
|
||||||
|
}
|
||||||
let mut guard = ipc_send.lock().unwrap_or_else(|p| p.into_inner());
|
let mut guard = ipc_send.lock().unwrap_or_else(|p| p.into_inner());
|
||||||
match guard.as_mut() {
|
match guard.as_mut() {
|
||||||
Some(ipc) => Ok((ipc.send(&payload),)),
|
Some(ipc) => Ok((ipc.send(&payload),)),
|
||||||
|
|
@ -316,7 +294,7 @@ fn run_module(
|
||||||
|
|
||||||
if let Some(socket_path) = ipc_socket {
|
if let Some(socket_path) = ipc_socket {
|
||||||
ctx_builder.env("WEFT_IPC_SOCKET", socket_path);
|
ctx_builder.env("WEFT_IPC_SOCKET", socket_path);
|
||||||
if let Some(ipc) = IpcState::connect(socket_path) {
|
if let Some(ipc) = ipc::IpcState::connect(socket_path) {
|
||||||
*ipc_state.lock().unwrap_or_else(|p| p.into_inner()) = Some(ipc);
|
*ipc_state.lock().unwrap_or_else(|p| p.into_inner()) = Some(ipc);
|
||||||
} else {
|
} else {
|
||||||
tracing::warn!("weft:app/ipc: could not connect to IPC socket {socket_path}");
|
tracing::warn!("weft:app/ipc: could not connect to IPC socket {socket_path}");
|
||||||
|
|
@ -339,8 +317,10 @@ fn run_module(
|
||||||
State {
|
State {
|
||||||
ctx,
|
ctx,
|
||||||
table: ResourceTable::new(),
|
table: ResourceTable::new(),
|
||||||
|
limits: limits::Limits::new(max_memory),
|
||||||
},
|
},
|
||||||
);
|
);
|
||||||
|
store.limiter(|state| &mut state.limits);
|
||||||
|
|
||||||
let command =
|
let command =
|
||||||
Command::instantiate(&mut store, &component, &linker).context("instantiate component")?;
|
Command::instantiate(&mut store, &component, &linker).context("instantiate component")?;
|
||||||
|
|
@ -635,6 +615,7 @@ mod tests {
|
||||||
&[],
|
&[],
|
||||||
Grants::default(),
|
Grants::default(),
|
||||||
None,
|
None,
|
||||||
|
DEFAULT_MAX_MEMORY_MIB << 20,
|
||||||
)
|
)
|
||||||
.expect_err("a build without wasmtime-runtime must not report success");
|
.expect_err("a build without wasmtime-runtime must not report success");
|
||||||
assert!(err.to_string().contains("wasmtime-runtime"));
|
assert!(err.to_string().contains("wasmtime-runtime"));
|
||||||
|
|
|
||||||
|
|
@ -46,7 +46,7 @@ systemd
|
||||||
├── weft-servo-shell (user, after compositor)
|
├── weft-servo-shell (user, after compositor)
|
||||||
└── weft-appd (user, after compositor + servo-shell)
|
└── weft-appd (user, after compositor + servo-shell)
|
||||||
└── per-session:
|
└── per-session:
|
||||||
├── weft-runtime <app_id> <session_id> --ipc-socket <path> --module <path> [--preopen HOST::GUEST::ro|rw]... [--grant CAP]...
|
├── weft-runtime <app_id> <session_id> --ipc-socket <path> --module <path> [--preopen HOST::GUEST::ro|rw]... [--grant CAP]... [--max-memory-mib N]
|
||||||
├── weft-app-shell <app_id> <session_id> --ui <path>
|
├── weft-app-shell <app_id> <session_id> --ui <path>
|
||||||
└── weft-file-portal <socket> [--allow ...] [--allow-read ...]
|
└── weft-file-portal <socket> [--allow ...] [--allow-read ...]
|
||||||
```
|
```
|
||||||
|
|
|
||||||
|
|
@ -14,7 +14,7 @@ The approval is recorded per user, in `$XDG_DATA_HOME/weft/approvals/<id>`; weft
|
||||||
|
|
||||||
## Process Isolation
|
## Process Isolation
|
||||||
|
|
||||||
Each app session runs as a separate OS process (`weft-runtime`). When systemd is available, the process is wrapped in a systemd scope (`weft-apps.slice`) with `CPUQuota=200%` and `MemoryMax=512M`.
|
Each app session runs as a separate OS process (`weft-runtime`). When systemd is available, the process is wrapped in a systemd scope (`weft-apps.slice`) with `CPUQuota=200%`, `MemoryMax=512M` and `TasksMax=512` (threads included; the runtime runs a few per CPU). Independently of systemd, the runtime limits the component's linear memory to 256 MiB in total, across all its memories (`--max-memory-mib` changes it), and bounds its tables, memories and core instances: a memory or table that would grow past its limit does not grow, and the component sees an allocation failure. App messages over `weft:app/ipc` are single lines of at most 64 KiB, the limit weft-appd applies; a component's message that is longer or contains a line break is refused, a longer line from weft-appd, or a failed send, or a write that blocks for 10 seconds, ends the connection for both sides, so weft-appd ends the session as it does when the component closes the connection. CPU time within the quota is not limited per component.
|
||||||
|
|
||||||
## Filesystem Isolation
|
## Filesystem Isolation
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -1,6 +1,6 @@
|
||||||
//! Test component that calls every grant-controlled operation once and
|
//! Test component that calls every grant-controlled operation once, and
|
||||||
//! prints one `PROBE <name> ok <detail>` or `PROBE <name> err <message>`
|
//! probes the runtime's memory and message limits, then prints one
|
||||||
//! line for each.
|
//! `PROBE <name> ok <detail>` or `PROBE <name> err <message>` line for each.
|
||||||
//!
|
//!
|
||||||
//! Fetch targets are read from `/probe/targets.txt` (`<name> <url>` per
|
//! Fetch targets are read from `/probe/targets.txt` (`<name> <url>` per
|
||||||
//! line), a directory the harness preopens read-only next to the grants
|
//! line), a directory the harness preopens read-only next to the grants
|
||||||
|
|
@ -13,7 +13,10 @@ wit_bindgen::generate!({
|
||||||
generate_all,
|
generate_all,
|
||||||
});
|
});
|
||||||
|
|
||||||
use weft::app::{clipboard, fetch, notifications, notify};
|
use weft::app::{clipboard, fetch, ipc, notifications, notify};
|
||||||
|
|
||||||
|
/// An allocation larger than the runtime's default memory limit.
|
||||||
|
const MEMORY_PROBE: usize = 300 << 20;
|
||||||
|
|
||||||
fn report<T: std::fmt::Debug, E: std::fmt::Display>(name: &str, result: Result<T, E>) {
|
fn report<T: std::fmt::Debug, E: std::fmt::Display>(name: &str, result: Result<T, E>) {
|
||||||
match result {
|
match result {
|
||||||
|
|
@ -49,6 +52,14 @@ fn main() {
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
let mut big: Vec<u8> = Vec::new();
|
||||||
|
report(
|
||||||
|
"memory-grow",
|
||||||
|
big.try_reserve(MEMORY_PROBE).map(|()| big.capacity()),
|
||||||
|
);
|
||||||
|
drop(big);
|
||||||
|
report("ipc-newline", ipc::send("two\nmessages"));
|
||||||
|
report("ipc-oversize", ipc::send(&"x".repeat(64 * 1024 + 1)));
|
||||||
report(
|
report(
|
||||||
"fetch-file-scheme",
|
"fetch-file-scheme",
|
||||||
fetch::fetch("file:///etc/hostname", "GET", &[], None).map(|r| r.status),
|
fetch::fetch("file:///etc/hostname", "GET", &[], None).map(|r| r.status),
|
||||||
|
|
|
||||||
|
|
@ -5,4 +5,5 @@ world app {
|
||||||
import weft:app/fetch@0.1.0;
|
import weft:app/fetch@0.1.0;
|
||||||
import weft:app/notifications@0.1.0;
|
import weft:app/notifications@0.1.0;
|
||||||
import weft:app/clipboard@0.1.0;
|
import weft:app/clipboard@0.1.0;
|
||||||
|
import weft:app/ipc@0.1.0;
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -21,7 +21,10 @@ scenario passes a different set of `--grant` and `--preopen` arguments:
|
||||||
are refused;
|
are refused;
|
||||||
- a wildcard fetch grant, and a grant for the name `localhost`: the local
|
- a wildcard fetch grant, and a grant for the name `localhost`: the local
|
||||||
server is refused, since only an address named in a grant reaches this
|
server is refused, since only an address named in a grant reaches this
|
||||||
machine or a local network; the connection is never made.
|
machine or a local network; the connection is never made;
|
||||||
|
- limits: an allocation beyond the default memory limit (256 MiB) fails
|
||||||
|
inside the component, and succeeds with `--max-memory-mib 512`; app
|
||||||
|
messages longer than 64 KiB or containing a line break are refused.
|
||||||
|
|
||||||
It also checks that the runtime refuses, with a specific error, filesystem
|
It also checks that the runtime refuses, with a specific error, filesystem
|
||||||
capabilities passed as `--grant`, unknown capabilities and preopens
|
capabilities passed as `--grant`, unknown capabilities and preopens
|
||||||
|
|
@ -164,11 +167,19 @@ def check(runner, data):
|
||||||
if REQUESTS:
|
if REQUESTS:
|
||||||
raise AssertionError(f"refused fetches reached the server: {REQUESTS}")
|
raise AssertionError(f"refused fetches reached the server: {REQUESTS}")
|
||||||
|
|
||||||
|
_, probes = runner.run()
|
||||||
|
expect(probes, "memory-grow", False)
|
||||||
|
expect(probes, "ipc-newline", False, contains="line break")
|
||||||
|
expect(probes, "ipc-oversize", False, contains="exceeds")
|
||||||
|
_, probes = runner.run("--max-memory-mib", "512")
|
||||||
|
expect(probes, "memory-grow", True)
|
||||||
|
|
||||||
for arguments, message in (
|
for arguments, message in (
|
||||||
(["--grant", "fs:rw:app-data"], "is not granted through --grant"),
|
(["--grant", "fs:rw:app-data"], "is not granted through --grant"),
|
||||||
(["--preopen", f"{data}::/data"], "--preopen expects HOST::GUEST::ro|rw"),
|
(["--preopen", f"{data}::/data"], "--preopen expects HOST::GUEST::ro|rw"),
|
||||||
(["--preopen", f"{data}::/data::wx"], "--preopen mode must be ro or rw"),
|
(["--preopen", f"{data}::/data::wx"], "--preopen mode must be ro or rw"),
|
||||||
(["--grant", "sys:everything"], "unknown capability 'sys:everything'")):
|
(["--grant", "sys:everything"], "unknown capability 'sys:everything'"),
|
||||||
|
(["--max-memory-mib", "0"], "invalid --max-memory-mib")):
|
||||||
result, _ = runner.run(*arguments, expect_success=False)
|
result, _ = runner.run(*arguments, expect_success=False)
|
||||||
if result.returncode == 0 or message not in result.stderr:
|
if result.returncode == 0 or message not in result.stderr:
|
||||||
raise AssertionError(f"runtime did not refuse {' '.join(arguments)} with "
|
raise AssertionError(f"runtime did not refuse {' '.join(arguments)} with "
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue