fix: disable V8 PKU feature for 'deno test' and 'deno bench'

cli/lsp/testing/execution.rs

@@ -294,6 +294,7 @@ impl TestRun {
             specifier,
             sender.clone(),
             fail_fast_tracker,
+            None,
             test::TestSpecifierOptions {
               filter,
               shuffle: None,

cli/tools/bench/mod.rs

@@ -166,13 +166,15 @@ async fn bench_specifier(
   specifier: ModuleSpecifier,
   sender: UnboundedSender<BenchEvent>,
   filter: TestFilter,
+  v8_platform: Option<v8::SharedRef<v8::Platform>>,
 ) -> Result<(), AnyError> {
   let mut worker = worker_factory
     .create_custom_worker(
       specifier.clone(),
       PermissionsContainer::new(permissions),
       vec![ops::bench::deno_bench::init_ops(sender.clone())],
       Default::default(),
+      v8_platform,
     )
     .await?;
 
@@ -240,8 +242,14 @@ async fn bench_specifiers(
   let (sender, mut receiver) = unbounded_channel::<BenchEvent>();
   let log_level = options.log_level;
   let option_for_handles = options.clone();
+  // NOTE(bartlomieju): due to new PKU feature introduced in V8 11.6 we need to
+  // use `new_unprotected` platform here, that disables the PKU. This is done,
+  // because we were getting segfaults if isolates were not created on the main
+  // thread.
+  let v8_platform = v8::Platform::new_unprotected(0, false).make_shared();
 
   let join_handles = specifiers.into_iter().map(move |specifier| {
+    let v8_platform = v8_platform.clone();
     let worker_factory = worker_factory.clone();
     let permissions = permissions.clone();
     let specifier = specifier;
@@ -254,6 +262,7 @@ async fn bench_specifiers(
         specifier,
         sender,
         options.filter,
+        Some(v8_platform.clone()),
       );
       create_and_run_current_thread(future)
     })

cli/tools/test/mod.rs

@@ -411,6 +411,7 @@ pub async fn test_specifier(
   specifier: ModuleSpecifier,
   mut sender: TestEventSender,
   fail_fast_tracker: FailFastTracker,
+  v8_platform: Option<v8::SharedRef<v8::Platform>>,
   options: TestSpecifierOptions,
 ) -> Result<(), AnyError> {
   if fail_fast_tracker.should_stop() {
@@ -428,6 +429,7 @@ pub async fn test_specifier(
         stdout,
         stderr,
       },
+      v8_platform,
     )
     .await?;
 
@@ -815,6 +817,12 @@ async fn test_specifiers(
     specifiers
   };
 
+  // NOTE(bartlomieju): due to new PKU feature introduced in V8 11.6 we need to
+  // use `new_unprotected` platform here, that disables the PKU. This is done,
+  // because we were getting segfaults if isolates were not created on the main
+  // thread.
+  let v8_platform = v8::Platform::new_unprotected(0, false).make_shared();
+
   let (sender, mut receiver) = unbounded_channel::<TestEvent>();
   let sender = TestEventSender::new(sender);
   let concurrent_jobs = options.concurrent_jobs;
@@ -828,6 +836,7 @@ async fn test_specifiers(
   let mut reporter = get_test_reporter(&options);
 
   let join_handles = specifiers.into_iter().map(move |specifier| {
+    let v8_platform = v8_platform.clone();
     let worker_factory = worker_factory.clone();
     let permissions = permissions.clone();
     let sender = sender.clone();
@@ -840,6 +849,7 @@ async fn test_specifiers(
         specifier,
         sender.clone(),
         fail_fast_tracker,
+        Some(v8_platform.clone()),
         specifier_options,
       ))
     })

cli/worker.rs

@@ -329,6 +329,7 @@ impl CliMainWorkerFactory {
         permissions,
         vec![],
         Default::default(),
+        None,
       )
       .await
   }
@@ -339,6 +340,7 @@ impl CliMainWorkerFactory {
     permissions: PermissionsContainer,
     mut custom_extensions: Vec<Extension>,
     stdio: deno_runtime::deno_io::Stdio,
+    v8_platform: Option<deno_core::v8::SharedRef<deno_core::v8::Platform>>,
   ) -> Result<CliMainWorker, AnyError> {
     let shared = &self.shared;
     let (main_module, is_main_cjs) = if let Ok(package_ref) =
@@ -455,6 +457,7 @@ impl CliMainWorkerFactory {
         shared.compiled_wasm_module_store.clone(),
       ),
       stdio,
+      v8_platform,
     };
 
     let worker = MainWorker::bootstrap_from_options(

runtime/worker.rs

@@ -91,6 +91,9 @@ pub struct WorkerOptions {
   /// Optional isolate creation parameters, such as heap limits.
   pub create_params: Option<v8::CreateParams>,
 
+  // Optional `v8::Platform` to use to create the associated `JsRuntime`.
+  pub v8_platform: Option<v8::SharedRef<v8::Platform>>,
+
   pub unsafely_ignore_certificate_errors: Option<Vec<String>>,
   pub root_cert_store_provider: Option<Arc<dyn RootCertStoreProvider>>,
   pub seed: Option<u64>,
@@ -170,6 +173,7 @@ impl Default for WorkerOptions {
       extensions: Default::default(),
       startup_snapshot: Default::default(),
       create_params: Default::default(),
+      v8_platform: Default::default(),
       bootstrap: Default::default(),
       stdio: Default::default(),
     }
@@ -333,6 +337,7 @@ impl MainWorker {
         .startup_snapshot
         .or_else(crate::js::deno_isolate_init),
       create_params: options.create_params,
+      v8_platform: options.v8_platform,
       source_map_getter: options.source_map_getter,
       get_error_class_fn: options.get_error_class_fn,
       shared_array_buffer_store: options.shared_array_buffer_store.clone(),
@@ -341,7 +346,6 @@ impl MainWorker {
       preserve_snapshotted_modules,
       inspector: options.maybe_inspector_server.is_some(),
       is_main: true,
-      ..Default::default()
     });
 
     if let Some(server) = options.maybe_inspector_server.clone() {