mini_racer_rs 1.0.0 → 1.0.2

data/crates/mini_racer_engine/src/runner.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::collections::hash_map::RandomState;
 use std::hash::BuildHasher;
 use std::panic::{AssertUnwindSafe, catch_unwind};
@@ -11,12 +12,15 @@ use mini_racer_sync::{
 use mini_racer_wire::Writer;
 use v8::ValueDeserializerHelper;
 
-use crate::control::{CallbackReply, ControlBlock, Depth, IsolateTerminator, JsText, Request};
+use crate::control::{
+    CallRequest, CallbackReply, ControlBlock, Depth, IsolateTerminator, JsText, Request,
+};
 use crate::fast_calls::{self, Hoisted, Shape};
-use crate::process::code_cache::{Building, Plan};
+use crate::process::code_cache::{Building, Key, Plan};
 use crate::process::fork::Generation;
 use crate::process::platform::{self, Mode};
 use crate::process::watchdog;
+use crate::request::{self, Read};
 use crate::serialize::{self, Filter, Tc};
 use crate::spin::spin_until;
 use crate::{EngineError, JsError, JsErrorKind};
@@ -258,10 +262,9 @@ fn serve(block: &Arc<ControlBlock>, generation: &'static Generation) -> bool {
     ));
     isolate.set_slot(Arc::clone(&runtime));
     // Installed only once the context exists, so nothing terminates its setup.
-    block.term.install(IsolateTerminator::new(
-        isolate.thread_safe_handle(),
-        &block.tasks,
-    ));
+    block
+        .term
+        .install(IsolateTerminator::new(block, isolate.thread_safe_handle()));
     let shared = match sys::share(isolate) {
         Ok(shared) => shared,
         Err(refused) => {
@@ -301,10 +304,9 @@ fn adopt(
         locker.set_slot(Arc::clone(&runtime));
         runtime
     };
-    block.term.install(IsolateTerminator::new(
-        shared.thread_safe_handle(),
-        &block.tasks,
-    ));
+    block
+        .term
+        .install(IsolateTerminator::new(block, shared.thread_safe_handle()));
     let _ = block.isolate.set(shared.thread_safe_handle());
     serve_isolate(block, shared, runtime)
 }
@@ -773,10 +775,12 @@ fn evaluate(
             .code_cache()
             .plan(filename, source, runtime.snapshot)
     } else {
-        Plan::Compile
+        Plan::Compile(None)
     };
     let too_large = || EngineError::Internal("source too large".to_owned());
-    let source = string(tc, source).ok_or_else(too_large)?;
+    let source = shared_source(tc, runtime, plan.key(), source)
+        .or_else(|| string(tc, source))
+        .ok_or_else(too_large)?;
     let name = string(tc, filename).ok_or_else(too_large)?;
     let origin = serialize::origin(tc, name.into());
     let (script, make) = compile(tc, runtime, source, &origin, plan);
@@ -792,6 +796,25 @@ fn evaluate(
     Ok(reply)
 }
 
+// A large script the process has seen before reads its source from the copy
+// every context compiling it shares, outside the V8 heap. `max_memory:`
+// measures the heap, where mini_racer keeps the source, so a context with it
+// keeps its own copy.
+fn shared_source<'s>(
+    scope: &v8::PinScope<'s, '_>,
+    runtime: &Runtime,
+    key: Option<&Key>,
+    source: &JsText,
+) -> Option<v8::Local<'s, v8::String>> {
+    if runtime.block.config.max_memory.is_some() {
+        return None;
+    }
+    let sources = runtime.generation.sources();
+    let string = sys::external_string(scope, &sources.units(key?, source)?)?;
+    sources.read();
+    Some(string)
+}
+
 fn settle<'s>(
     tc: &mut Tc<'s, '_, '_, '_>,
     runtime: &Runtime,
