haiku.git

// NodeHandleMap.cpp

#include "NodeHandleMap.h"

#include "AutoLocker.h"
#include "GlobalBlockerPool.h"


// constructor
NodeHandleMap::NodeHandleMap(const char* name)
	: Locker(name),
	  fNextNodeHandleCookie(0)
{
}

// destructor
NodeHandleMap::~NodeHandleMap()
{
}

// Init
status_t
NodeHandleMap::Init()
{
	// check semaphore
	if (Sem() < 0)
		return Sem();

	return B_OK;
}

// AddNodeHandle
status_t
NodeHandleMap::AddNodeHandle(NodeHandle* handle)
{
	if (!handle)
		return B_BAD_VALUE;

	AutoLocker<Locker> _(this);

	handle->SetCookie(_NextNodeHandleCookie());

	status_t error = Put(handle->GetCookie(), handle);
	if (error == B_OK)
		handle->AcquireReference();

	return error;
}

// RemoveNodeHandle
bool
NodeHandleMap::RemoveNodeHandle(NodeHandle* handle)
{
	if (!handle)
		return false;

	AutoLocker<Locker> _(this);

	if (Get(handle->GetCookie()) != handle)
		return false;

	Remove(handle->GetCookie());
	handle->ReleaseReference();
	return true;
}

// LockNodeHandle
//
// VolumeManager must NOT be locked.
status_t
NodeHandleMap::LockNodeHandle(int32 cookie, NodeHandle** _handle)
{
	if (!_handle)
		return B_BAD_VALUE;

	NodeHandle* handle;
	{
		AutoLocker<Locker> _(this);

		// get the node handle
		handle = Get(cookie);
		if (!handle)
			return B_ENTRY_NOT_FOUND;
		handle->AcquireReference();

		// first attempt: we just try to lock the node handle, which will fail,
		// if someone else has the lock at the momemt
		if (handle->Lock()) {
			*_handle = handle;
			return B_OK;
		}
	}

	// someone else is locking, get a blocker and wait for the lock
	BlockerPool* blockerPool = GlobalBlockerPool::GetDefault();
	Blocker blocker = blockerPool->GetBlocker();
	BlockerPutter blockerPutter(*blockerPool, blocker);
	LockerCandidate lockerCandidate(blocker);
	{
		AutoLocker<Locker> _(this);

		if (handle->Lock()) {
			*_handle = handle;
			return B_OK;
		}
		handle->QueueLockerCandidate(&lockerCandidate);
	}

	// wait for the lock
	status_t error = lockerCandidate.Block();
	if (error != B_OK) {
		handle->ReleaseReference();
		return error;
	}

	*_handle = handle;
	return B_OK;
}

// UnlockNodeHandle
//
// VolumeManager may or may not be locked.
void
NodeHandleMap::UnlockNodeHandle(NodeHandle* nodeHandle)
{
	if (!nodeHandle)
		return;

	if (nodeHandle->IsLocked()) {
		AutoLocker<Locker> _(this);

		nodeHandle->Unlock();
		nodeHandle->ReleaseReference();
	}
}

// _NextNodeHandleCookie
int32
NodeHandleMap::_NextNodeHandleCookie()
{
	int32 cookie;

	do {
		if (fNextNodeHandleCookie < 0)
			fNextNodeHandleCookie = 0;
		cookie = fNextNodeHandleCookie++;
	} while (ContainsKey(cookie));

	return cookie;
}