From 74c7522dd19cb3064e341039eec35a0eee6f08d5 Mon Sep 17 00:00:00 2001 From: bQUARKz Date: Wed, 7 Oct 2026 20:50:44 +0100 Subject: [PATCH] feat(vm): integrate metered strings and native retention for PLN-0176 step 19 --- .../prometeu-hal/src/debugger_protocol.rs | 6 +- .../console/prometeu-hal/src/host_return.rs | 190 +++++++++++++++++- crates/console/prometeu-hal/src/lib.rs | 2 + .../prometeu-hal/src/value_snapshot.rs | 62 ++++++ .../prometeu-system/src/os/facades/vm.rs | 3 +- .../src/services/vm_runtime/dispatch.rs | 19 +- .../console/prometeu-vm/src/program_image.rs | 3 + .../prometeu-vm/src/program_image/tests.rs | 45 +++++ .../console/prometeu-vm/src/string_ledger.rs | 57 ++++++ .../prometeu-vm/src/string_ledger/tests.rs | 42 ++++ .../prometeu-vm/src/virtual_machine.rs | 77 +++++-- .../prometeu-vm/src/virtual_machine/gc.rs | 3 + .../prometeu-vm/src/virtual_machine/loader.rs | 10 +- .../prometeu-vm/src/virtual_machine/stack.rs | 11 +- .../src/virtual_machine/strings.rs | 69 +++++++ .../src/virtual_machine/typed_tests.rs | 113 ++++++++++- .../host/prometeu-host-headless/src/host.rs | 3 +- 17 files changed, 661 insertions(+), 54 deletions(-) create mode 100644 crates/console/prometeu-hal/src/value_snapshot.rs create mode 100644 crates/console/prometeu-vm/src/virtual_machine/strings.rs diff --git a/crates/console/prometeu-hal/src/debugger_protocol.rs b/crates/console/prometeu-hal/src/debugger_protocol.rs index d718a14..99942ec 100644 --- a/crates/console/prometeu-hal/src/debugger_protocol.rs +++ b/crates/console/prometeu-hal/src/debugger_protocol.rs @@ -1,4 +1,5 @@ use crate::app_mode::AppMode; +#[cfg(test)] use prometeu_bytecode::Value; use serde::{Deserialize, Serialize}; @@ -35,7 +36,7 @@ pub enum DebugResponse { #[serde(rename = "handshake")] Handshake { protocol_version: u32, runtime_version: String, cartridge: HandshakeCartridge }, #[serde(rename = "getState")] - GetState { pc: usize, stack_top: Vec, frame_index: u64, app_id: u32 }, + GetState { pc: usize, stack_top: crate::ValueSnapshot, frame_index: u64, app_id: u32 }, #[serde(rename = "breakpoints")] Breakpoints { pcs: Vec }, } @@ -115,7 +116,8 @@ mod tests { fn test_get_state_serialization() { let resp = DebugResponse::GetState { pc: 42, - stack_top: vec![Value::Int64(10), Value::String("test".into()), Value::Boolean(true)], + stack_top: vec![Value::Int64(10), Value::String("test".into()), Value::Boolean(true)] + .into(), frame_index: 5, app_id: 1, }; diff --git a/crates/console/prometeu-hal/src/host_return.rs b/crates/console/prometeu-hal/src/host_return.rs index f8a0847..6050d66 100644 --- a/crates/console/prometeu-hal/src/host_return.rs +++ b/crates/console/prometeu-hal/src/host_return.rs @@ -1,4 +1,16 @@ +use crate::vm_fault::VmFault; use prometeu_bytecode::{HeapRef, Value}; +use std::sync::Arc; + +/// Native producers describe their output before materializing guest content. +/// The VM provides the session allocator; HAL does not own guest quotas. +pub trait GuestStringAllocator { + fn build( + &mut self, + length: usize, + writer: &mut dyn FnMut(&mut dyn std::fmt::Write) -> std::fmt::Result, + ) -> Result, VmFault>; +} /// Writes only into result slots reserved by the VM. A native handler cannot /// grow the operand buffer or exceed its declared result count. @@ -6,16 +18,28 @@ pub struct HostReturn<'a> { stack: &'a mut Vec, remaining: usize, overflowed: bool, + strings: &'a mut dyn GuestStringAllocator, + failure: Option, } impl<'a> HostReturn<'a> { - pub fn new(stack: &'a mut Vec, result_slots: usize) -> Self { - Self { stack, remaining: result_slots, overflowed: false } + pub fn new( + stack: &'a mut Vec, + result_slots: usize, + strings: &'a mut dyn GuestStringAllocator, + ) -> Self { + Self { stack, remaining: result_slots, overflowed: false, strings, failure: None } + } + pub fn failure(&self) -> Option<&VmFault> { + self.failure.as_ref() } pub fn overflowed(&self) -> bool { self.overflowed } fn admit(&mut self) -> bool { + if self.failure.is_some() { + return false; + } if self.remaining == 0 || self.stack.len() == self.stack.capacity() { self.overflowed = true; false @@ -45,31 +69,183 @@ impl<'a> HostReturn<'a> { self.stack.push(if handle.is_null() { Value::Null } else { Value::HeapRef(handle) }); } } - pub fn push_string(&mut self, s: String) { - if self.admit() { - self.stack.push(Value::string(s)); + pub fn push_string(&mut self, text: &str) -> Result<(), VmFault> { + self.push_string_with_len(text.len(), &mut |writer| writer.write_str(text)) + } + pub fn push_string_with_len( + &mut self, + length: usize, + writer: &mut dyn FnMut(&mut dyn std::fmt::Write) -> std::fmt::Result, + ) -> Result<(), VmFault> { + if !self.admit() { + return self.failure.clone().map_or(Ok(()), Err); + } + match self.strings.build(length, writer) { + Ok(content) => { + self.stack.push(Value::String(content)); + Ok(()) + } + Err(error) => { + self.failure = Some(error.clone()); + Err(error) + } } } + pub fn push_utf8_lossy(&mut self, bytes: &[u8]) -> Result<(), VmFault> { + let mut length = 0usize; + lossy_chunks(bytes, &mut |part| { + length = length.checked_add(part.len()).ok_or(std::fmt::Error)?; + Ok(()) + }) + .map_err(|_| size_overflow())?; + self.push_string_with_len(length, &mut |writer| { + lossy_chunks(bytes, &mut |part| writer.write_str(part)) + }) + } + pub fn push_hex(&mut self, bytes: &[u8]) -> Result<(), VmFault> { + const HEX: &[u8; 16] = b"0123456789abcdef"; + let length = bytes.len().checked_mul(2).ok_or_else(size_overflow)?; + self.push_string_with_len(length, &mut |writer| { + for &byte in bytes { + let pair = [HEX[(byte >> 4) as usize], HEX[(byte & 15) as usize]]; + writer.write_str(std::str::from_utf8(&pair).expect("ASCII hex"))?; + } + Ok(()) + }) + } + pub fn push_joined<'s, I: Iterator + Clone>( + &mut self, + parts: I, + separator: &str, + ) -> Result<(), VmFault> { + let mut length = 0usize; + for (index, part) in parts.clone().enumerate() { + if index > 0 { + length = length.checked_add(separator.len()).ok_or_else(size_overflow)?; + } + length = length.checked_add(part.len()).ok_or_else(size_overflow)?; + } + self.push_string_with_len(length, &mut |writer| { + for (index, part) in parts.clone().enumerate() { + if index > 0 { + writer.write_str(separator)?; + } + writer.write_str(part)?; + } + Ok(()) + }) + } +} + +fn size_overflow() -> VmFault { + VmFault::Trap(prometeu_bytecode::TRAP_RESOURCE_LIMIT, "Native string length overflow".into()) +} +fn lossy_chunks( + mut bytes: &[u8], + emit: &mut dyn FnMut(&str) -> std::fmt::Result, +) -> std::fmt::Result { + while !bytes.is_empty() { + match std::str::from_utf8(bytes) { + Ok(valid) => { + emit(valid)?; + break; + } + Err(error) => { + let valid = error.valid_up_to(); + emit(std::str::from_utf8(&bytes[..valid]).expect("validated prefix"))?; + emit("\u{fffd}")?; + match error.error_len() { + Some(invalid) => bytes = &bytes[valid + invalid..], + None => break, + } + } + } + } + Ok(()) } #[cfg(test)] mod tests { use super::*; + struct RejectStrings; + impl GuestStringAllocator for RejectStrings { + fn build( + &mut self, + _length: usize, + _writer: &mut dyn FnMut(&mut dyn std::fmt::Write) -> std::fmt::Result, + ) -> Result, VmFault> { + panic!("unexpected string allocation") + } + } #[test] fn native_results_cannot_grow_the_reserved_buffer_or_exceed_the_signature() { let mut stack = Vec::with_capacity(8); let capacity = stack.capacity(); - let mut ret = HostReturn::new(&mut stack, 1); + let mut strings = RejectStrings; + let mut ret = HostReturn::new(&mut stack, 1, &mut strings); ret.push_int(7); ret.push_int(8); assert!(ret.overflowed()); assert_eq!(stack, vec![Value::Int64(7)]); assert_eq!(stack.capacity(), capacity); let mut empty = Vec::new(); - let mut ret = HostReturn::new(&mut empty, 1); + let mut ret = HostReturn::new(&mut empty, 1, &mut strings); ret.push_null(); assert!(ret.overflowed()); assert!(empty.is_empty()); assert_eq!(empty.capacity(), 0); } + + struct Collect; + impl GuestStringAllocator for Collect { + fn build( + &mut self, + length: usize, + writer: &mut dyn FnMut(&mut dyn std::fmt::Write) -> std::fmt::Result, + ) -> Result, VmFault> { + let mut text = String::new(); + writer(&mut text).unwrap(); + assert_eq!(text.len(), length); + Ok(Arc::from(text)) + } + } + #[test] + fn measured_native_encoding_matches_utf8_lossy_hex_and_join_semantics() { + for bytes in [ + b"plain".as_slice(), + "é猫".as_bytes(), + &[0xff, 0xe2, 0x82], + &[0xf0, 0x80, 0x80, 0x80, 0x61, 0xc2, 0xa9], + &[], + ] { + let mut stack = Vec::with_capacity(1); + let mut allocator = Collect; + let mut ret = HostReturn::new(&mut stack, 1, &mut allocator); + ret.push_utf8_lossy(bytes).unwrap(); + assert_eq!(stack, vec![Value::string(String::from_utf8_lossy(bytes).as_ref())]); + } + for byte in 0..=255u8 { + let bytes = [b'a', byte, b'b', byte]; + let mut stack = Vec::with_capacity(1); + let mut allocator = Collect; + HostReturn::new(&mut stack, 1, &mut allocator).push_utf8_lossy(&bytes).unwrap(); + assert_eq!(stack, vec![Value::string(String::from_utf8_lossy(&bytes).as_ref())]); + } + let mut stack = Vec::with_capacity(2); + let mut allocator = Collect; + let mut ret = HostReturn::new(&mut stack, 2, &mut allocator); + ret.push_hex(&[0, 0x12, 0xab, 0xff]).unwrap(); + ret.push_joined(["", "é", "猫"].into_iter(), ";").unwrap(); + assert_eq!(stack, vec![Value::string("0012abff"), Value::string(";é;猫")]); + } + + #[test] + fn full_native_result_buffer_does_not_invoke_string_allocator() { + let mut stack = Vec::with_capacity(1); + let mut allocator = RejectStrings; + let mut ret = HostReturn::new(&mut stack, 0, &mut allocator); + ret.push_string("ignored").unwrap(); + assert!(ret.overflowed()); + assert!(stack.is_empty()); + } } diff --git a/crates/console/prometeu-hal/src/lib.rs b/crates/console/prometeu-hal/src/lib.rs index 106bfc0..dd091ee 100644 --- a/crates/console/prometeu-hal/src/lib.rs +++ b/crates/console/prometeu-hal/src/lib.rs @@ -36,6 +36,7 @@ pub mod telemetry; pub mod tile; pub mod tilemap; pub mod touch_bridge; +pub mod value_snapshot; pub mod vm_fault; pub use asset_bridge::AssetBridge; @@ -64,3 +65,4 @@ pub use render_worker::{ RenderWorkerBackend, RenderWorkerError, RenderWorkerFrameSink, RenderWorkerTelemetry, }; pub use touch_bridge::TouchBridge; +pub use value_snapshot::ValueSnapshot; diff --git a/crates/console/prometeu-hal/src/value_snapshot.rs b/crates/console/prometeu-hal/src/value_snapshot.rs new file mode 100644 index 0000000..83aec5c --- /dev/null +++ b/crates/console/prometeu-hal/src/value_snapshot.rs @@ -0,0 +1,62 @@ +use prometeu_bytecode::Value; +use serde::{Deserialize, Serialize}; +use std::sync::Arc; + +/// Native/debug ownership only. Wire data is the ordinary list of values; +/// opaque accounting domains stay alive for every retained string allocation. +#[derive(Clone, Default, Serialize, Deserialize)] +#[serde(transparent)] +pub struct ValueSnapshot { + values: Vec, + #[serde(skip)] + owners: [Option>; 2], +} +impl ValueSnapshot { + pub fn with_owners(values: Vec, owners: [Option>; 2]) -> Self { + Self { values, owners } + } + pub fn retained_domains(&self) -> usize { + self.owners.iter().filter(|owner| owner.is_some()).count() + } +} +impl std::ops::Deref for ValueSnapshot { + type Target = [Value]; + fn deref(&self) -> &[Value] { + &self.values + } +} +impl std::fmt::Debug for ValueSnapshot { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + self.values.fmt(f) + } +} +impl PartialEq> for ValueSnapshot { + fn eq(&self, other: &Vec) -> bool { + self.values == *other + } +} +impl From> for ValueSnapshot { + /// External/native values have no provenance and are copied on guest import. + fn from(values: Vec) -> Self { + Self::with_owners(values, [None, None]) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn serialization_contains_values_and_never_exports_native_domain_metadata() { + let owner: Arc = Arc::new(17u32); + let snapshot = ValueSnapshot::with_owners( + vec![Value::string("shared"), Value::Null], + [Some(owner), None], + ); + assert_eq!(snapshot.retained_domains(), 1); + let bytes = serde_json::to_string(&snapshot).unwrap(); + assert_eq!(bytes, "[\"shared\",null]"); + let imported: ValueSnapshot = serde_json::from_str(&bytes).unwrap(); + assert_eq!(imported.retained_domains(), 0); + assert_eq!(&*imported, &*snapshot); + } +} diff --git a/crates/console/prometeu-system/src/os/facades/vm.rs b/crates/console/prometeu-system/src/os/facades/vm.rs index b530311..31d6c53 100644 --- a/crates/console/prometeu-system/src/os/facades/vm.rs +++ b/crates/console/prometeu-system/src/os/facades/vm.rs @@ -3,7 +3,6 @@ use crate::os::{GameLifecycleEvent, SystemOS}; use crate::task::TaskId; use crate::vm_session::VmSession; use crate::{RenderWorkerConfig, RenderWorkerController}; -use prometeu_bytecode::Value; use prometeu_hal::app_mode::AppMode; use prometeu_hal::telemetry::{CertificationConfig, TelemetryFrame}; use prometeu_hal::{ @@ -100,7 +99,7 @@ impl<'a> VmFacade<'a> { self.active_session().map(|session| session.vm.pc()) } - pub fn active_operand_stack_top(&self, n: usize) -> Vec { + pub fn active_operand_stack_top(&self, n: usize) -> prometeu_hal::ValueSnapshot { self.active_session().map(|session| session.vm.operand_stack_top(n)).unwrap_or_default() } diff --git a/crates/console/prometeu-system/src/services/vm_runtime/dispatch.rs b/crates/console/prometeu-system/src/services/vm_runtime/dispatch.rs index 4e766e2..3561580 100644 --- a/crates/console/prometeu-system/src/services/vm_runtime/dispatch.rs +++ b/crates/console/prometeu-system/src/services/vm_runtime/dispatch.rs @@ -561,7 +561,7 @@ impl NativeInterface for VmRuntimeHost<'_> { .ok_or_else(|| VmFault::Panic("Invalid handle".into()))? .clone(); match self.fs.read_file(&path) { - Ok(data) => ret.push_string(String::from_utf8_lossy(&data).into_owned()), + Ok(data) => ret.push_utf8_lossy(&data)?, Err(_) => ret.push_null(), } Ok(()) @@ -588,8 +588,7 @@ impl NativeInterface for VmRuntimeHost<'_> { let path = expect_string(args, 0, "path")?; match self.fs.list_dir(&path) { Ok(entries) => { - let names: Vec = entries.into_iter().map(|e| e.name).collect(); - ret.push_string(names.join(";")); + ret.push_joined(entries.iter().map(|entry| entry.name.as_str()), ";")?; } Err(_) => ret.push_null(), } @@ -645,14 +644,14 @@ impl NativeInterface for VmRuntimeHost<'_> { let max_bytes = expect_non_negative_usize(args, 2, "max_bytes")?; if self.current_cartridge_app_mode != AppMode::Game { ret.push_int(MemcardStatus::AccessDenied as i64); - ret.push_string(String::new()); + ret.push_string("")?; ret.push_int(0); return Ok(()); } let read = self.memcard.slot_read(self.fs, self.current_app_id, slot, offset, max_bytes); ret.push_int(read.status as i64); - ret.push_string(hex_encode(&read.bytes)); + ret.push_hex(&read.bytes)?; ret.push_int(read.bytes_read as i64); Ok(()) } @@ -866,16 +865,6 @@ fn expect_non_negative_usize(args: &[Value], index: usize, field: &str) -> Resul Ok(val as usize) } -fn hex_encode(bytes: &[u8]) -> String { - const HEX: &[u8; 16] = b"0123456789abcdef"; - let mut out = String::with_capacity(bytes.len() * 2); - for &b in bytes { - out.push(HEX[(b >> 4) as usize] as char); - out.push(HEX[(b & 0x0f) as usize] as char); - } - out -} - fn hex_decode(s: &str) -> Result, VmFault> { fn nibble(c: u8) -> Option { match c { diff --git a/crates/console/prometeu-vm/src/program_image.rs b/crates/console/prometeu-vm/src/program_image.rs index dac5cae..8303a3d 100644 --- a/crates/console/prometeu-vm/src/program_image.rs +++ b/crates/console/prometeu-vm/src/program_image.rs @@ -74,6 +74,9 @@ pub struct ValidatedProgramImage { capabilities: CapFlags, } impl ValidatedProgramImage { + pub(crate) fn string_retention(&self) -> Arc { + self.strings.clone() + } pub fn registry(&self) -> &Arc { &self.registry } diff --git a/crates/console/prometeu-vm/src/program_image/tests.rs b/crates/console/prometeu-vm/src/program_image/tests.rs index 763a4f8..6ecacca 100644 --- a/crates/console/prometeu-vm/src/program_image/tests.rs +++ b/crates/console/prometeu-vm/src/program_image/tests.rs @@ -213,3 +213,48 @@ fn late_work_refusal_releases_all_new_owners() { assert_eq!(b.used(Q::ConstantStringBytes), 0); assert_eq!(b.used(Q::PbxBytes), 0); } + +#[test] +fn constant_strings_share_image_domain_across_sessions_and_native_snapshots() { + use crate::resource_budget::{RuntimeLimits, RuntimeResource}; + use crate::{HostContext, HostReturn, NativeInterface, VirtualMachine}; + struct Native; + impl NativeInterface for Native { + fn syscall( + &mut self, + _id: u32, + _args: &[Value], + _ret: &mut HostReturn, + _ctx: &mut HostContext, + ) -> Result<(), prometeu_hal::vm_fault::VmFault> { + Ok(()) + } + } + let mut code = (Op::PushConst as u16).to_le_bytes().to_vec(); + code.extend_from_slice(&0u32.to_le_bytes()); + code.extend_from_slice(&(Op::Halt as u16).to_le_bytes()); + let bytes = fixture(&code, 1, &[K::String("shared".into())], None, &[]); + let image = ValidatedProgramImage::load(&bytes, &mut budget(), caps::NONE).unwrap(); + let lease = image.lease_constant(0).unwrap(); + let limits = RuntimeLimits::default().lowered(RuntimeResource::StringBytes, 0).unwrap(); + let mut first = VirtualMachine::from_image(image.clone(), limits.clone()); + let mut second = VirtualMachine::from_image(image.clone(), limits); + first.prepare_boot_call().unwrap(); + second.prepare_boot_call().unwrap(); + for vm in [&mut first, &mut second] { + vm.step(&mut Native, &mut HostContext::new(None)).unwrap(); + } + let snapshot = first.operand_stack_top(1); + let other = second.operand_stack_top(1); + let (Value::String(left), Value::String(right)) = (&snapshot[0], &other[0]) else { panic!() }; + assert!(Arc::ptr_eq(left, right)); + assert_eq!(snapshot.retained_domains(), 1); + drop(image); + drop(first); + drop(second); + drop(other); + assert_eq!(lease.retained_content(), (6, 1)); + drop(lease); + let Value::String(text) = &snapshot[0] else { panic!() }; + assert_eq!(text.as_ref(), "shared"); +} diff --git a/crates/console/prometeu-vm/src/string_ledger.rs b/crates/console/prometeu-vm/src/string_ledger.rs index 1a74132..ec6ea05 100644 --- a/crates/console/prometeu-vm/src/string_ledger.rs +++ b/crates/console/prometeu-vm/src/string_ledger.rs @@ -41,6 +41,9 @@ impl StringLease { } impl StringLedger { + pub(crate) fn retention(&self) -> Arc { + self.0.clone() + } pub(crate) fn new(budget: RuntimeBudget) -> Result { let state = budget.reserve( Q::AuxiliaryBytes, @@ -144,6 +147,60 @@ struct TextBuffer { bytes: BudgetVec, failure: Option, } + +pub(crate) enum MaterializeError { + Resource(ResourceFailure), + InvalidLength, +} +impl From for MaterializeError { + fn from(error: ResourceFailure) -> Self { + Self::Resource(error) + } +} +impl StringLedger { + pub(crate) fn build( + &self, + length: usize, + write: &mut dyn FnMut(&mut dyn std::fmt::Write) -> std::fmt::Result, + ) -> Result, MaterializeError> { + let mut domain = self.domain(); + let charges = domain.prepare(length)?; + let mut writer = LimitedTextBuffer { + buffer: TextBuffer { + bytes: BudgetVec::new(&domain.budget, Q::TemporaryBytes), + failure: None, + }, + length, + }; + writer.buffer.bytes.reserve(length)?; + if write(&mut writer).is_err() { + return Err(writer + .buffer + .failure + .map(MaterializeError::Resource) + .unwrap_or(MaterializeError::InvalidLength)); + } + if writer.buffer.bytes.len() != length { + return Err(MaterializeError::InvalidLength); + } + let text = std::str::from_utf8(&writer.buffer.bytes).expect("fmt::Write receives UTF-8"); + let content: Arc = Arc::from(text); + domain.publish(&content, charges); + Ok(content) + } +} +struct LimitedTextBuffer { + buffer: TextBuffer, + length: usize, +} +impl std::fmt::Write for LimitedTextBuffer { + fn write_str(&mut self, text: &str) -> std::fmt::Result { + if text.len() > self.length.saturating_sub(self.buffer.bytes.len()) { + return Err(std::fmt::Error); + } + std::fmt::Write::write_str(&mut self.buffer, text) + } +} impl std::fmt::Write for TextBuffer { fn write_str(&mut self, text: &str) -> std::fmt::Result { self.bytes.extend_from_slice(text.as_bytes()).map_err(|failure| { diff --git a/crates/console/prometeu-vm/src/string_ledger/tests.rs b/crates/console/prometeu-vm/src/string_ledger/tests.rs index 376dd52..55bc724 100644 --- a/crates/console/prometeu-vm/src/string_ledger/tests.rs +++ b/crates/console/prometeu-vm/src/string_ledger/tests.rs @@ -34,6 +34,48 @@ fn clones_share_charge_but_equal_independent_allocations_do_not() { assert_eq!(budget.used(Q::StringAllocations), 0); } +#[test] +fn native_writer_quota_refusal_happens_before_callback_or_content_materialization() { + let (budget, ledger) = fixture(&[(Q::StringBytes, 2)]); + let mut called = false; + let result = ledger.build(3, &mut |writer| { + called = true; + writer.write_str("abc") + }); + assert!( + matches!(result,Err(MaterializeError::Resource(error)) if error.resource==Q::StringBytes) + ); + assert!(!called); + assert_eq!(budget.used(Q::StringBytes), 0); + assert_eq!(budget.used(Q::StringAllocations), 0); + assert_eq!(budget.used(Q::TemporaryBytes), 0); +} + +#[test] +fn native_writer_length_mismatch_cannot_grow_buffer_and_refunds_content_reservations() { + let (budget, ledger) = fixture(&[]); + for (length, text) in [(2, "abc"), (4, "abc")] { + assert!(matches!( + ledger.build(length, &mut |writer| writer.write_str(text)), + Err(MaterializeError::InvalidLength) + )); + assert_eq!(budget.used(Q::StringBytes), 0); + assert_eq!(budget.used(Q::StringAllocations), 0); + assert_eq!(budget.used(Q::TemporaryBytes), 0); + assert_eq!(ledger.tracked_allocations(), 0); + } + let content = ledger + .build(5, &mut |writer| { + writer.write_str("é")?; + writer.write_str("猫") + }) + .ok() + .unwrap(); + assert_eq!(&*content, "é猫"); + assert_eq!(budget.used(Q::StringBytes), 5); + assert_eq!(budget.used(Q::StringAllocations), 1); +} + #[test] fn empty_strings_still_consume_distinct_allocation_records() { let (budget, ledger) = fixture(&[(Q::StringAllocations, 2), (Q::StringBytes, 0)]); diff --git a/crates/console/prometeu-vm/src/virtual_machine.rs b/crates/console/prometeu-vm/src/virtual_machine.rs index 1f23fb9..584c756 100644 --- a/crates/console/prometeu-vm/src/virtual_machine.rs +++ b/crates/console/prometeu-vm/src/virtual_machine.rs @@ -5,6 +5,7 @@ mod loader; mod reference; mod runtime; mod stack; +mod strings; mod typed; #[cfg(test)] mod typed_tests; @@ -87,6 +88,7 @@ pub struct VirtualMachine { /// The loaded executable (Bytecode + Constant Pool), that is the ROM translated. program: ProgramImage, validated_image: Option>, + strings: Option, /// Heap Memory: Dynamic allocation pool. heap: Heap, /// Total virtual cycles consumed since the VM started. @@ -144,10 +146,26 @@ impl VirtualMachine { } /// Returns up to `n` values from the top of the operand stack (top-first order). - pub fn operand_stack_top(&self, n: usize) -> Vec { + pub fn operand_stack_top(&self, n: usize) -> prometeu_hal::ValueSnapshot { let len = self.operand_stack.len(); let start = len.saturating_sub(n); - self.operand_stack[start..].iter().rev().cloned().collect() + let values: Vec<_> = self.operand_stack[start..].iter().rev().cloned().collect(); + let mut owners = [None, None]; + for value in &values { + if let Value::String(content) = value { + if let Some(image) = &self.validated_image { + if owners[0].is_none() && image.retains_string(content) { + owners[0] = Some(image.string_retention()); + } + } + if let Some(strings) = &self.strings { + if owners[1].is_none() && strings.retains(content) { + owners[1] = Some(strings.retention()); + } + } + } + } + prometeu_hal::ValueSnapshot::with_owners(values, owners) } /// Returns a reference to the VM's heap. @@ -204,6 +222,7 @@ impl VirtualMachine { std::collections::HashMap::new(), ), validated_image: None, + strings: None, heap: Heap::with_budget(&budget), cycles: 0, halted: false, @@ -723,26 +742,32 @@ impl VirtualMachine { self.push_trap(a, opcode, start_pc as u32)?; self.push_trap(b, opcode, start_pc as u32)?; } - OpCode::Add => self.binary_op(opcode, start_pc as u32, |a, b| match (&a, &b) { - (Value::String(_), _) | (_, Value::String(_)) => { - let mut out = String::with_capacity(a.string_len_hint() + b.string_len_hint()); - a.append_to_string(&mut out); - b.append_to_string(&mut out); - Ok(Value::string(out)) + OpCode::Add => { + let len = self.operand_stack.len(); + if self.temporary_slots() >= 2 + && (matches!(self.operand_stack[len - 2], Value::String(_)) + || matches!(self.operand_stack[len - 1], Value::String(_))) + { + self.execute_string_add(opcode, start_pc as u32)?; + } else { + self.binary_op(opcode, start_pc as u32, |a, b| match (&a, &b) { + (Value::Int32(a), Value::Int32(b)) => Ok(Value::Int32(a.wrapping_add(*b))), + (Value::Int64(a), Value::Int64(b)) => Ok(Value::Int64(a.wrapping_add(*b))), + (Value::Int32(a), Value::Int64(b)) => { + Ok(Value::Int64((*a as i64).wrapping_add(*b))) + } + (Value::Int64(a), Value::Int32(b)) => { + Ok(Value::Int64(a.wrapping_add(*b as i64))) + } + (Value::Float(a), Value::Float(b)) => Ok(Value::Float(a + b)), + (Value::Int32(a), Value::Float(b)) => Ok(Value::Float(*a as f64 + b)), + (Value::Float(a), Value::Int32(b)) => Ok(Value::Float(a + *b as f64)), + (Value::Int64(a), Value::Float(b)) => Ok(Value::Float(*a as f64 + b)), + (Value::Float(a), Value::Int64(b)) => Ok(Value::Float(a + *b as f64)), + _ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for ADD".into())), + })?; } - (Value::Int32(a), Value::Int32(b)) => Ok(Value::Int32(a.wrapping_add(*b))), - (Value::Int64(a), Value::Int64(b)) => Ok(Value::Int64(a.wrapping_add(*b))), - (Value::Int32(a), Value::Int64(b)) => { - Ok(Value::Int64((*a as i64).wrapping_add(*b))) - } - (Value::Int64(a), Value::Int32(b)) => Ok(Value::Int64(a.wrapping_add(*b as i64))), - (Value::Float(a), Value::Float(b)) => Ok(Value::Float(a + b)), - (Value::Int32(a), Value::Float(b)) => Ok(Value::Float(*a as f64 + b)), - (Value::Float(a), Value::Int32(b)) => Ok(Value::Float(a + *b as f64)), - (Value::Int64(a), Value::Float(b)) => Ok(Value::Float(*a as f64 + b)), - (Value::Float(a), Value::Int64(b)) => Ok(Value::Float(a + *b as f64)), - _ => Err(OpError::Trap(TRAP_TYPE, "Invalid types for ADD".into())), - })?, + } OpCode::Sub => self.binary_op(opcode, start_pc as u32, |a, b| match (a, b) { (Value::Int32(a), Value::Int32(b)) => Ok(Value::Int32(a.wrapping_sub(b))), (Value::Int64(a), Value::Int64(b)) => Ok(Value::Int64(a.wrapping_sub(b))), @@ -1222,12 +1247,22 @@ impl VirtualMachine { self.operand_stack .reserve(syscall.results_count()) .map_err(|e| self.resource_trap(e, opcode, start_pc as u32))?; + let mut strings = strings::SessionStringAllocator { + ledger: &mut self.strings, + budget: self.budget.clone(), + }; let mut ret = crate::HostReturn::new( self.operand_stack.native_result_buffer(), syscall.results_count(), + &mut strings, ); let native_result = native.syscall(id, &args, &mut ret, ctx); let return_overflow = ret.overflowed(); + let return_failure = ret.failure().cloned(); + let native_result = return_failure.map(Err).unwrap_or(native_result); + if native_result.is_err() { + self.operand_stack.truncate(stack_height_before); + } native_result.map_err(|fault| match fault { VmFault::Trap(code, msg) => { self.trap(code, OpCode::Syscall as u16, msg, pc_at_syscall) diff --git a/crates/console/prometeu-vm/src/virtual_machine/gc.rs b/crates/console/prometeu-vm/src/virtual_machine/gc.rs index 63b2cf7..5295477 100644 --- a/crates/console/prometeu-vm/src/virtual_machine/gc.rs +++ b/crates/console/prometeu-vm/src/virtual_machine/gc.rs @@ -20,6 +20,9 @@ impl VirtualMachine { } } + if let Some(strings) = &self.strings { + strings.reconcile(); + } self.current_tick = self.current_tick.wrapping_add(1); self.scheduler.wake_ready(self.current_tick)?; diff --git a/crates/console/prometeu-vm/src/virtual_machine/loader.rs b/crates/console/prometeu-vm/src/virtual_machine/loader.rs index 35a0a27..a708406 100644 --- a/crates/console/prometeu-vm/src/virtual_machine/loader.rs +++ b/crates/console/prometeu-vm/src/virtual_machine/loader.rs @@ -71,6 +71,7 @@ impl VirtualMachine { pub fn initialize(&mut self, program_bytes: Vec) -> Result<(), VmInitError> { self.program = ProgramImage::default(); self.validated_image = None; + self.strings = None; self.pc = 0; self.operand_stack.clear(); self.call_stack.clear(); @@ -177,6 +178,13 @@ impl VirtualMachine { })?; } self.budget.check(RuntimeResource::CallDepth, 1)?; + let mut imported = BudgetVec::new(&self.budget, RuntimeResource::TemporaryBytes); + if self.validated_image.is_some() { + imported.reserve(arguments.len())?; + for value in arguments { + imported.push(self.import_string_value(value)?)?; + } + } let callee = self.program.functions.get(func_idx).cloned().unwrap_or_default(); let total_slots = callee.param_slots as usize + callee.local_slots as usize; let stack_growth = self @@ -202,7 +210,7 @@ impl VirtualMachine { if let Some(func) = self.program.functions.get(func_idx) { let typed = self.validated_image.is_some(); if typed { - self.operand_stack.extend_from_slice(arguments)?; + self.operand_stack.extend_from_slice(&imported)?; } let null_slots = func.local_slots as usize + if typed { 0 } else { func.param_slots as usize }; diff --git a/crates/console/prometeu-vm/src/virtual_machine/stack.rs b/crates/console/prometeu-vm/src/virtual_machine/stack.rs index 111439f..387490c 100644 --- a/crates/console/prometeu-vm/src/virtual_machine/stack.rs +++ b/crates/console/prometeu-vm/src/virtual_machine/stack.rs @@ -32,6 +32,9 @@ impl VirtualMachine { } pub fn push(&mut self, val: Value) -> Result<(), ResourceFailure> { + let growth = self.operand_stack.prepare_growth(1)?; + let val = self.import_string_value(&val)?; + self.operand_stack.commit_growth(growth); self.operand_stack.push(val) } @@ -41,10 +44,12 @@ impl VirtualMachine { opcode: OpCode, pc: u32, ) -> Result<(), LogicalFrameEndingReason> { - self.push(val).map_err(|e| self.resource_trap(e, opcode, pc)) + // Interpreter copies already belong to the current image/session; + // native imports use the public push boundary instead. + self.operand_stack.push(val).map_err(|e| self.resource_trap(e, opcode, pc)) } - pub fn pop(&mut self) -> Result { + pub(crate) fn pop(&mut self) -> Result { if self.temporary_slots() == 0 { return Err("Stack underflow".into()); } @@ -64,7 +69,7 @@ impl VirtualMachine { val.as_integer().ok_or_else(|| "Expected integer".into()) } - pub fn peek(&self) -> Result<&Value, String> { + pub(crate) fn peek(&self) -> Result<&Value, String> { if self.temporary_slots() == 0 { return Err("Stack underflow".into()); } diff --git a/crates/console/prometeu-vm/src/virtual_machine/strings.rs b/crates/console/prometeu-vm/src/virtual_machine/strings.rs new file mode 100644 index 0000000..60515bb --- /dev/null +++ b/crates/console/prometeu-vm/src/virtual_machine/strings.rs @@ -0,0 +1,69 @@ +use super::*; +use crate::string_ledger::{MaterializeError, StringLedger}; +use std::sync::Arc; + +pub(super) struct SessionStringAllocator<'a> { + pub ledger: &'a mut Option, + pub budget: RuntimeBudget, +} +impl prometeu_hal::host_return::GuestStringAllocator for SessionStringAllocator<'_> { + fn build( + &mut self, + length: usize, + writer: &mut dyn FnMut(&mut dyn std::fmt::Write) -> std::fmt::Result, + ) -> Result, VmFault> { + if self.ledger.is_none() { + *self.ledger = Some(StringLedger::new(self.budget.clone()).map_err(resource_fault)?); + } + self.ledger.as_ref().unwrap().build(length, writer).map_err(|error| match error { + MaterializeError::Resource(resource) => resource_fault(resource), + MaterializeError::InvalidLength => VmFault::Panic( + "Native string writer did not produce its declared UTF-8 length".into(), + ), + }) + } +} +fn resource_fault(resource: ResourceFailure) -> VmFault { + VmFault::Trap(TRAP_RESOURCE_LIMIT, resource.to_string()) +} + +impl VirtualMachine { + pub(super) fn import_string_value(&mut self, value: &Value) -> Result { + let Value::String(content) = value else { + return Ok(value.clone()); + }; + if self.validated_image.as_ref().is_some_and(|image| image.retains_string(content)) + || self.strings.as_ref().is_some_and(|domain| domain.retains(content)) + { + return Ok(value.clone()); + } + if self.strings.is_none() { + self.strings = Some(StringLedger::new(self.budget.clone())?); + } + self.strings.as_ref().unwrap().import(content).map(Value::String) + } + pub(super) fn execute_string_add( + &mut self, + opcode: OpCode, + pc: u32, + ) -> Result<(), LogicalFrameEndingReason> { + if self.strings.is_none() { + self.strings = Some( + StringLedger::new(self.budget.clone()) + .map_err(|error| self.resource_trap(error, opcode, pc))?, + ); + } + let base = self.operand_stack.len() - 2; + let content = self + .strings + .as_ref() + .unwrap() + .concat_values(&self.operand_stack[base], &self.operand_stack[base + 1]) + .map_err(|error| self.resource_trap(error, opcode, pc))?; + self.operand_stack.truncate(base); + self.operand_stack + .push(Value::String(content)) + .expect("ADD replaces two existing slots with one"); + Ok(()) + } +} diff --git a/crates/console/prometeu-vm/src/virtual_machine/typed_tests.rs b/crates/console/prometeu-vm/src/virtual_machine/typed_tests.rs index 4c0508e..fb921a6 100644 --- a/crates/console/prometeu-vm/src/virtual_machine/typed_tests.rs +++ b/crates/console/prometeu-vm/src/virtual_machine/typed_tests.rs @@ -426,6 +426,114 @@ fn decoded_stale_handle_is_an_invalid_handle_even_when_target_type_differs() { } } +#[test] +fn decoded_string_add_accounts_content_and_preserves_inputs_on_quota_refusal() { + let mut code = vec![]; + arg(&mut code, OpCode::GetLocal, 0); + arg(&mut code, OpCode::GetLocal, 1); + op(&mut code, OpCode::Add); + op(&mut code, OpCode::Halt); + let image = image(&code, vec![function(0, code.len(), &[4, 0], &[], 0, 2)]); + for (ceiling, success) in [(4, false), (5, true)] { + let mut vm = VirtualMachine::from_image( + image.clone(), + RuntimeLimits::default().lowered(RuntimeResource::StringBytes, ceiling).unwrap(), + ); + vm.prepare_call_with_args("0", &[Value::String(Arc::from("é")), Value::Int32(7)]).unwrap(); + assert_eq!(vm.budget.used(RuntimeResource::StringBytes), 2); + let result = run(&mut vm); + if success { + assert_eq!(result, LogicalFrameEndingReason::Halted); + assert_eq!(vm.operand_stack.last(), Some(&Value::String(Arc::from("é7")))); + assert_eq!(vm.budget.used(RuntimeResource::StringBytes), 5); + assert_eq!(vm.budget.used(RuntimeResource::StringAllocations), 2); + } else { + assert!( + matches!(result,LogicalFrameEndingReason::Trap(info) if info.code==TRAP_RESOURCE_LIMIT && info.pc==12) + ); + assert_eq!(vm.operand_stack.len(), 4); + assert_eq!(vm.operand_stack[2..], vm.operand_stack[..2]); + assert_eq!(vm.budget.used(RuntimeResource::StringBytes), 2); + assert_eq!(vm.budget.used(RuntimeResource::StringAllocations), 1); + } + assert_eq!(vm.budget.used(RuntimeResource::TemporaryBytes), 0); + } +} + +#[test] +fn native_import_and_snapshot_retention_preserve_domain_across_session_close() { + let image = image(&[1, 0], vec![function(0, 2, &[], &[], 0, 1)]); + let mut vm = VirtualMachine::from_image(image.clone(), RuntimeLimits::default()); + let external: Arc = Arc::from("same"); + vm.push(Value::String(external.clone())).unwrap(); + let Value::String(first) = &vm.operand_stack[0] else { panic!() }; + let first = first.clone(); + assert!(!Arc::ptr_eq(&first, &external)); + vm.push(Value::String(first.clone())).unwrap(); + assert_eq!(vm.budget.used(RuntimeResource::StringBytes), 4); + let snapshot = vm.operand_stack_top(2); + assert_eq!(snapshot.retained_domains(), 1); + let budget = vm.budget.clone(); + drop(first); + drop(vm); + assert_eq!(budget.used(RuntimeResource::StringBytes), 4); + let retained = snapshot.clone(); + drop(snapshot); + assert_eq!(budget.used(RuntimeResource::StringAllocations), 1); + let mut destination = VirtualMachine::from_image(image, RuntimeLimits::default()); + destination.push(retained[0].clone()).unwrap(); + let (Value::String(source), Value::String(imported)) = + (&retained[0], &destination.operand_stack[0]) + else { + panic!() + }; + assert!(!Arc::ptr_eq(source, imported)); + assert_eq!(destination.budget.used(RuntimeResource::StringBytes), 4); + drop(retained); + assert_eq!(budget.used(RuntimeResource::StringBytes), 0); + assert_eq!(budget.used(RuntimeResource::StringAllocations), 0); +} + +#[test] +fn native_string_failures_cannot_publish_partial_results_even_if_handler_ignores_error() { + struct ReturnsString; + impl NativeInterface for ReturnsString { + fn syscall( + &mut self, + _id: u32, + _args: &[Value], + ret: &mut HostReturn, + _ctx: &mut HostContext, + ) -> Result<(), VmFault> { + let _ = ret.push_string("abc"); + Ok(()) + } + } + let mut code = vec![]; + arg(&mut code, OpCode::Syscall, prometeu_hal::syscalls::Syscall::SystemHasCart as u32); + let mut vm = VirtualMachine::with_runtime_limits( + code, + vec![], + RuntimeLimits::default().lowered(RuntimeResource::StringBytes, 2).unwrap(), + ); + vm.program.functions = Arc::from(vec![prometeu_bytecode::FunctionMeta { + code_len: 6, + max_stack_slots: 1, + ..Default::default() + }]); + vm.set_capabilities(prometeu_hal::syscalls::caps::SYSTEM); + vm.prepare_boot_call().unwrap(); + let report = vm.run_budget(100, &mut ReturnsString, &mut HostContext::new(None)).unwrap(); + // This synthetic native implementation tests the bounded writer, not the + // has-cart handler's ordinary Boolean semantic contract. + assert!( + matches!(report.reason,LogicalFrameEndingReason::Trap(info) if info.code==TRAP_RESOURCE_LIMIT && info.pc==0) + ); + assert!(vm.operand_stack.is_empty()); + assert_eq!(vm.budget.used(RuntimeResource::StringBytes), 0); + assert_eq!(vm.budget.used(RuntimeResource::StringAllocations), 0); +} + #[test] fn typed_sessions_share_image_but_have_independent_execution_and_heap() { let image = image(&[1, 0], vec![function(0, 2, &[], &[], 0, 0)]); @@ -527,11 +635,14 @@ fn ordered_multi_group_return_preserves_native_owners_and_receiver_identity() { Value::String(text.clone()), ]; vm.prepare_call_with_args("0", &args).unwrap(); + let Value::String(imported) = &vm.operand_stack[6] else { panic!() }; + let imported = imported.clone(); + assert!(!Arc::ptr_eq(&imported, &text)); assert_eq!(run(&mut vm), LogicalFrameEndingReason::EndOfRom); assert_eq!(vm.operand_stack.as_slice(), &args); assert!(vm.call_stack.is_empty()); let Value::String(returned) = &vm.operand_stack[6] else { panic!() }; - assert!(Arc::ptr_eq(returned, &text)); + assert!(Arc::ptr_eq(returned, &imported)); } #[test] diff --git a/crates/host/prometeu-host-headless/src/host.rs b/crates/host/prometeu-host-headless/src/host.rs index fcca69e..0d09e24 100644 --- a/crates/host/prometeu-host-headless/src/host.rs +++ b/crates/host/prometeu-host-headless/src/host.rs @@ -1,7 +1,6 @@ use std::fmt; use std::sync::Arc; -use prometeu_bytecode::Value; use prometeu_drivers::MemoryBanks; use prometeu_drivers::hardware::Hardware; use prometeu_firmware::firmware_state::{AppCrashesStep, ResetStep}; @@ -27,7 +26,7 @@ pub struct CapturedFrame { #[derive(Debug, Clone)] pub struct HostState { pub pc: usize, - pub stack_top: Vec, + pub stack_top: prometeu_hal::ValueSnapshot, pub frame_index: u64, pub tick_index: u64, pub app_id: u32,