@@ -1043,7 +1066,7 @@ fn compile<'s>(
     plan: Plan,
 ) -> (Option<v8::Local<'s, v8::Script>>, Option<Building>) {
     let (entry, key) = match plan {
-        Plan::Compile => return (v8::Script::compile(scope, source, Some(origin)), None),
+        Plan::Compile(_) => return (v8::Script::compile(scope, source, Some(origin)), None),
         Plan::Make(building) => {
             return (
                 v8::Script::compile(scope, source, Some(origin)),
@@ -1265,19 +1288,36 @@ fn read_request<'s>(
     Some((request, path))
 }
 
+enum Arguments<'s> {
+    Built(Vec<v8::Local<'s, v8::Value>>),
+    Read(v8::Local<'s, v8::Object>),
+}
+
 // mini_racer's order: everything from the path walk on fails as a runtime
 // error. Each dotted segment but the last becomes an object, and the function
 // is called on its parent.
 fn invoke(
     tc: &mut Tc<'_, '_, '_, '_>,
     runtime: &Runtime,
-    request: &[u8],
+    request: &CallRequest,
     (depth, awaited): (Depth, bool),
 ) -> Result<Vec<u8>, EngineError> {
     let context = tc.get_current_context();
     let failed = |tc: &Tc<'_, '_, '_, '_>| failure(tc, JsErrorKind::Runtime);
-    let (request, path) =
-        read_request(tc, request).ok_or_else(|| failure(tc, JsErrorKind::Internal))?;
+    let built = if request::worth_building(request.objects, request.properties) {
+        request::read(tc, &request.bytes, &runtime.block.termination_requested)
+    } else {
+        Read::Unbuilt
+    };
+    let (path, arguments) = match built {
+        Read::Built(call) => (call.path, Arguments::Built(call.args)),
+        Read::Failed => return Err(failure(tc, JsErrorKind::Internal)),
+        Read::Unbuilt => {
+            let (request, path) = read_request(tc, &request.bytes)
+                .ok_or_else(|| failure(tc, JsErrorKind::Internal))?;
+            (Cow::Owned(path), Arguments::Read(request))
+        }
+    };
     let mut receiver = context.global(tc);
     let mut keys = path.split('.').peekable();
     let mut function = None;
@@ -1296,11 +1336,17 @@ fn invoke(
         tc.throw_exception(exception);
         return Err(failed(tc));
     };
-    let count = v8::Local::<v8::Array>::try_from(request).map_or(0, |array| array.length());
-    let mut args = Vec::new();
-    for index in 1..count {
-        args.push(request.get_index(tc, index).ok_or_else(|| failed(tc))?);
-    }
+    let args = match arguments {
+        Arguments::Built(args) => args,
+        Arguments::Read(request) => {
+            let count = v8::Local::<v8::Array>::try_from(request).map_or(0, |array| array.length());
+            let mut args = Vec::new();
+            for index in 1..count {
+                args.push(request.get_index(tc, index).ok_or_else(|| failed(tc))?);
+            }
+            args
+        }
+    };
     let value = function
         .call(tc, receiver.into(), &args)
         .ok_or_else(|| failed(tc))?;
@@ -1372,7 +1418,7 @@ fn trampoline<'s>(
     };
     let outcome = catch_unwind(AssertUnwindSafe(|| callback(scope, &runtime, &args, rv)));
     if outcome.is_err() {
-        scope.terminate_execution();
+        terminate(scope, &runtime);
         runtime.block.channel.close();
     }
 }
@@ -1406,7 +1452,7 @@ fn callback<'s>(
         return;
     };
     if runtime.block.channel.callback(bytes).is_err() {
-        scope.terminate_execution();
+        terminate(scope, runtime);
         return;
     }
     loop {
@@ -1424,13 +1470,13 @@ fn callback<'s>(
                     handle(scope, runtime, request)
                 };
                 if runtime.block.channel.respond(response).is_err() {
-                    scope.terminate_execution();
+                    terminate(scope, runtime);
                     return;
                 }
                 continue;
             }
             None => {
-                scope.terminate_execution();
+                terminate(scope, runtime);
                 return;
             }
         };
@@ -1448,7 +1494,7 @@ fn callback<'s>(
                     scope.throw_exception(exception);
                 }
                 if !runtime.block.term.is_settled() {
-                    scope.terminate_execution();
+                    terminate(scope, runtime);
                 }
             }
             // mini_racer throws a raising callback's exception even with a
