Method wait_for_request

src/lock/lock.cpp:3721–4002

void LockManager::wait_for_request(thread_db* tdbb, lrq* request, SSHORT lck_wait)
{
/**************************************
 *
 *	w a i t _ f o r _ r e q u e s t
 *
 **************************************
 *
 * Functional description
 *	There is a request that needs satisfaction, but is waiting for
 *	somebody else.  Mark the request as pending and go to sleep until
 *	the lock gets poked.  When we wake up, see if somebody else has
 *	cleared the pending flag.  If not, go back to sleep.
 * Returns
 *	FB_SUCCESS	- we waited until the request was granted or rejected
 * 	FB_FAILURE - Insufficient resouces to wait (eg: no semaphores)
 *
 **************************************/
	ASSERT_ACQUIRED;

	++(m_sharedMemory->getHeader()->lhb_waits);
	const ULONG scan_interval = m_sharedMemory->getHeader()->lhb_scan_interval;

	// lrq_count will be off if we wait for a pending request
	CHECK(!(request->lrq_flags & LRQ_pending));

	const SRQ_PTR request_offset = SRQ_REL_PTR(request);
	const SRQ_PTR owner_offset = request->lrq_owner;

	own* owner = (own*) SRQ_ABS_PTR(owner_offset);
	owner->own_flags &= ~(OWN_scanned | OWN_wakeup);
	owner->own_waits++;

	request->lrq_flags &= ~LRQ_rejected;
	request->lrq_flags |= LRQ_pending;
	insert_tail(&owner->own_pending, &request->lrq_own_pending);

	const SRQ_PTR lock_offset = request->lrq_lock;
	lbl* lock = (lbl*) SRQ_ABS_PTR(lock_offset);
	lock->lbl_pending_lrq_count++;

	if (!request->lrq_state)
	{
		// If this is a conversion of an existing lock in LCK_none state -
		// put the lock to the end of the list so it's not taking cuts in the lineup
		remove_que(&request->lrq_lbl_requests);
		insert_tail(&lock->lbl_requests, &request->lrq_lbl_requests);
	}

	if (lck_wait <= 0)
		request->lrq_flags |= LRQ_wait_timeout;

	SLONG value = m_sharedMemory->eventClear(&owner->own_wakeup);

	// Post blockage. If the blocking owner has disappeared, the blockage
	// may clear spontaneously.

	post_blockage(tdbb, request, lock);