From 182ccade4f6e860c9af9acc6f288c907a5fc0acd Mon Sep 17 00:00:00 2001 From: Paolo Insogna Date: Thu, 19 Nov 2026 11:55:03 +0100 Subject: [PATCH] src: fix Web Locks synchronization across workers Settle stolen locks in their owning environment instead of from the stealing thread, make the grant decision and the insertion into the held locks a single critical section, keep the environment alive while it has pending requests, cancel native requests on abort, and wake eligible waiters after an owner is cleaned up. Add worker regression tests. Assisted-By: OpenAI GPT-5.6 Sol Signed-off-by: Paolo Insogna --- lib/internal/locks.js | 9 +- src/node_locks.cc | 251 +++++++++++--------- src/node_locks.h | 6 +- test/parallel/test-web-locks-no-livelock.js | 4 +- test/parallel/test-web-locks-workers.js | 246 +++++++++++++++++++ 5 files changed, 404 insertions(+), 112 deletions(-) create mode 100644 test/parallel/test-web-locks-workers.js diff --git a/lib/internal/locks.js b/lib/internal/locks.js index 817159c06e28..2ecf6bebca32 100644 --- a/lib/internal/locks.js +++ b/lib/internal/locks.js @@ -227,10 +227,15 @@ class LockManager { if (signal) { return new Promise((resolve, reject) => { let lockGranted = false; + let released; const abortListener = () => { if (!lockGranted) { - reject(signal.reason || lazyDOMException('The operation was aborted', 'AbortError')); + const reason = signal.reason || lazyDOMException('The operation was aborted', 'AbortError'); + if (released !== undefined) { + locks.cancel(released, reason); + } + reject(reason); } }; @@ -249,7 +254,7 @@ class LockManager { }; try { - const released = locks.request( + released = locks.request( name, clientId, mode, diff --git a/src/node_locks.cc b/src/node_locks.cc index 4fca3a7df94e..8e10d103bd9f 100644 --- a/src/node_locks.cc +++ b/src/node_locks.cc @@ -164,45 +164,19 @@ static void OnIfAvailableReject(const FunctionCallbackInfo& info) { info.GetIsolate()->GetCurrentContext(), info[0])); } -void LockManager::CleanupStolenLocks(Environment* env) { - std::vector resources_to_clean; +bool LockManager::CleanupStolenLocks(Environment* env) { + std::vector> stolen_locks; - // Iterate held locks and remove entries that were stolen from other envs. { Mutex::ScopedLock scoped_lock(mutex_); for (auto resource_iter = held_locks_.begin(); - resource_iter != held_locks_.end(); - ++resource_iter) { + resource_iter != held_locks_.end();) { auto& resource_locks = resource_iter->second; - bool has_stolen_from_other_env = false; - - // Check if this resource has stolen locks from other environments - for (const auto& lock_ptr : resource_locks) { - if (lock_ptr->is_stolen() && lock_ptr->env() != env) { - has_stolen_from_other_env = true; - break; - } - } - - if (has_stolen_from_other_env) { - resources_to_clean.push_back(resource_iter->first); - } - } - } - - // Clean up resources - for (const auto& resource_name : resources_to_clean) { - Mutex::ScopedLock scoped_lock(mutex_); - - auto resource_iter = held_locks_.find(resource_name); - if (resource_iter != held_locks_.end()) { - auto& resource_locks = resource_iter->second; - - // Remove stolen locks from other environments for (auto lock_iter = resource_locks.begin(); lock_iter != resource_locks.end();) { - if ((*lock_iter)->is_stolen() && (*lock_iter)->env() != env) { + if ((*lock_iter)->is_stolen() && (*lock_iter)->env() == env) { + stolen_locks.push_back(*lock_iter); lock_iter = resource_locks.erase(lock_iter); } else { ++lock_iter; @@ -210,10 +184,25 @@ void LockManager::CleanupStolenLocks(Environment* env) { } if (resource_locks.empty()) { - held_locks_.erase(resource_iter); + resource_iter = held_locks_.erase(resource_iter); + } else { + ++resource_iter; } } } + + if (stolen_locks.empty()) return true; + + Local context = env->context(); + Local error = Exception::Error( + FIXED_ONE_BYTE_STRING(env->isolate(), "LOCK_STOLEN")); + for (const auto& lock : stolen_locks) { + if (lock->released_promise()->Reject(context, error).IsNothing()) { + return false; + } + } + + return true; } /** @@ -225,12 +214,13 @@ void LockManager::ProcessQueue(Environment* env) { HandleScope handle_scope(isolate); Local context = env->context(); - // Remove locks that were stolen from this Environment first - CleanupStolenLocks(env); + // Settle stolen locks on the Environment that owns their V8 handles. + if (!CleanupStolenLocks(env)) return; while (true) { std::unique_ptr grantable_request; std::unique_ptr if_available_request; + std::shared_ptr granted_lock; std::unordered_set other_envs_to_wake; /** @@ -308,11 +298,41 @@ void LockManager::ProcessQueue(Environment* env) { pending_queue_.erase(queue_iter); break; } - } - // Wake each environment only once - for (Environment* target_env : other_envs_to_wake) { - WakeEnvironment(target_env); + if (if_available_request) { + env->add_refs(-1); + } + + if (grantable_request) { + env->add_refs(-1); + granted_lock = + std::make_shared(env, + grantable_request->name(), + grantable_request->mode(), + grantable_request->client_id(), + grantable_request->waiting_promise(), + grantable_request->released_promise()); + + if (grantable_request->steal()) { + auto held_locks_iter = + held_locks_.find(grantable_request->name()); + if (held_locks_iter != held_locks_.end()) { + for (const auto& existing_lock : held_locks_iter->second) { + existing_lock->mark_stolen(); + other_envs_to_wake.insert(existing_lock->env()); + } + } + } + + held_locks_[grantable_request->name()].push_back(granted_lock); + } + + // Schedule wakeups while the mutex protects Environment lifetimes. + for (Environment* target_env : other_envs_to_wake) { + if (target_env != env) { + WakeEnvironment(target_env); + } + } } /** @@ -398,73 +418,9 @@ void LockManager::ProcessQueue(Environment* env) { if (!grantable_request) return; - /** - * 1- We grant the lock immediately even if other envs hold it - * 2- All existing locks with the same name are marked stolen, their - * released_promise is rejected, and their owners are woken so they - * can observe the rejection - * 3- We remove stolen locks that belong to this env right away; other - * envs will clean up in their next queue pass - */ - if (grantable_request->steal()) { - std::unordered_set envs_to_notify; - - { - Mutex::ScopedLock scoped_lock(mutex_); - auto held_locks_iter = held_locks_.find(grantable_request->name()); - if (held_locks_iter != held_locks_.end()) { - // Mark existing locks as stolen and collect environments to notify - for (auto& existing_lock : held_locks_iter->second) { - existing_lock->mark_stolen(); - envs_to_notify.insert(existing_lock->env()); - - Local error = - Exception::Error(FIXED_ONE_BYTE_STRING(isolate, "LOCK_STOLEN")); - - if (existing_lock->released_promise() - ->Reject(context, error) - .IsNothing()) - return; - } - - // Remove stolen locks from current environment immediately - for (auto lock_iter = held_locks_iter->second.begin(); - lock_iter != held_locks_iter->second.end();) { - if ((*lock_iter)->env() == env) { - lock_iter = held_locks_iter->second.erase(lock_iter); - } else { - ++lock_iter; - } - } - - if (held_locks_iter->second.empty()) { - held_locks_.erase(held_locks_iter); - } - } - } - - // Wake other environments - for (Environment* target_env : envs_to_notify) { - if (target_env != env) { - WakeEnvironment(target_env); - } - } - } - - // Create and store the new granted lock - auto granted_lock = - std::make_shared(env, - grantable_request->name(), - grantable_request->mode(), - grantable_request->client_id(), - grantable_request->waiting_promise(), - grantable_request->released_promise()); - { - Mutex::ScopedLock scoped_lock(mutex_); - held_locks_[grantable_request->name()].push_back(granted_lock); - } + if (grantable_request->steal() && !CleanupStolenLocks(env)) return; - // Create and store the new granted lock + // Create the lock passed to the user callback. Local lock_info; if (!CreateLockInfoObject(env, *grantable_request).ToLocal(&lock_info)) { return; @@ -624,6 +580,7 @@ void LockManager::Request(const FunctionCallbackInfo& args) { client_id.ToString(), steal, if_available); + env->add_refs(1); // Steal requests get priority by going to front of queue if (steal) { manager->pending_queue_.emplace_front(std::move(lock_request)); @@ -637,6 +594,48 @@ void LockManager::Request(const FunctionCallbackInfo& args) { args.GetReturnValue().Set(released_promise->GetPromise()); } +void LockManager::Cancel(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + Local context = env->context(); + + CHECK_EQ(args.Length(), 2); + CHECK(args[0]->IsPromise()); + + Local released_promise = args[0].As(); + std::unique_ptr canceled_request; + LockManager* manager = GetCurrent(); + { + Mutex::ScopedLock scoped_lock(manager->mutex_); + + for (auto request_iter = manager->pending_queue_.begin(); + request_iter != manager->pending_queue_.end(); + ++request_iter) { + if ((*request_iter)->env() == env && + (*request_iter) + ->released_promise() + ->GetPromise() + ->StrictEquals(released_promise)) { + canceled_request = std::move(*request_iter); + manager->pending_queue_.erase(request_iter); + env->add_refs(-1); + break; + } + } + } + + if (!canceled_request) { + args.GetReturnValue().Set(false); + return; + } + + USE(RejectBoth(context, + canceled_request->waiting_promise(), + canceled_request->released_promise(), + args[1])); + manager->ProcessQueue(env); + args.GetReturnValue().Set(true); +} + void LockManager::Query(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); Isolate* isolate = env->isolate(); @@ -709,16 +708,20 @@ void LockManager::ReleaseLockAndProcessQueue(Environment* env, std::shared_ptr lock, Local callback_result, bool was_rejected) { + bool was_stolen; { Mutex::ScopedLock scoped_lock(mutex_); - ReleaseLock(lock.get()); + was_stolen = lock->is_stolen(); + if (!was_stolen) { + ReleaseLock(lock.get()); + } } Local context = env->context(); // For stolen locks, the released_promise was already rejected when marked as // stolen. - if (!lock->is_stolen()) { + if (!was_stolen) { if (was_rejected) { // Propagate rejection from the user callback if (lock->released_promise() @@ -757,7 +760,10 @@ void LockManager::ReleaseLock(Lock* lock) { // Wakeup of target Environment's event loop void LockManager::WakeEnvironment(Environment* target_env) { - if (target_env == nullptr || target_env->is_stopping()) return; + if (target_env == nullptr || !registered_envs_.contains(target_env) || + target_env->is_stopping()) { + return; + } COUNT_GENERIC_USAGE("LockManager.WakeEnvironment"); @@ -769,6 +775,32 @@ void LockManager::WakeEnvironment(Environment* target_env) { }); } +void LockManager::WakeGrantableEnvironments() { + std::unordered_map first_seen_for_resource; + std::unordered_set envs_to_wake; + + for (const auto& request_ptr : pending_queue_) { + LockRequest* request = request_ptr.get(); + auto& first_for_resource = first_seen_for_resource[request->name()]; + if (first_for_resource == nullptr) { + first_for_resource = request; + } + + bool should_wait_for_earlier_requests = + first_for_resource != request && + (request->mode() == Lock::Mode::Exclusive || + first_for_resource->mode() == Lock::Mode::Exclusive); + if ((!should_wait_for_earlier_requests && IsGrantable(request)) || + request->if_available()) { + envs_to_wake.insert(request->env()); + } + } + + for (Environment* env : envs_to_wake) { + WakeEnvironment(env); + } +} + // Remove all held locks and pending requests that belong to an Environment // that is being destroyed void LockManager::CleanupEnvironment(Environment* env_to_cleanup) { @@ -797,6 +829,7 @@ void LockManager::CleanupEnvironment(Environment* env_to_cleanup) { for (auto request_iter = pending_queue_.begin(); request_iter != pending_queue_.end();) { if ((*request_iter)->env() == env_to_cleanup) { + env_to_cleanup->add_refs(-1); request_iter = pending_queue_.erase(request_iter); } else { ++request_iter; @@ -805,6 +838,8 @@ void LockManager::CleanupEnvironment(Environment* env_to_cleanup) { // Finally, remove it from registered_envs_ registered_envs_.erase(env_to_cleanup); + + WakeGrantableEnvironments(); } // Cleanup hook wrapper @@ -819,6 +854,7 @@ void CreatePerIsolateProperties(IsolateData* isolate_data, Local target) { Isolate* isolate = isolate_data->isolate(); SetMethod(isolate, target, "request", LockManager::Request); + SetMethod(isolate, target, "cancel", LockManager::Cancel); SetMethod(isolate, target, "query", LockManager::Query); PropertyAttribute read_only = static_cast( @@ -841,6 +877,7 @@ void CreatePerContextProperties(Local target, void RegisterExternalReferences(ExternalReferenceRegistry* registry) { registry->Register(LockManager::Request); + registry->Register(LockManager::Cancel); registry->Register(LockManager::Query); registry->Register(OnLockCallbackFulfilled); registry->Register(OnLockCallbackRejected); diff --git a/src/node_locks.h b/src/node_locks.h index cee1d26a42ff..bccf26918bd4 100644 --- a/src/node_locks.h +++ b/src/node_locks.h @@ -144,6 +144,7 @@ class LockRequest final { class LockManager final { public: static void Request(const v8::FunctionCallbackInfo& args); + static void Cancel(const v8::FunctionCallbackInfo& args); static void Query(const v8::FunctionCallbackInfo& args); void ProcessQueue(Environment* env); @@ -164,8 +165,11 @@ class LockManager final { LockManager& operator=(const LockManager&) = delete; bool IsGrantable(const LockRequest* req) const; - void CleanupStolenLocks(Environment* env); + bool CleanupStolenLocks(Environment* env); void ReleaseLock(Lock* lock); + // mutex_ must be held while calling this method. + void WakeGrantableEnvironments(); + // mutex_ must be held while calling this method. void WakeEnvironment(Environment* env); static LockManager current_; diff --git a/test/parallel/test-web-locks-no-livelock.js b/test/parallel/test-web-locks-no-livelock.js index d654acb2b353..b7a64c4e7856 100644 --- a/test/parallel/test-web-locks-no-livelock.js +++ b/test/parallel/test-web-locks-no-livelock.js @@ -19,8 +19,8 @@ const { const resource = `web-locks-no-livelock`; if (!isMainThread) { - // A pending lock request alone does not keep the worker alive, so keep a - // message listener until the parent terminates this Environment. + // Keep this test focused on wakeups; lock request liveness is tested + // separately. parentPort.on('message', () => {}); navigator.locks.request(workerData, () => {}); parentPort.postMessage('ready'); diff --git a/test/parallel/test-web-locks-workers.js b/test/parallel/test-web-locks-workers.js new file mode 100644 index 000000000000..eebccbb1e262 --- /dev/null +++ b/test/parallel/test-web-locks-workers.js @@ -0,0 +1,246 @@ +'use strict'; + +const common = require('../common'); +const assert = require('node:assert'); +const { once } = require('node:events'); +const { setTimeout: delay } = require('node:timers/promises'); +const { describe, it } = require('node:test'); +const { Worker } = require('node:worker_threads'); + +describe('Web Locks with workers', () => { + it('steals a lock held by another worker environment', async () => { + let notifyAcquired; + const acquired = new Promise((resolve) => { + notifyAcquired = resolve; + }); + const originalRequest = navigator.locks.request( + 'cross-environment-steal', + common.mustCall(async () => { + notifyAcquired(); + await new Promise(() => {}); + }), + ); + const originalRejected = assert.rejects( + originalRequest, + { name: 'AbortError' }, + ); + + await acquired; + const worker = new Worker(` + const { parentPort } = require('node:worker_threads'); + + navigator.locks.request( + 'cross-environment-steal', + { steal: true }, + () => 'stolen', + ).then( + (result) => parentPort.postMessage({ result }), + (error) => parentPort.postMessage({ error: error.message }), + ); + `, { eval: true }); + + const [message] = await once(worker, 'message'); + assert.deepStrictEqual(message, { result: 'stolen' }); + await originalRejected; + await worker.terminate(); + }); + + it('rejects a stolen lock while its callback completes', async () => { + const state = new Int32Array(new SharedArrayBuffer(4)); + const worker = new Worker(` + const { parentPort, workerData } = require('node:worker_threads'); + const state = new Int32Array(workerData); + + parentPort.postMessage('ready'); + Atomics.wait(state, 0, 0); + navigator.locks.request( + 'cross-environment-steal-release', + { steal: true }, + () => { + Atomics.store(state, 0, 2); + Atomics.notify(state, 0); + }, + ).then(() => parentPort.postMessage('stolen')); + `, { eval: true, workerData: state.buffer }); + + await once(worker, 'message'); + const stolen = once(worker, 'message'); + const originalRequest = navigator.locks.request( + 'cross-environment-steal-release', + async () => { + Atomics.store(state, 0, 1); + Atomics.notify(state, 0); + Atomics.wait(state, 0, 1); + }, + ); + const originalRejected = assert.rejects( + originalRequest, + { name: 'AbortError' }, + ); + + let timeout; + await Promise.race([ + originalRejected, + new Promise((resolve, reject) => { + timeout = setTimeout( + () => reject(new Error('stolen lock request did not settle')), + 1000, + ); + }), + ]).finally(() => clearTimeout(timeout)); + assert.deepStrictEqual(await stolen, ['stolen']); + await worker.terminate(); + }); + + it('keeps a worker alive while its request is pending', async () => { + let worker; + let outcome; + + await navigator.locks.request('pending-worker-request', async () => { + worker = new Worker(` + const { parentPort } = require('node:worker_threads'); + + parentPort.postMessage('ready'); + navigator.locks.request('pending-worker-request', () => { + parentPort.postMessage('acquired'); + }); + `, { eval: true }); + + await once(worker, 'message'); + outcome = Promise.race([ + once(worker, 'message').then(([message]) => message), + once(worker, 'exit').then(([code]) => `exit:${code}`), + ]); + await delay(100); + }); + + assert.strictEqual(await outcome, 'acquired'); + await worker.terminate(); + }); + + it('grants a pending request after the lock owner terminates', async () => { + const owner = new Worker(` + const { parentPort } = require('node:worker_threads'); + + parentPort.on('message', () => {}); + navigator.locks.request('terminated-lock-owner', async () => { + parentPort.postMessage('acquired'); + await new Promise(() => {}); + }); + `, { eval: true }); + await once(owner, 'message'); + + const waiter = new Worker(` + const { parentPort } = require('node:worker_threads'); + + const request = navigator.locks.request('terminated-lock-owner', () => { + parentPort.postMessage('acquired'); + }); + parentPort.postMessage('queued'); + request.catch((error) => parentPort.postMessage(error.name)); + `, { eval: true }); + await once(waiter, 'message'); + const acquired = once(waiter, 'message').then(([message]) => message); + + await owner.terminate(); + const result = await Promise.race([ + acquired, + delay(common.platformTimeout(500), null, { ref: false }), + ]); + if (result === null) { + await waiter.terminate(); + } + assert.strictEqual(result, 'acquired'); + await waiter.terminate(); + }); + + it('lets a worker exit after its pending request is aborted', async () => { + let worker; + + await navigator.locks.request('aborted-worker-request', common.mustCall(async () => { + worker = new Worker(` + const { parentPort } = require('node:worker_threads'); + const controller = new AbortController(); + + navigator.locks.request( + 'aborted-worker-request', + { signal: controller.signal }, + () => parentPort.postMessage('acquired'), + ).catch((error) => parentPort.postMessage(error.name)); + setImmediate(() => controller.abort()); + `, { eval: true }); + + const exited = once(worker, 'exit').then(([code]) => code); + const [message] = await once(worker, 'message'); + assert.strictEqual(message, 'AbortError'); + const exitCode = await Promise.race([ + exited, + delay(common.platformTimeout(500), null, { ref: false }), + ]); + if (exitCode === null) { + await worker.terminate(); + } + assert.strictEqual(exitCode, 0); + })); + }); + + it('grants exclusive locks atomically across workers', async () => { + const workerCount = 9; + const rounds = 500; + const resourceCount = 4; + const counters = new Int32Array( + new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * resourceCount * 2), + ); + const workerSource = ` + const { parentPort, workerData } = require('node:worker_threads'); + const counters = new Int32Array(workerData.counters); + + parentPort.on('message', async (message) => { + if (message === 'close') { + parentPort.close(); + return; + } + + for (let i = 0; i < workerData.rounds; i++) { + const resource = i % workerData.resourceCount; + await navigator.locks.request(\`exclusive-race-\${resource}\`, async () => { + const active = Atomics.add(counters, resource, 1) + 1; + if (active > 1) { + Atomics.add(counters, workerData.resourceCount + resource, 1); + } + await new Promise(setImmediate); + Atomics.sub(counters, resource, 1); + }); + } + + parentPort.postMessage('done'); + }); + parentPort.postMessage('ready'); + `; + const workers = Array.from({ length: workerCount }, () => new Worker( + workerSource, + { + eval: true, + workerData: { + counters: counters.buffer, + resourceCount, + rounds, + }, + }, + )); + + await Promise.all(workers.map(async (worker) => { + await once(worker, 'message'); + worker.postMessage('start'); + const [message] = await once(worker, 'message'); + assert.strictEqual(message, 'done'); + })); + + const violations = Array.from(counters.subarray(resourceCount)); + await Promise.all(workers.map(async (worker) => { + worker.postMessage('close'); + await once(worker, 'exit'); + })); + assert.deepStrictEqual(violations, [0, 0, 0, 0]); + }); +});