Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 4 additions & 2 deletions src/access.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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 {
Expand All @@ -483,6 +483,7 @@ fn run_request_owned_phase(
program: &Arc<Program>,
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();
Expand All @@ -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,
Expand Down
31 changes: 31 additions & 0 deletions src/async_bridge.rs
Original file line number Diff line number Diff line change
Expand Up @@ -5,13 +5,35 @@
//! 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};

use tokio::runtime::Handle;
use vm::operation::OperationCancelReason;
use vm::{CallReturn, HostAsyncBridge, HostFuture, HostOpId, VmError, VmResult};

#[cfg(test)]
thread_local! {
static BRIDGES_CREATED: Cell<usize> = const { Cell::new(0) };
static BRIDGES_DROPPED: Cell<usize> = 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,
Expand All @@ -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(),
Expand All @@ -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) {
Expand Down
28 changes: 25 additions & 3 deletions src/config.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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,
}
}
Expand All @@ -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<Arc<Program>, ConfigError> {
compile_rss_source_for_phase(source, NgxPhase::Access)
Expand Down
1 change: 1 addition & 0 deletions src/phase.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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,
}

Expand Down
59 changes: 59 additions & 0 deletions src/request_state.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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<Program>,
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<CompletionPermit, SubmitError>;
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)]
Expand All @@ -357,6 +374,7 @@ enum ExecState {
/// Request-local VM plus generation-safe wait identity.
pub struct AccessExec {
vm: Option<Vm>,
reusable_key: Option<ReusableVmKey>,
request_id: u64,
identity: RequestIdentity,
phase: NgxPhase,
Expand Down Expand Up @@ -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,
Expand All @@ -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
}
Expand Down Expand Up @@ -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<RequestIdentity> {
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;
Expand Down
Loading
Loading