diff --git a/src/access.rs b/src/access.rs index 0dff907..f50283e 100644 --- a/src/access.rs +++ b/src/access.rs @@ -464,7 +464,7 @@ fn run_configured_phase(request: &mut Request, conf: &LocationConf, slot: PhaseS }) }); } - run_request_owned_phase(request, program, slot, policy) + run_request_owned_phase(request, program, slot, policy, metadata) } fn complete_sync_ok(raw: *mut ngx_http_request_t, slot: PhaseSlot) -> Status { @@ -483,6 +483,7 @@ fn run_request_owned_phase( program: &Arc, slot: PhaseSlot, policy: crate::host::StandardHostPolicy, + metadata: crate::phase::ScriptExecutionMetadata, ) -> Status { let raw = request.as_mut() as *mut ngx_http_request_t; let directive = slot.directive(); @@ -492,11 +493,12 @@ fn run_request_owned_phase( { let request_id = next_request_id(); let mut exec = match crate::runtime::with_worker(|worker| { - worker.bind_phase_exec_with_policy( + worker.bind_configured_phase_exec_with_policy( Arc::clone(program), request_id, slot.phase(), policy, + metadata, ) }) { Some(Ok(exec)) => exec, diff --git a/src/async_bridge.rs b/src/async_bridge.rs index 823970e..b726371 100644 --- a/src/async_bridge.rs +++ b/src/async_bridge.rs @@ -5,6 +5,8 @@ //! cancel. It is host-agnostic: `ngx::sleep` and any other macro async host //! share the same map. +#[cfg(test)] +use std::cell::Cell; use std::collections::HashMap; use std::task::{Context, Poll}; @@ -12,6 +14,26 @@ use tokio::runtime::Handle; use vm::operation::OperationCancelReason; use vm::{CallReturn, HostAsyncBridge, HostFuture, HostOpId, VmError, VmResult}; +#[cfg(test)] +thread_local! { + static BRIDGES_CREATED: Cell = const { Cell::new(0) }; + static BRIDGES_DROPPED: Cell = const { Cell::new(0) }; +} + +#[cfg(test)] +pub(crate) fn reset_bridge_lifecycle_counts() { + BRIDGES_CREATED.with(|count| count.set(0)); + BRIDGES_DROPPED.with(|count| count.set(0)); +} + +#[cfg(test)] +pub(crate) fn bridge_lifecycle_counts() -> (usize, usize) { + ( + BRIDGES_CREATED.with(Cell::get), + BRIDGES_DROPPED.with(Cell::get), + ) +} + /// Worker-owned async host future table. pub struct NgxAsyncBridge { runtime: Handle, @@ -20,6 +42,8 @@ pub struct NgxAsyncBridge { impl NgxAsyncBridge { pub fn new(runtime: Handle) -> Self { + #[cfg(test)] + BRIDGES_CREATED.with(|count| count.set(count.get().saturating_add(1))); Self { runtime, futures: HashMap::new(), @@ -39,6 +63,13 @@ impl NgxAsyncBridge { } } +#[cfg(test)] +impl Drop for NgxAsyncBridge { + fn drop(&mut self) { + BRIDGES_DROPPED.with(|count| count.set(count.get().saturating_add(1))); + } +} + impl HostAsyncBridge for NgxAsyncBridge { fn submit_op(&mut self, op_id: HostOpId, future: HostFuture) -> VmResult<()> { if self.futures.contains_key(&op_id) { diff --git a/src/config.rs b/src/config.rs index 00753e9..6fbf013 100644 --- a/src/config.rs +++ b/src/config.rs @@ -347,12 +347,28 @@ fn request_state_required_by_imports(program: &Program) -> bool { }) } +fn program_may_suspend_or_retain_state(program: &Program) -> bool { + let builtins = standard_builtin_usage(program); + builtins.io + || builtins.sqlite + || program.imports.iter().any(|import| { + crate::host::ngx_timer_host_names().contains(&import.name.as_str()) + || is_standard_host_import(&import.name) + || ngx_host_manifest().iter().any(|entry| { + entry.name == import.name.as_str() + && (entry.sync == HostSyncKind::Async + || entry.family == HostFamily::Cosocket) + }) + }) +} + fn script_execution_metadata(program: &Program) -> ScriptExecutionMetadata { let builtins = standard_builtin_usage(program); + let requires_request_state = + builtins.io || builtins.sqlite || request_state_required_by_imports(program); ScriptExecutionMetadata { - requires_request_state: builtins.io - || builtins.sqlite - || request_state_required_by_imports(program), + requires_request_state, + reuses_request_vm: requires_request_state && !program_may_suspend_or_retain_state(program), uses_sqlite: builtins.sqlite, } } @@ -366,6 +382,12 @@ pub fn program_requires_request_state(program: &Program) -> bool { script_execution_metadata(program).requires_request_state } +/// True when a request-owned program cannot suspend or retain worker callbacks +/// and can therefore reuse a reset VM after terminal cleanup. +pub fn program_can_reuse_request_vm(program: &Program) -> bool { + script_execution_metadata(program).reuses_request_vm +} + /// Compile with the ngx host catalog and reject unknown or phase-forbidden imports. pub fn compile_rss_source(source: &str) -> Result, ConfigError> { compile_rss_source_for_phase(source, NgxPhase::Access) diff --git a/src/phase.rs b/src/phase.rs index 2da5a94..bbee9fa 100644 --- a/src/phase.rs +++ b/src/phase.rs @@ -33,6 +33,7 @@ impl PhaseSlot { #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] pub struct ScriptExecutionMetadata { pub requires_request_state: bool, + pub reuses_request_vm: bool, pub uses_sqlite: bool, } diff --git a/src/request_state.rs b/src/request_state.rs index 63a087d..97b64e1 100644 --- a/src/request_state.rs +++ b/src/request_state.rs @@ -337,12 +337,29 @@ pub(crate) fn bind_program_hosts(vm: &mut Vm, policy: &StandardHostPolicy) -> Re Ok(()) } +pub(crate) struct ReusableVmKey { + pub program: std::sync::Arc, + pub phase: NgxPhase, + pub policy: StandardHostPolicy, +} + +impl ReusableVmKey { + pub(crate) fn matches(&self, other: &Self) -> bool { + std::ptr::eq(self.program.as_ref(), other.program.as_ref()) + && self.phase == other.phase + && self.policy == other.policy + } +} + /// Wait-slot + waker factory used by [`AccessExec`]. pub trait AsyncWait { fn reserve(&self) -> Result; fn waker(&self, identity: RequestIdentity) -> Waker; fn invalidate(&self, identity: RequestIdentity); fn forget_invalidated(&self, identity: RequestIdentity); + fn recycle_finished_exec(&self, _exec: &mut AccessExec) -> bool { + false + } } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -357,6 +374,7 @@ enum ExecState { /// Request-local VM plus generation-safe wait identity. pub struct AccessExec { vm: Option, + reusable_key: Option, request_id: u64, identity: RequestIdentity, phase: NgxPhase, @@ -413,6 +431,7 @@ impl AccessExec { .map_err(|err| err.to_string())?; Ok(Self { vm: Some(vm), + reusable_key: None, request_id, identity: RequestIdentity::new(generation, request_id), phase, @@ -429,6 +448,40 @@ impl AccessExec { }) } + pub(crate) fn bind_reusable_vm( + vm: Vm, + key: ReusableVmKey, + request_id: u64, + generation: u64, + ) -> Self { + let phase = key.phase; + Self { + vm: Some(vm), + reusable_key: Some(key), + request_id, + identity: RequestIdentity::new(generation, request_id), + phase, + ctx: RequestLocalCtx::new(), + shared_ctx: None, + disposition: RequestDisposition::Continue, + final_status: None, + state: ExecState::New, + suspend_committed: false, + deferred: false, + permit: None, + last_status: None, + last_error: None, + } + } + + pub(crate) fn take_reusable_vm(&mut self) -> Option<(ReusableVmKey, Vm)> { + let key = self.reusable_key.take()?; + let vm = self.vm.take()?; + self.release_owned_ctx(); + self.permit = None; + Some((key, vm)) + } + pub fn phase(&self) -> NgxPhase { self.phase } @@ -798,6 +851,12 @@ impl AccessExec { /// Tombstone, drop the VM/future, then forget the tombstone. pub fn cleanup_wait(&mut self, waiter: &impl AsyncWait) -> Option { if self.is_finished() { + if self.state == ExecState::Halted + && self.reusable_key.is_some() + && waiter.recycle_finished_exec(self) + { + return None; + } return self.cleanup(); } let identity = self.identity; diff --git a/src/runtime.rs b/src/runtime.rs index 3ff74ba..a7a5060 100644 --- a/src/runtime.rs +++ b/src/runtime.rs @@ -19,13 +19,13 @@ use ngx::core::Status; use ngx::ffi::{NGX_LOG_ERR, NGX_LOG_NOTICE, NGX_PROCESS_SINGLE, NGX_PROCESS_WORKER, ngx_process}; use ngx::ngx_log_error; use tokio::runtime::{Handle, Runtime}; -use vm::Program; +use vm::{Program, Vm}; use crate::notify::{ CompletionPermit, CompletionSender, DEFAULT_MAX_IN_FLIGHT, NotifyBridge, NotifyError, RequestIdentity, eventfd_waker, }; -use crate::request_state::{AccessExec, AsyncWait, SubmitError}; +use crate::request_state::{AccessExec, AsyncWait, ReusableVmKey, SubmitError}; thread_local! { static WORKER: RefCell> = const { RefCell::new(None) }; @@ -66,11 +66,46 @@ fn is_worker_or_single() -> bool { process == NGX_PROCESS_WORKER as ngx_uint_t || process == NGX_PROCESS_SINGLE as ngx_uint_t } +const MAX_IDLE_REUSABLE_REQUEST_VMS: usize = 4; + +struct ReusableRequestVm { + key: ReusableVmKey, + vm: Vm, +} + +#[derive(Default)] +struct ReusableRequestVmPool { + idle: Vec, + created: usize, +} + +impl ReusableRequestVmPool { + fn take(&mut self, key: &ReusableVmKey) -> Result { + if let Some(index) = self.idle.iter().position(|entry| entry.key.matches(key)) { + return Ok(self.idle.swap_remove(index).vm); + } + let mut vm = Vm::new_shared(Arc::clone(&key.program)); + crate::request_state::bind_program_hosts(&mut vm, &key.policy)?; + self.created = self.created.saturating_add(1); + Ok(vm) + } + + fn recycle(&mut self, key: ReusableVmKey, mut vm: Vm) { + if self.idle.len() >= MAX_IDLE_REUSABLE_REQUEST_VMS { + return; + } + if crate::vm_pool::reset_for_pool(&mut vm) { + self.idle.push(ReusableRequestVm { key, vm }); + } + } +} + /// Per-worker Tokio runtime, eventfd bridge, and generation counter. pub struct WorkerRuntime { runtime: Option, notify: NotifyBridge, next_generation: u64, + reusable_request_vms: RefCell, stopped: bool, } @@ -94,6 +129,7 @@ impl WorkerRuntime { runtime: Some(runtime), notify, next_generation: 1, + reusable_request_vms: RefCell::new(ReusableRequestVmPool::default()), stopped: false, }) } @@ -174,6 +210,60 @@ impl WorkerRuntime { ) } + pub(crate) fn bind_reusable_phase_exec_with_policy( + &mut self, + program: Arc, + request_id: u64, + phase: crate::host::NgxPhase, + policy: crate::host::StandardHostPolicy, + ) -> Result { + if self.stopped || !self.notify.is_accepting() { + return Err(NotifyError::ShutDown.to_string()); + } + let generation = self.next_generation; + self.next_generation = self.next_generation.wrapping_add(1); + if self.next_generation == 0 { + self.next_generation = 1; + } + let key = ReusableVmKey { + program, + phase, + policy, + }; + let handle = self.handle().map_err(|error| error.to_string())?; + let mut vm = self.reusable_request_vms.borrow_mut().take(&key)?; + vm.set_async_bridge(Box::new(crate::async_bridge::NgxAsyncBridge::new(handle))) + .map_err(|error| error.to_string())?; + Ok(AccessExec::bind_reusable_vm( + vm, key, request_id, generation, + )) + } + + #[cfg(test)] + fn reusable_request_vm_created_count(&self) -> usize { + self.reusable_request_vms.borrow().created + } + + #[cfg(test)] + fn reusable_request_vm_idle_count(&self) -> usize { + self.reusable_request_vms.borrow().idle.len() + } + + pub(crate) fn bind_configured_phase_exec_with_policy( + &mut self, + program: Arc, + request_id: u64, + phase: crate::host::NgxPhase, + policy: crate::host::StandardHostPolicy, + metadata: crate::phase::ScriptExecutionMetadata, + ) -> Result { + if metadata.reuses_request_vm { + self.bind_reusable_phase_exec_with_policy(program, request_id, phase, policy) + } else { + self.bind_phase_exec_with_policy(program, request_id, phase, policy) + } + } + pub fn drain_ready(&mut self) -> Result, RuntimeError> { let (ready, err) = self.drain_ready_outcome(); match err { @@ -199,6 +289,7 @@ impl WorkerRuntime { return; } self.stopped = true; + self.reusable_request_vms.get_mut().idle.clear(); crate::socket::pool::shutdown_current(); crate::semaphore::shutdown_current(); crate::timer::shutdown_current(); @@ -241,6 +332,14 @@ impl AsyncWait for WorkerRuntime { fn forget_invalidated(&self, identity: RequestIdentity) { WorkerRuntime::forget_invalidated(self, identity); } + + fn recycle_finished_exec(&self, exec: &mut AccessExec) -> bool { + let Some((key, vm)) = exec.take_reusable_vm() else { + return false; + }; + self.reusable_request_vms.borrow_mut().recycle(key, vm); + true + } } impl Drop for WorkerRuntime { @@ -522,6 +621,184 @@ mod tests { worker.shutdown(); } + #[test] + fn sync_request_owned_exec_reuses_bound_vm_and_clears_ctx() { + let mut worker = WorkerRuntime::start().unwrap(); + let program = compile_rss_source( + r#" +use ngx; +if ngx::ctx::get("seen") != null { + 1 / 0; +} +ngx::ctx::set("seen", 1); +ngx::exit(ngx::core::ok()); +"#, + ) + .expect("compile"); + let policy = crate::host::StandardHostPolicy::fail_closed(); + + for request_id in 1..=32 { + let mut exec = worker + .bind_reusable_phase_exec_with_policy( + Arc::clone(&program), + request_id, + crate::host::NgxPhase::Access, + policy.clone(), + ) + .expect("bind reusable request VM"); + let mut registry = IdentityRegistry::with_capacity(8); + assert_eq!( + exec.handle_access(&mut registry, &worker), + AccessStatus::Ok, + "request-local ctx must be empty after every pool checkout" + ); + assert!(exec.cleanup_wait(&worker).is_none()); + } + + assert_eq!(worker.reusable_request_vm_created_count(), 1); + assert_eq!(worker.reusable_request_vm_idle_count(), 1); + worker.shutdown(); + } + + #[test] + fn configured_exec_selects_reusable_pool_from_cached_metadata() { + let mut worker = WorkerRuntime::start().unwrap(); + let program = compile_rss_source("use ngx;\nngx::ctx::set(\"k\", 1);\n").expect("compile"); + let metadata = crate::phase::ScriptExecutionMetadata { + requires_request_state: true, + reuses_request_vm: true, + uses_sqlite: false, + }; + for request_id in 1..=2 { + let mut exec = worker + .bind_configured_phase_exec_with_policy( + Arc::clone(&program), + request_id, + crate::host::NgxPhase::Access, + crate::host::StandardHostPolicy::fail_closed(), + metadata, + ) + .expect("bind configured exec"); + let mut registry = IdentityRegistry::with_capacity(8); + assert_eq!(exec.handle_access(&mut registry, &worker), AccessStatus::Ok); + assert!(exec.cleanup_wait(&worker).is_none()); + } + assert_eq!(worker.reusable_request_vm_created_count(), 1); + worker.shutdown(); + } + + #[test] + fn reusable_request_vm_pool_separates_policy_and_phase() { + let mut worker = WorkerRuntime::start().unwrap(); + let program = compile_rss_source("use ngx;\nngx::ctx::set(\"k\", 1);\n").expect("compile"); + let first_policy = crate::host::StandardHostPolicy::fail_closed(); + let mut second_policy = first_policy.clone(); + second_policy.io_roots.push("/tmp/isolated".into()); + + for (request_id, phase, policy) in [ + (1, crate::host::NgxPhase::Access, first_policy.clone()), + (2, crate::host::NgxPhase::Access, second_policy), + (3, crate::host::NgxPhase::Content, first_policy), + ] { + let mut exec = worker + .bind_reusable_phase_exec_with_policy( + Arc::clone(&program), + request_id, + phase, + policy, + ) + .expect("bind reusable exec"); + let mut registry = IdentityRegistry::with_capacity(8); + assert_eq!(exec.handle_access(&mut registry, &worker), AccessStatus::Ok); + assert!(exec.cleanup_wait(&worker).is_none()); + } + + assert_eq!(worker.reusable_request_vm_created_count(), 3); + assert_eq!(worker.reusable_request_vm_idle_count(), 3); + worker.shutdown(); + } + + #[test] + fn configured_exec_keeps_non_reusable_metadata_out_of_request_vm_pool() { + let mut worker = WorkerRuntime::start().unwrap(); + let program = compile_rss_source("use ngx;\nngx::ctx::set(\"k\", 1);\n").expect("compile"); + let metadata = crate::phase::ScriptExecutionMetadata { + requires_request_state: true, + reuses_request_vm: false, + uses_sqlite: false, + }; + for request_id in 1..=2 { + let mut exec = worker + .bind_configured_phase_exec_with_policy( + Arc::clone(&program), + request_id, + crate::host::NgxPhase::Access, + crate::host::StandardHostPolicy::fail_closed(), + metadata, + ) + .expect("bind configured exec"); + let mut registry = IdentityRegistry::with_capacity(8); + assert_eq!(exec.handle_access(&mut registry, &worker), AccessStatus::Ok); + assert!(exec.cleanup_wait(&worker).is_none()); + } + + assert_eq!(worker.reusable_request_vm_created_count(), 0); + assert_eq!(worker.reusable_request_vm_idle_count(), 0); + worker.shutdown(); + } + + #[test] + fn reusable_request_vm_replaces_and_clears_async_bridge_per_checkout() { + crate::async_bridge::reset_bridge_lifecycle_counts(); + let mut worker = WorkerRuntime::start().unwrap(); + let program = compile_rss_source("use ngx;\nngx::ctx::set(\"k\", 1);\n").expect("compile"); + + for request_id in 1..=2 { + let mut exec = worker + .bind_reusable_phase_exec_with_policy( + Arc::clone(&program), + request_id, + crate::host::NgxPhase::Access, + crate::host::StandardHostPolicy::fail_closed(), + ) + .expect("bind reusable exec"); + let mut registry = IdentityRegistry::with_capacity(8); + assert_eq!(exec.handle_access(&mut registry, &worker), AccessStatus::Ok); + assert!(exec.cleanup_wait(&worker).is_none()); + } + + assert_eq!(crate::async_bridge::bridge_lifecycle_counts(), (2, 2)); + worker.shutdown(); + } + + #[test] + fn failed_request_vm_is_dropped_instead_of_reused() { + let mut worker = WorkerRuntime::start().unwrap(); + let program = compile_rss_source("use ngx;\nngx::ctx::set(\"k\", 1);\nlet x = 1 / 0;\n") + .expect("compile"); + + for request_id in 1..=2 { + let mut exec = worker + .bind_reusable_phase_exec_with_policy( + Arc::clone(&program), + request_id, + crate::host::NgxPhase::Access, + crate::host::StandardHostPolicy::fail_closed(), + ) + .expect("bind reusable exec"); + let mut registry = IdentityRegistry::with_capacity(8); + assert_eq!( + exec.handle_access(&mut registry, &worker), + AccessStatus::Error500 + ); + assert!(exec.cleanup_wait(&worker).is_none()); + } + + assert_eq!(worker.reusable_request_vm_created_count(), 2); + assert_eq!(worker.reusable_request_vm_idle_count(), 0); + worker.shutdown(); + } + #[test] fn bounded_capacity_rejects_then_reclaims() { let mut worker = WorkerRuntime::start_with_capacity(1).unwrap(); diff --git a/src/vm_pool.rs b/src/vm_pool.rs index 81dc68a..1754e88 100644 --- a/src/vm_pool.rs +++ b/src/vm_pool.rs @@ -72,7 +72,7 @@ fn construct(program: &Arc) -> Vm { /// Reset through the supported pd-vm APIs. Pending host-IO close cannot be /// driven without an async runtime; those VMs are dropped rather than parked. -fn reset_for_pool(vm: &mut Vm) -> bool { +pub(crate) fn reset_for_pool(vm: &mut Vm) -> bool { if vm.reset_for_reuse().is_err() { return false; } @@ -84,6 +84,10 @@ fn reset_for_pool(vm: &mut Vm) -> bool { Poll::Ready(Err(_)) | Poll::Pending => return false, } } + if vm.clear_async_bridge().is_err() { + return false; + } + vm.clear_runtime_print_sink(); vm.is_reusable() } diff --git a/tests/access_config.rs b/tests/access_config.rs index 7c7a1b3..0843ad2 100644 --- a/tests/access_config.rs +++ b/tests/access_config.rs @@ -203,6 +203,50 @@ fn ctx_only_program_requires_request_owned_exec() { ); } +#[test] +fn synchronous_request_state_programs_are_reusable_but_waiting_programs_are_not() { + let key_auth = + compile_rss_source(include_str!("../examples/key-auth.rss")).expect("key auth example"); + assert!(ngx_rustscript::config::program_requires_request_state( + &key_auth + )); + assert!(ngx_rustscript::config::program_can_reuse_request_vm( + &key_auth + )); + + let ctx = compile_rss_source(include_str!("fixtures/ctx_sync.rss")).expect("ctx-only"); + assert!(ngx_rustscript::config::program_can_reuse_request_vm(&ctx)); + + let sleep = compile_rss_source(include_str!("fixtures/ngx_sleep.rss")).expect("ngx::sleep"); + assert!(!ngx_rustscript::config::program_can_reuse_request_vm( + &sleep + )); + + let retained_or_async_cases = [ + ("timer", "use ngx;\nngx::timer::pending_count();\n"), + ("cosocket", "use ngx;\nlet sock = ngx::socket::udp();\n"), + ( + "standard io", + "use io;\nlet input = io::open(\"x\", \"r\");\nio::close(input);\n", + ), + ( + "sqlite", + "use sqlite;\nlet db = sqlite::open({\"path\": \":memory:\", \"mode\": \"memory\"});\nsqlite::close(db);\n", + ), + ]; + for (label, source) in retained_or_async_cases { + let program = compile_rss_source(source).unwrap_or_else(|error| panic!("{label}: {error}")); + assert!( + ngx_rustscript::config::program_requires_request_state(&program), + "{label} requires request-owned execution" + ); + assert!( + !ngx_rustscript::config::program_can_reuse_request_vm(&program), + "{label} must not enter the synchronous request VM pool" + ); + } +} + #[test] fn import_free_and_codec_programs_stay_on_pool_fast_path() { let ok = compile_rss_source(include_str!("fixtures/ok.rss")).expect("ok.rss"); @@ -242,6 +286,10 @@ fn request_state_routing_uses_manifest_async_or_request_ctx() { access.contains("metadata.requires_request_state"), "access handler must consult cached request-state routing metadata" ); + assert!( + access.contains("bind_configured_phase_exec_with_policy"), + "request-owned access handler must route through the cached execution metadata selector" + ); assert!( !access.contains("disassemble_program"), "request handler must not disassemble programs on the hot path"