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]); + }); +});