@@ -1463,11 +1509,11 @@ fn callback<'s>(
                 *lock(&runtime.raised) = Some(v8::Global::new(scope, exception));
                 scope.throw_exception(exception);
                 if terminating {
-                    scope.terminate_execution();
+                    terminate(scope, runtime);
                 }
             }
             _ if terminating => {
-                scope.terminate_execution();
+                terminate(scope, runtime);
             }
             // As mini_racer reads the reply: a termination pending for this
             // script makes the read throw it, and the script ends here.
@@ -1485,6 +1531,16 @@ fn callback<'s>(
     }
 }
 
+// Sets the flag a runner's own reads consult before V8 is asked to terminate,
+// as the termination cell's requests do.
+fn terminate(isolate: &v8::Isolate, runtime: &Runtime) {
+    runtime
+        .block
+        .termination_requested
+        .store(true, Ordering::Release);
+    isolate.terminate_execution();
+}
+
 fn error<'s>(scope: &v8::PinScope<'s, '_>, message: &JsText) -> v8::Local<'s, v8::Value> {
     let message = string(scope, message)
         .or_else(|| v8::String::new(scope, "Ruby exception"))

data/crates/mini_racer_engine/src/serialize.rs

@@ -1,6 +1,6 @@
-use mini_racer_wire::marker;
+use mini_racer_wire::{Writer, marker};
 
-use crate::snapshot;
+use crate::{snapshot, sys};
 use v8::ValueSerializerHelper;
 
 // mini_racer's filter (mini_racer_v8.cc, MIT, Copyright (c) 2016-2019 the
@@ -59,6 +59,9 @@ pub type Tc<'a, 'b, 'c, 'i> = v8::PinnedRef<'a, v8::TryCatch<'b, 'c, v8::HandleS
 pub struct Filter {
     pub context: v8::Global<v8::Context>,
     function: v8::Global<v8::Function>,
+    // The format version V8's serializer writes, which a reply written
+    // without it carries too.
+    version: u32,
 }
 
 pub fn origin<'s>(
@@ -85,7 +88,7 @@ pub fn contexts(
         .flatten()
         .unwrap_or_else(|| v8::Context::new(scope, v8::ContextOptions::default()));
     let user = v8::Context::new(scope, v8::ContextOptions::default());
-    let function = {
+    let (function, version) = {
         let scope = &mut v8::ContextScope::new(scope, safe);
         let source = v8::String::new(scope, FILTER_SOURCE)?;
         let name = v8::String::new(scope, "safe_context_script.js")?;
@@ -97,17 +100,32 @@ pub fn contexts(
         let global = user.global(scope).into();
         let filter = setup.call(scope, receiver, &[global]);
         safe.use_default_security_token();
-        v8::Local::<v8::Function>::try_from(filter?).ok()?
+        let filter = v8::Local::<v8::Function>::try_from(filter?).ok()?;
+        (filter, wire_version(scope)?)
     };
     Some((
         v8::Global::new(scope, user),
         Filter {
             context: v8::Global::new(scope, safe),
             function: v8::Global::new(scope, function),
+            version,
         },
     ))
 }
 
+fn wire_version(scope: &v8::PinScope<'_, '_>) -> Option<u32> {
+    let bytes = write(scope, v8::undefined(scope).into())?;
+    let (_, header) = bytes.split_first()?;
+    let mut version = 0u32;
+    for (shift, byte) in (0..32).step_by(7).zip(header) {
+        version |= u32::from(byte & 0x7f).checked_shl(shift)?;
+        if byte & 0x80 == 0 {
+            return Some(version);
+        }
+    }
+    None
+}
+
 /// What `mini_racer` does to a result before serializing it: proxies give way
 /// to their targets, symbols to their descriptions, functions to the marker
 /// its Ruby side reads as `JavaScriptFunction`, and weak collections and
@@ -189,6 +207,46 @@ impl v8::ValueSerializerImpl for Delegate {
     }
 }
 
+// The bytes V8's serializer writes for a primitive, written without it: for
+// these values it checks for no termination and runs no script, and the
+// microtasks it would run as it returns ran as the script returned. `None` for
+// anything else, and for a NaN, whose bits V8 copies unchanged.
+fn primitive(
+    isolate: &mut v8::Isolate,
+    version: u32,
+    value: v8::Local<'_, v8::Value>,
+) -> Option<Vec<u8>> {
+    let mut out = Vec::new();
+    let mut writer = Writer::versioned(&mut out, version);
+    if sys::is_smi(&value) {
+        let small = v8::Local::<v8::Int32>::try_from(value).ok()?;
+        writer.integer(small.value().into());
+    } else if let Ok(number) = v8::Local::<v8::Number>::try_from(value) {
+        let number = number.value();
+        if number.is_nan() {
+            return None;
+        }
+        writer.number(number);
+    } else if let Ok(string) = v8::Local::<v8::String>::try_from(value) {
+        let view = v8::ValueView::new(isolate, string);
+        match view.data() {
+            v8::ValueViewData::OneByte(bytes) => writer.latin1(bytes),
+            v8::ValueViewData::TwoByte(units) => writer.utf16_aligned(units),
+        }
+    } else if value.is_undefined() {
+        writer.undefined();
+    } else if value.is_null() {
+        writer.null();
+    } else if value.is_true() {
+        writer.bool(true);
+    } else if value.is_false() {
+        writer.bool(false);
+    } else {
+        return None;
+    }
+    Some(out)
+}
+
 /// Serializes `value` with no filter retry; `None` leaves an exception pending.
 pub fn write(scope: &v8::PinScope<'_, '_>, value: v8::Local<'_, v8::Value>) -> Option<Vec<u8>> {
     let context = scope.get_current_context();
@@ -213,6 +271,9 @@ pub fn reply(
     // mini_racer serializes in a TryCatch of its own, which is not verbose, and
     // rethrows from it; V8 never reports a rethrown exception.
     tc.set_verbose(false);
+    if let Some(bytes) = primitive(tc, filter.version, value) {
+        return Some(bytes);
+    }
     if let Some(bytes) = write(tc, value) {
         return Some(bytes);
     }

data/crates/mini_racer_engine/src/sys.rs

@@ -1,7 +1,10 @@
-use std::ffi::c_void;
+use std::ffi::{c_char, c_void};
 use std::ptr::NonNull;
+use std::sync::Arc;
 use std::time::Duration;
 
+use crate::process::sources::Units;
+
 // The prebuilt V8 archive marks every heap mapping MADV_DONTFORK, so a forked
 // child would lose the isolate's memory. `-Wl,--wrap=madvise` (build.rs) routes
 // V8's calls here; this drops that one advice and forwards the rest unchanged.
@@ -47,6 +50,77 @@ pub fn startup_data(blob: &crate::SnapshotBlob) -> v8::StartupData {
     v8::StartupData::from(bytes)
 }
 
+/// A string V8 reads from `units` in place. It holds a reference to them,
+/// which V8 hands back through `release_one_byte` or `release_two_byte` once,
+/// on whatever thread it runs that on: when the string dies in a collection
+/// or its isolate's teardown, or when V8 internalizes it while it lives and
+/// gives the units to the internalized string, to release when that one dies,
+/// or releases them at once if that string has its own (`MigrateExternalString`
+/// in V8's `string.cc`). `None` past V8's length limit.
+pub fn external_string<'s>(
+    scope: &v8::PinScope<'s, '_>,
+    units: &Units,
+) -> Option<v8::Local<'s, v8::String>> {
+    // V8 refuses a resource past its limit without disposing of it, which
+    // would keep the reference for good, so it never gets one.
+    match units {
+        Units::OneByte(bytes) if bytes.len() <= v8::String::MAX_LENGTH => {
+            let data = Arc::into_raw(Arc::clone(bytes));
+            // SAFETY: the bytes stay where they are, unchanged, while the
+            // reference made here lives; V8 only reads them, and hands the
+            // reference back through `release_one_byte`, with this pointer and
+            // length, once the string dies.
+            unsafe {
+                v8::String::new_external_onebyte_raw(
+                    scope,
+                    data.cast::<c_char>().cast_mut(),
+                    bytes.len(),
+                    release_one_byte,
+                )
+            }
+        }
+        Units::TwoByte(units) if units.len() <= v8::String::MAX_LENGTH => {
+            let data = Arc::into_raw(Arc::clone(units));
+            // SAFETY: as for one byte a unit, through `release_two_byte`.
+            unsafe {
+                v8::String::new_external_twobyte_raw(
+                    scope,
+                    data.cast::<u16>().cast_mut(),
+                    units.len(),
+                    release_two_byte,
+                )
+            }
+        }
+        Units::OneByte(_) | Units::TwoByte(_) => None,
+    }
+}
+
+// Each runs once per string `external_string` made, and only releases its
+// reference: the list in `process::sources` holds another for as long as any
+// string reads them, so the units are never freed here.
+unsafe extern "C" fn release_one_byte(data: *mut c_char, length: usize) {
+    let released = std::panic::catch_unwind(|| {
+        let bytes = std::ptr::slice_from_raw_parts(data.cast::<u8>().cast_const(), length);
+        // SAFETY: V8 passes back the pointer and length `external_string`
+        // gave it, once, so this releases the one reference it made.
+        unsafe { Arc::decrement_strong_count(bytes) };
+    });
+    if released.is_err() {
+        std::process::abort();
+    }
+}
+
+unsafe extern "C" fn release_two_byte(data: *mut u16, length: usize) {
+    let released = std::panic::catch_unwind(|| {
+        let units = std::ptr::slice_from_raw_parts(data.cast_const(), length);
+        // SAFETY: as in `release_one_byte`.
+        unsafe { Arc::decrement_strong_count(units) };
+    });
+    if released.is_err() {
+        std::process::abort();
+    }
+}
+
 /// The address V8 names `isolate` by when it posts the isolate a task.
 #[must_use]
 pub fn isolate_key(isolate: &v8::Isolate) -> usize {
@@ -58,6 +132,22 @@ pub fn isolate_key(isolate: &v8::Isolate) -> usize {
     pointer.addr()
 }
 
+// V8 tags a small integer's word with a clear low bit and a heap object's with
+// a set one.
+const SMI_TAG_MASK: usize = 1;
+
+/// Whether `value` is a small integer, which V8's serializer writes as an
+/// int32; a heap number it writes as a double, even one holding an int32.
+#[must_use]
+pub const fn is_smi(value: &v8::Value) -> bool {
+    let slot: *const v8::Value = value;
+    // SAFETY: rusty_v8 builds V8 without direct handles, so a reference to a
+    // value is the address of its handle slot, one aligned tagged word that
+    // lives as long as the reference.
+    let tagged = unsafe { slot.cast::<usize>().read() };
+    tagged & SMI_TAG_MASK == 0
+}
+
 /// Has V8 report each garbage collection on `isolate`, so its runner can
 /// check the heap against `max_memory`.
 pub fn watch_heap(isolate: &mut v8::Isolate) {

data/crates/mini_racer_wire/src/lib.rs

@@ -20,7 +20,7 @@ pub use write::{WriteError, Writer};
 pub const READ_VERSIONS: RangeInclusive<u32> = 13..=16;
 pub const WRITE_VERSION: u32 = 15;
 
-mod tag {
+pub mod tag {
     pub const HEADER: u8 = 0xFF;
     pub const PADDING: u8 = 0x00;
     pub const VERIFY_OBJECT_COUNT: u8 = b'?';

data/crates/mini_racer_wire/src/write.rs

@@ -22,10 +22,16 @@ pub struct Writer<'a> {
 impl<'a> Writer<'a> {
     /// Starts a frame: clears `out` and writes the header.
     pub fn new(out: &'a mut Vec<u8>) -> Self {
+        Self::versioned(out, WRITE_VERSION)
+    }
+
+    /// Starts a frame under another format version, such as the one V8's own
+    /// serializer writes, for bytes that must match its output.
+    pub fn versioned(out: &'a mut Vec<u8>, version: u32) -> Self {
         out.clear();
         out.push(tag::HEADER);
         let mut writer = Self { out, next_id: 0 };
-        writer.varint(WRITE_VERSION.into());
+        writer.varint(version.into());
         writer
     }
 
@@ -131,6 +137,32 @@ impl<'a> Writer<'a> {
         self.out.extend_from_slice(bytes);
     }
 
+    /// A two-byte string as V8's serializer writes one: after a padding byte
+    /// wherever its characters would otherwise start at an odd offset.
+    pub fn utf16_aligned(&mut self, units: &[u16]) {
+        let bytes = units.len().saturating_mul(2);
+        let mut length_bytes = 1usize;
+        let mut rest = bytes >> 7;
+        while rest > 0 {
+            length_bytes = length_bytes.saturating_add(1);
+            rest >>= 7;
+        }
+        let start = self
+            .out
+            .len()
+            .saturating_add(1)
+            .saturating_add(length_bytes);
+        if !start.is_multiple_of(2) {
+            self.out.push(tag::PADDING);
+        }
+        self.out.push(tag::TWO_BYTE_STRING);
+        self.len(bytes);
+        self.out.reserve(bytes);
+        for unit in units {
+            self.out.extend_from_slice(&unit.to_le_bytes());
+        }
+    }
+
     /// Milliseconds since the Unix epoch; non-finite times become NaN.
     pub fn date(&mut self, millis: f64) -> u32 {
         self.out.push(tag::DATE);

data/ext/mini_racer_rs/src/context.rs

@@ -298,11 +298,13 @@ impl Context {
 
     fn invoke(ruby: &Ruby, rb_self: &Self, args: &[Value], awaited: bool) -> Result<Value, Error> {
         let handle = rb_self.handle(ruby)?;
-        let args = scan_args::<(Value,), (), RArray, (), (), ()>(args)?;
-        let name = rb_raw::expect_string(ruby, args.required.0)?;
-        let request = args.splat;
-        request.unshift(name)?;
-        let request = encode::encode(ruby, request.as_value(), |message| {
+        let Some((&name, args)) = args.split_first() else {
+            // The arity error mini_racer's rb_scan_args raises.
+            scan_args::<(Value,), (), RArray, (), (), ()>(args)?;
+            return Err(errors::internal(ruby, "no function name"));
+        };
+        let name = rb_raw::expect_string(ruby, name)?;
+        let request = encode::call(ruby, name, args, |message| {
             errors::runtime(ruby, [b"Context.call: ".as_slice(), &message].concat())
         })?;
         let bytes = rb_self.dispatch(ruby, |host| {

data/ext/mini_racer_rs/src/decode.rs

@@ -87,10 +87,11 @@ struct Pending {
 }
 
 // The visitor and its frames live on the native stack for the whole decode,
-// where Ruby's GC finds them (I3); `refs` holds every value V8 gave an id.
+// where Ruby's GC finds them (I3); `refs` holds every value V8 gave an id,
+// made at the first, so a result without one allocates none.
 struct RubyVisitor<'r> {
     ruby: &'r Ruby,
-    refs: RArray,
+    refs: Option<RArray>,
     pending: Pending,
 }
 
@@ -359,12 +360,18 @@ impl Visitor for RubyVisitor<'_> {
     }
 
     fn register(&mut self, id: u32, value: Value) -> Result<(), Error> {
+        let ruby = self.ruby;
         self.refs
+            .get_or_insert_with(|| ruby.ary_new())
             .store(isize::try_from(id).unwrap_or(isize::MAX), value)
     }
 
+    // The decoder refers back only to an id it saw registered.
     fn back_ref(&mut self, id: u32) -> Result<Value, Error> {
-        self.refs.entry(isize::try_from(id).unwrap_or(isize::MAX))
+        self.refs.map_or_else(
+            || self.bad_state(),
+            |refs| refs.entry(isize::try_from(id).unwrap_or(isize::MAX)),
+        )
     }
 
     fn push_int32s(&mut self, frame: &mut Frame, values: &[i32]) -> Result<(), Error> {
@@ -416,7 +423,7 @@ const RESULT_LIMITS: Limits = Limits {
 pub fn value(ruby: &Ruby, bytes: &[u8]) -> Result<Value, Error> {
     let mut visitor = RubyVisitor {
         ruby,
-        refs: ruby.ary_new(),
+        refs: None,
         pending: Pending {
             target: None,
             values: [ruby.qnil().as_value(); BATCH],