// VolumeManager.cpp

#include "VolumeManager.h"

#include <new>

#include <sys/stat.h>

#include <AutoDeleter.h>
#include <Entry.h>
#include <fs_info.h>
#include <fs_query.h>
#include <HashMap.h>
#include <NodeMonitor.h>
#include <Volume.h>

#include "ClientVolume.h"
#include "DebugSupport.h"
#include "Directory.h"
#include "Entry.h"
#include "FDManager.h"
#include "NodeHandle.h"
#include "Path.h"
#include "QueryDomain.h"
#include "Volume.h"

// TODO: We should filter recent events at some point. Otherwise we'll end up
// with one event of each kind for each entry/node.

const bigtime_t kRecentEventLifeTime = 100000;	// 0.1 s

// QueryHandler
class VolumeManager::QueryHandler : public BHandler, public QueryListener,
	public BReferenceable {
public:
	QueryHandler(NodeMonitorListener* listener, QueryDomain* queryDomain,
		QueryHandle* handle)
		:
		BHandler(),
		QueryListener(),
		BReferenceable(),
		fListener(listener),
		fQueryDomain(queryDomain),
		fHandle(handle)
	{
	}

	QueryDomain* GetQueryDomain() const
	{
		return fQueryDomain;
	}

	QueryHandle* GetQueryHandle() const
	{
		return fHandle;
	}

	virtual void MessageReceived(BMessage* message)
	{
		switch (message->what) {
			case B_QUERY_UPDATE:
			{
				NodeMonitoringEvent* event = NULL;
				int32 opcode;
				if (message->FindInt32("opcode", &opcode) == B_OK) {
					switch (opcode) {
						case B_ENTRY_CREATED:
							event = new(std::nothrow) EntryCreatedEvent;
							break;
						case B_ENTRY_REMOVED:
							event = new(std::nothrow) EntryRemovedEvent;
							break;
						case B_ENTRY_MOVED:
							event = new(std::nothrow) EntryMovedEvent;
							break;
					}
				}
				if (event) {
					event->queryHandler = this;
					AcquireReference();
					if (event->Init(message) == B_OK)
						fListener->ProcessNodeMonitoringEvent(event);
					else
						delete event;
				}
				break;
			}
			default:
				BHandler::MessageReceived(message);
		}
	}

	virtual void QueryHandleClosed(QueryHandle* handle)
	{
		BLooper* looper = Looper();
		if (looper && looper->Lock()) {
			looper->RemoveHandler(this);
			looper->Unlock();
		}
		handle->SetQueryListener(NULL);
		ReleaseReference();
	}

private:
	NodeMonitorListener*	fListener;
	QueryDomain*			fQueryDomain;
	QueryHandle*			fHandle;
};

// VolumeMap
struct VolumeManager::VolumeMap : HashMap<HashKey32<dev_t>, Volume*> {
};

// ClientVolumeMap
struct VolumeManager::ClientVolumeMap
	: HashMap<HashKey32<int32>, ClientVolume*> {
};

// private BeOS syscalls to set the FD and node monitor slot limits
extern "C" int _kset_fd_limit_(int num);
extern "C" int _kset_mon_limit_(int num);


// EntryCreatedEventMap
struct VolumeManager::EntryCreatedEventMap
	: HashMap<EntryRef, EntryCreatedEvent*> {
};

// EntryRemovedEventMap
struct VolumeManager::EntryRemovedEventMap
	: HashMap<EntryRef, EntryRemovedEvent*> {
};

// EntryMovedEventKey
struct EntryMovedEventKey : public EntryRef {
	EntryMovedEventKey()
	{
	}

	EntryMovedEventKey(dev_t volumeID, ino_t fromDirectory,
		const char* fromName, ino_t toDirectory, const char* toName)
		: EntryRef(volumeID, fromDirectory, fromName),
		  toDirectory(toDirectory),
		  toName(toName)
	{

	}

	uint32 GetHashCode() const
	{
		uint32 hash = EntryRef::GetHashCode();
		hash = 17 * hash + (uint32)(toDirectory >> 32);
		hash = 17 * hash + (uint32)toDirectory;
		hash = 17 * hash + string_hash(toName.GetString());
		return hash;
	}

	bool operator==(const EntryMovedEventKey& other) const
	{
		return (*(const EntryRef*)this) == other
			&& toDirectory == other.toDirectory
			&& toName == other.toName;
	}

	bool operator!=(const EntryMovedEventKey& other) const
	{
		return !(*this == other);
	}

	ino_t		toDirectory;
	HashString	toName;
};

// EntryMovedEventMap
struct VolumeManager::EntryMovedEventMap : HashMap<EntryRef, EntryMovedEvent*> {
};

// NodeStatChangedEventMap
struct VolumeManager::NodeStatChangedEventMap
	: HashMap<NodeRef, StatChangedEvent*> {
};

typedef EntryRef AttributeRef;

// NodeAttributeChangedEventMap
struct VolumeManager::NodeAttributeChangedEventMap
	: HashMap<AttributeRef, AttributeChangedEvent*> {
};


// #pragma mark -

// constructor
VolumeManager::VolumeManager()
	: fLock("volume manager"),
	  fVolumes(NULL),
	  fRootVolume(NULL),
	  fClientVolumes(NULL),
	  fNodeMonitor(NULL),
	  fNodeMonitoringProcessor(-1),
	  fNodeMonitoringEvents(),
	  fRecentNodeMonitoringEvents(),
	  fEntryCreatedEvents(NULL),
	  fEntryRemovedEvents(NULL),
	  fEntryMovedEvents(NULL),
	  fNodeStatChangedEvents(NULL),
	  fNodeAttributeChangedEvents(NULL),
	  fRevision(0),
	  fTerminating(false)
{
}

// destructor
VolumeManager::~VolumeManager()
{
	// terminate the node monitor and the node monitoring processor
	fTerminating = true;
	if (fNodeMonitor && fNodeMonitor->Lock())
		fNodeMonitor->Quit();
	fNodeMonitoringEvents.Close(true);
	if (fNodeMonitoringProcessor >= 0) {
		int32 result;
		wait_for_thread(fNodeMonitoringProcessor, &result);
	}

	// delete all events
	// entry created events
	for (EntryCreatedEventMap::Iterator it = fEntryCreatedEvents->GetIterator();
		 it.HasNext();) {
		it.Next().value->ReleaseReference();
	}
	delete fEntryCreatedEvents;

	// entry removed events
	for (EntryRemovedEventMap::Iterator it = fEntryRemovedEvents->GetIterator();
		 it.HasNext();) {
		it.Next().value->ReleaseReference();
	}
	delete fEntryRemovedEvents;

	// entry moved events
	for (EntryMovedEventMap::Iterator it = fEntryMovedEvents->GetIterator();
		 it.HasNext();) {
		it.Next().value->ReleaseReference();
	}
	delete fEntryMovedEvents;

	// stat changed events
	for (NodeStatChangedEventMap::Iterator it
			= fNodeStatChangedEvents->GetIterator();
		 it.HasNext();) {
		it.Next().value->ReleaseReference();
	}
	delete fNodeStatChangedEvents;

	// attribute changed events
	for (NodeAttributeChangedEventMap::Iterator it
			= fNodeAttributeChangedEvents->GetIterator();
		 it.HasNext();) {
		it.Next().value->ReleaseReference();
	}
	delete fNodeAttributeChangedEvents;

	delete fClientVolumes;

	// delete the volumes
	for (VolumeMap::Iterator it = fVolumes->GetIterator(); it.HasNext();) {
		Volume* volume = it.Next().value;
		delete volume;
	}
	delete fVolumes;
}

// Init
status_t
VolumeManager::Init()
{
	// check node monitoring message queue
	status_t error = fNodeMonitoringEvents.InitCheck();
	if (error != B_OK)
		return error;

	// entry created event map
	fEntryCreatedEvents = new(std::nothrow) EntryCreatedEventMap;
	if (!fEntryCreatedEvents)
		return B_NO_MEMORY;

	// entry removed event map
	fEntryRemovedEvents = new(std::nothrow) EntryRemovedEventMap;
	if (!fEntryRemovedEvents)
		return B_NO_MEMORY;

	// entry moved event map
	fEntryMovedEvents = new(std::nothrow) EntryMovedEventMap;
	if (!fEntryMovedEvents)
		return B_NO_MEMORY;

	// node stat changed event map
	fNodeStatChangedEvents = new(std::nothrow) NodeStatChangedEventMap;
	if (!fNodeStatChangedEvents)
		return B_NO_MEMORY;

	// node attribute changed event map
	fNodeAttributeChangedEvents = new(std::nothrow) NodeAttributeChangedEventMap;
	if (!fNodeAttributeChangedEvents)
		return B_NO_MEMORY;

	// create the node monitor
	fNodeMonitor = new(std::nothrow) NodeMonitor(this);
	if (!fNodeMonitor)
		return B_NO_MEMORY;

	// create the volume map
	fVolumes = new(std::nothrow) VolumeMap;
	if (!fVolumes)
		return B_NO_MEMORY;
	if (fVolumes->InitCheck() != B_OK)
		return fVolumes->InitCheck();

	// create the client volume map
	fClientVolumes = new(std::nothrow) ClientVolumeMap;
	if (!fClientVolumes)
		return B_NO_MEMORY;
	if (fClientVolumes->InitCheck() != B_OK)
		return fClientVolumes->InitCheck();

	// start the node monitor
	thread_id monitorThread = fNodeMonitor->Run();
	if (monitorThread < 0) {
		delete fNodeMonitor;
		fNodeMonitor = NULL;
		return monitorThread;
	}

	// create all volumes
	int32 cookie = 0;
	dev_t volumeID;
	while ((volumeID = next_dev(&cookie)) >= 0)
		_AddVolume(volumeID);

	// get the root volume
	volumeID = dev_for_path("/");
	if (volumeID < 0)
		return volumeID;
	fRootVolume = GetVolume(volumeID, true);
	if (!fRootVolume)
		return B_ERROR;

	// spawn the node monitoring message processor
	fNodeMonitoringProcessor = spawn_thread(&_NodeMonitoringProcessorEntry,
		"node monitoring processor", B_NORMAL_PRIORITY, this);
	if (fNodeMonitoringProcessor < 0)
		return fNodeMonitoringProcessor;
	resume_thread(fNodeMonitoringProcessor);

	return B_OK;
}

// GetRootVolume
Volume*
VolumeManager::GetRootVolume() const
{
	return fRootVolume;
}

// AddClientVolume
status_t
VolumeManager::AddClientVolume(ClientVolume* clientVolume)
{
	if (!clientVolume)
		return B_BAD_VALUE;

	return fClientVolumes->Put(clientVolume->GetID(), clientVolume);
}

// RemoveClientVolume
void
VolumeManager::RemoveClientVolume(ClientVolume* clientVolume)
{
	if (!clientVolume)
		return;

	fClientVolumes->Remove(clientVolume->GetID());
}

// CreateDefault
status_t
VolumeManager::CreateDefault()
{
	if (sManager)
		return B_OK;

	VolumeManager* manager = new(std::nothrow) VolumeManager;
	if (!manager)
		return B_NO_MEMORY;

	status_t error = manager->Init();
	if (error != B_OK) {
		delete manager;
		return error;
	}

	sManager = manager;
	return B_OK;
}

// DeleteDefault
void
VolumeManager::DeleteDefault()
{
	if (sManager) {
		delete sManager;
		sManager = NULL;
	}
}

// GetDefault
VolumeManager*
VolumeManager::GetDefault()
{
	return sManager;
}

// Lock
bool
VolumeManager::Lock()
{
	bool alreadyLocked = fLock.IsLocked();

	bool success = fLock.Lock();

	// If locking was successful and we didn't have a lock before, we increment
	// the revision.
	if (success && !alreadyLocked)
		fRevision++;

	return success;
}

// Unlock
void
VolumeManager::Unlock()
{
	return fLock.Unlock();
}

// GetRevision
int64
VolumeManager::GetRevision() const
{
	return fRevision;
}

// GetVolume
Volume*
VolumeManager::GetVolume(dev_t volumeID, bool add)
{
	Volume* volume = fVolumes->Get(volumeID);
	if (!volume && add)
		_AddVolume(volumeID, &volume);

	return volume;
}


// #pragma mark -

// AddNode
status_t
VolumeManager::AddNode(Node* node)
{
	if (!node || !node->GetVolume())
		return B_BAD_VALUE;

	status_t error = node->GetVolume()->AddNode(node);

	// start watching the node
	if (error == B_OK)
		fNodeMonitor->StartWatching(node->GetNodeRef());

	return error;
}

// RemoveNode
void
VolumeManager::RemoveNode(Node* node)
{
	if (!node)
		return;

	// if the node is a directory, we remove all its entries first
	if (Directory* directory = dynamic_cast<Directory*>(node)) {
		while (Entry* entry = directory->GetFirstEntry()) {
			RemoveEntry(entry);
			delete entry;
		}
	}

	// remove all referring entries
	while (Entry* entry = node->GetFirstReferringEntry())
		RemoveEntry(entry);

	// remove the node from the volume
	if (node->GetVolume())
		node->GetVolume()->RemoveNode(node);

	// stop watching the node
	fNodeMonitor->StopWatching(node->GetNodeRef());
}

// GetNode
Node*
VolumeManager::GetNode(dev_t volumeID, ino_t nodeID)
{
	if (Volume* volume = GetVolume(volumeID))
		return volume->GetNode(nodeID);
	return NULL;
}

// LoadNode
status_t
VolumeManager::LoadNode(const struct stat& st, Node** _node)
{
	Node* node = GetNode(st.st_dev, st.st_ino);
	if (!node) {
		// node not known yet: create it

		// get the volume
		Volume* volume = GetVolume(st.st_dev, true);
		if (!volume)
			return B_BAD_VALUE;

		// create the node
		if (S_ISDIR(st.st_mode))
			node = new(std::nothrow) Directory(volume, st);
		else
			node = new(std::nothrow) Node(volume, st);
		if (!node)
			return B_NO_MEMORY;

		// add it
		status_t error = AddNode(node);
		if (error != B_OK) {
			delete node;
			return error;
		}
	}

	if (_node)
		*_node = node;
	return B_OK;
}


// #pragma mark -

// GetDirectory
Directory*
VolumeManager::GetDirectory(dev_t volumeID, ino_t nodeID)
{
	return dynamic_cast<Directory*>(GetNode(volumeID, nodeID));
}

// GetRootDirectory
Directory*
VolumeManager::GetRootDirectory() const
{
	return (fRootVolume ? fRootVolume->GetRootDirectory() : NULL);
}

// GetParentDirectory
Directory*
VolumeManager::GetParentDirectory(Directory* directory)
{
	if (!directory)
		return NULL;

	// get ".." entry
	Entry* parentEntry;
	if (LoadEntry(directory->GetVolumeID(), directory->GetID(), "..", true,
			&parentEntry) != B_OK) {
		return NULL;
	}

	return dynamic_cast<Directory*>(parentEntry->GetNode());
}

// LoadDirectory
status_t
VolumeManager::LoadDirectory(dev_t volumeID, ino_t directoryID,
	Directory** _directory)
{
	// try to get the node
	Node* node = GetNode(volumeID, directoryID);
	bool newNode = false;
	if (!node) {
		// directory not yet loaded: stat it
		NoAllocEntryRef entryRef(volumeID, directoryID, ".");
		struct stat st;
		BEntry bEntry;
		status_t error = FDManager::SetEntry(&bEntry, &entryRef);
		if (error == B_OK)
			error = bEntry.GetStat(&st);
		if (error != B_OK)
			return error;

		// load the node
		error = LoadNode(st, &node);
		if (error != B_OK)
			return error;

		newNode = true;
	}

	// check, if the node is a directory
	Directory* directory = dynamic_cast<Directory*>(node);
	if (!directory)
		return B_NOT_A_DIRECTORY;

	if (newNode)
		CompletePathToRoot(directory);

	if (_directory)
		*_directory = directory;
	return B_OK;
}


// #pragma mark -

// AddEntry
status_t
VolumeManager::AddEntry(Entry* entry)
{
	if (!entry || !entry->GetVolume() || !entry->GetDirectory()
		|| ! entry->GetNode()) {
		return B_BAD_VALUE;
	}

	// add the entry to the volume
	status_t error = entry->GetVolume()->AddEntry(entry);
	if (error != B_OK)
		return error;

	// add the entry to its directory and node
	entry->GetDirectory()->AddEntry(entry);
	entry->GetNode()->AddReferringEntry(entry);

//PRINT(("VolumeManager::AddEntry(): %ld, %lld, `%s', dir: %p, "
//"entry count: %ld\n", entry->GetVolumeID(), entry->GetDirectoryID(),
//entry->GetName(), entry->GetDirectory(),
//entry->GetDirectory()->CountEntries()));

	return B_OK;
}

// RemoveEntry
void
VolumeManager::RemoveEntry(Entry* entry)
{
	if (entry) {
		// remove the entry from the volume
		if (entry->GetVolume())
			entry->GetVolume()->RemoveEntry(entry);

		// remove the entry from the directory and its node
		entry->GetDirectory()->RemoveEntry(entry);
		entry->GetNode()->RemoveReferringEntry(entry);

//PRINT(("VolumeManager::RemoveEntry(): %ld, %lld, `%s', dir: %p, "
//"entry count: %ld\n", entry->GetVolumeID(), entry->GetDirectoryID(),
//entry->GetName(), entry->GetDirectory(),
//entry->GetDirectory()->CountEntries()));
	}
}

// DeleteEntry
void
VolumeManager::DeleteEntry(Entry* entry, bool keepNode)
{
	if (!entry)
		return;

	Node* node = entry->GetNode();

	// remove the entry
	RemoveEntry(entry);
	delete entry;

	// remove the node, if it doesn't have any more actual referring entries
	if (!keepNode && !node->GetActualReferringEntry()) {
		RemoveNode(node);
		if (node != node->GetVolume()->GetRootDirectory())
			delete node;
	}
}

// GetEntry
Entry*
VolumeManager::GetEntry(dev_t volumeID, ino_t directoryID, const char* name)
{
	if (Volume* volume = GetVolume(volumeID))
		return volume->GetEntry(directoryID, name);
	return NULL;
}

// GetEntry
Entry*
VolumeManager::GetEntry(const entry_ref& ref)
{
	return GetEntry(ref.device, ref.directory, ref.name);
}

// LoadEntry
status_t
VolumeManager::LoadEntry(dev_t volumeID, ino_t directoryID, const char* name,
	bool loadDir, Entry** _entry)
{
	Entry* entry = GetEntry(volumeID, directoryID, name);
	if (!entry) {
		// entry not known yet: create it
		PRINT("VolumeManager::LoadEntry(%" B_PRIdDEV ", "
			"%" B_PRIdINO ", `%s')\n", volumeID, directoryID, name);

		// get the volume
		Volume* volume = GetVolume(volumeID, true);
		if (!volume)
			return B_BAD_VALUE;

		// get the directory
		status_t error = B_OK;
		Directory* directory = GetDirectory(volumeID, directoryID);
		if (!directory) {
			if (!loadDir)
				return B_ENTRY_NOT_FOUND;

//PRINT(("  loading directory...\n"));
			// load the directory
			error = LoadDirectory(volumeID, directoryID, &directory);
			if (error != B_OK)
				return error;
		}

//PRINT(("  opening BNode...\n"));
		// stat the entry
		NoAllocEntryRef entryRef(volumeID, directoryID, name);
		struct stat st;
		BNode bNode;
		error = bNode.SetTo(&entryRef);
//PRINT(("  stat()ing BNode...\n"));
		if (error == B_OK)
			error = bNode.GetStat(&st);
		if (error != B_OK)
			return error;

//PRINT(("  loading node...\n"));
		// load the node
		Node* node;
		error = LoadNode(st, &node);
		if (error != B_OK)
			return error;

//PRINT(("  creating and adding entry...\n"));
		// create the entry
		entry = new(std::nothrow) Entry(volume, directory, name, node);
		if (!entry)
			return B_NO_MEMORY;

		// add it
		error = AddEntry(entry);
		if (error != B_OK) {
			delete entry;
			return error;
		}
//PRINT(("  adding entry done\n"));
	}

	if (_entry)
		*_entry = entry;
	return B_OK;
}


// #pragma mark -

// OpenQuery
status_t
VolumeManager::OpenQuery(QueryDomain* queryDomain, const char* queryString,
	uint32 flags, port_id remotePort, int32 remoteToken, QueryHandle** handle)
{
	if (!queryDomain || !queryString || !handle)
		return B_BAD_VALUE;
	bool liveQuery = (flags & B_LIVE_QUERY);
	PRINT("VolumeManager::OpenQuery(%p, \"%s\", 0x%" B_PRIx32 ", "
		"%" B_PRId32 ", %" B_PRId32 ")\n",
		queryDomain, queryString, flags, remotePort, remoteToken);

	// allocate the handle
	QueryHandle* queryHandle = new(std::nothrow) QueryHandle(remotePort,
		remoteToken);
	if (!queryHandle)
		return B_NO_MEMORY;
	ObjectDeleter<QueryHandle> handleDeleter(queryHandle);

	// allocate a query handler, if this is a live query
	QueryHandler* queryHandler = NULL;
	if (liveQuery) {
		queryHandler = new(std::nothrow) QueryHandler(this, queryDomain,
			queryHandle);
		if (!queryHandler)
			return B_NO_MEMORY;

		fNodeMonitor->Lock();
		fNodeMonitor->AddHandler(queryHandler);
		fNodeMonitor->Unlock();
		queryHandle->SetQueryListener(queryHandler);
	}

	// iterate through the volumes and create a query for each one
	// supporting queries
	for (VolumeMap::Iterator it = fVolumes->GetIterator(); it.HasNext();) {
		Volume* volume = it.Next().value;
		if (!volume->KnowsQuery())
			continue;

		// The volume should either be contained by the client volume or
		// the other way around. Otherwise they are located in different
		// branches of the FS tree and don't have common nodes.
		if (!queryDomain->QueryDomainIntersectsWith(volume))
			continue;
		PRINT("VolumeManager::OpenQuery(): adding Query for volume "
			"%" B_PRIdDEV "\n", volume->GetID());

		// create the query for this volume
		BVolume bVolume(volume->GetID());
		Query* query = new(std::nothrow) Query;
		if (!query)
			return B_NO_MEMORY;

		// init the query
		ObjectDeleter<Query> queryDeleter(query);
		status_t error = query->SetVolume(&bVolume);
		if (error != B_OK)
			return error;
		error = query->SetPredicate(queryString);
		if (error != B_OK)
			return error;
		if (liveQuery) {
			error = query->SetTarget(queryHandler);
			if (error != B_OK)
				return error;
		}

		// fetch
		error = query->Fetch();
		if (error != B_OK)
			return error;

		queryHandle->AddQuery(query);
		queryDeleter.Detach();
	}

	*handle = queryHandle;
	handleDeleter.Detach();
	return B_OK;
}

// CompletePathToRoot
status_t
VolumeManager::CompletePathToRoot(Directory* directory)
{
	if (!directory)
		return B_BAD_VALUE;

	while (directory != GetRootDirectory()) {
		// if the dir has a valid entry referring to it, we've nothing to do
		if (directory->GetActualReferringEntry())
			return B_OK;

		// get a proper entry_ref
		BEntry bEntry;
		entry_ref entryRef(directory->GetVolumeID(), directory->GetID(), ".");
		status_t error = FDManager::SetEntry(&bEntry, &entryRef);
		if (error == B_OK)
			error = bEntry.GetRef(&entryRef);
		if (error != B_OK)
			return error;

		// if the entry is already loaded, we're done
		if (GetEntry(entryRef))
			return B_OK;

		// the entry is not yet known -- load it
		Entry* entry;
		error = LoadEntry(entryRef.device, entryRef.directory, entryRef.name,
			true, &entry);
		if (error != B_OK)
			return error;

		// get the entry's parent dir and enter the next round
		directory = entry->GetDirectory();
	}

	return B_OK;
}

// GetPath
status_t
VolumeManager::GetPath(Entry* entry, Path* path)
{
	// get directory path
	status_t error = GetPath(entry->GetDirectory(), path);
	if (error != B_OK)
		return error;

	// append the entry name
	return path->Append(entry->GetName());
}

// GetPath
status_t
VolumeManager::GetPath(Node* node, Path* path)
{
	if (node == GetRootDirectory())
		return path->SetTo("/");

	// get an entry referring to the node
	Entry* entry = node->GetActualReferringEntry();
	if (!entry) {
		// if the node is a directory, we complete the path to the root and
		// try again
		if (Directory* directory = dynamic_cast<Directory*>(node)) {
			CompletePathToRoot(directory);
			entry = node->GetActualReferringEntry();
		}

		if (!entry)
			return B_ERROR;
	}

	return GetPath(entry, path);
}

// DirectoryContains
bool
VolumeManager::DirectoryContains(Directory* directory, Entry* entry)
{
	if (!directory || !entry)
		return false;

	return DirectoryContains(directory, entry->GetDirectory(), true);
}

// DirectoryContains
bool
VolumeManager::DirectoryContains(Directory* directory, Directory* descendant,
	bool reflexive)
{
	if (!directory || !descendant)
		return false;

	// a directory contains itself, just as defined by the caller
	if (directory == descendant)
		return reflexive;

	// if the directory is the root directory, it contains everything
	Directory* rootDir = GetRootDirectory();
	if (directory == rootDir)
		return true;

	// recursively get the descendant's parent dir until reaching the root dir
	// or the given dir
	while (descendant != rootDir) {
		descendant = GetParentDirectory(descendant);
		if (!descendant)
			return false;

		if (descendant == directory)
			return true;
	}

	return false;
}

// DirectoryContains
bool
VolumeManager::DirectoryContains(Directory* directory, Node* descendant,
	bool reflexive)
{
	if (!directory || !descendant)
		return false;

	// if the node is a directory, let the other version do the job
	if (Directory* dir = dynamic_cast<Directory*>(descendant))
		return DirectoryContains(directory, dir, reflexive);

	// iterate through the referring entries and check, if the directory
	// contains any of them
	for (Entry* entry = descendant->GetFirstReferringEntry();
		 entry;
		 entry = descendant->GetNextReferringEntry(entry)) {
		if (DirectoryContains(directory, entry))
			return true;
	}

	return false;
}


// #pragma mark -

// ProcessNodeMonitoringEvent
void
VolumeManager::ProcessNodeMonitoringEvent(NodeMonitoringEvent* event)
{
	if (fNodeMonitoringEvents.Push(event) != B_OK)
		delete event;
}

// _AddVolume
status_t
VolumeManager::_AddVolume(dev_t volumeID, Volume** _volume)
{
	if (GetVolume(volumeID))
		return B_OK;

	// create the volume
	Volume* volume = new(std::nothrow) Volume(volumeID);
	if (!volume)
		RETURN_ERROR(B_NO_MEMORY);
	ObjectDeleter<Volume> volumeDeleter(volume);
	status_t error = volume->Init();
	if (error != B_OK)
		RETURN_ERROR(error);

	// add it
	error = fVolumes->Put(volumeID, volume);
	if (error != B_OK)
		RETURN_ERROR(error);

	// add the root node
	error = AddNode(volume->GetRootDirectory());
	if (error != B_OK) {
		fVolumes->Remove(volumeID);
		RETURN_ERROR(error);
	}

	// complete the root dir path
	CompletePathToRoot(volume->GetRootDirectory());

	volumeDeleter.Detach();
	if (_volume)
		*_volume = volume;
	return B_OK;
}

// _EntryCreated
void
VolumeManager::_EntryCreated(EntryCreatedEvent* event)
{
	// get the directory
	Directory* directory = GetDirectory(event->volumeID, event->directoryID);
	if (!directory)
		return;

	// check, if there is an earlier similar event
	bool notify = true;
	NoAllocEntryRef ref(event->volumeID, event->directoryID,
		event->name.GetString());
	EntryCreatedEvent* oldEvent = fEntryCreatedEvents->Get(ref);

	// remove the old event
	if (oldEvent) {
		fEntryCreatedEvents->Remove(ref);
		fRecentNodeMonitoringEvents.Remove(oldEvent);
		notify = !_IsRecentEvent(oldEvent);
		oldEvent->ReleaseReference();
	}

	// add the new event
	if (fEntryCreatedEvents->Put(ref, event) == B_OK) {
		fRecentNodeMonitoringEvents.Insert(event);
		event->AcquireReference();
	}

	// if the directory is complete or at least has iterators attached to it,
	// we load the entry
	if (directory->IsComplete() || directory->HasDirIterators()) {
		Entry* entry;
		LoadEntry(ref.device, ref.directory, ref.name, false, &entry);
	}

	// send notifications
	if (notify) {
		for (ClientVolumeMap::Iterator it = fClientVolumes->GetIterator();
			 it.HasNext();) {
			ClientVolume* clientVolume = it.Next().value;
			if (DirectoryContains(clientVolume->GetRootDirectory(), directory,
				true)) {
				clientVolume->ProcessNodeMonitoringEvent(event);
			}
		}
	}
}

// _EntryRemoved
void
VolumeManager::_EntryRemoved(EntryRemovedEvent* event, bool keepNode)
{
	// get node and directory
	Node* node = GetNode(event->nodeVolumeID, event->nodeID);
	Directory* directory = GetDirectory(event->volumeID, event->directoryID);
	if (!directory)
		return;

	// find the entry
	Entry* entry = NULL;
	if (node) {
		if (event->name.GetLength() == 0) {
			for (entry = node->GetFirstReferringEntry();
				 entry;
				 entry = node->GetNextReferringEntry(entry)) {
				if (!entry->Exists()) {
					event->name.SetTo(entry->GetName());
					break;
				}
			}
		} else {
			entry = GetEntry(directory->GetVolumeID(), directory->GetID(),
				event->name.GetString());
		}
	}

	// check, if there is an earlier similar event
	bool notify = true;
	NoAllocEntryRef ref(event->volumeID, event->directoryID,
		event->name.GetString());
	EntryRemovedEvent* oldEvent = fEntryRemovedEvents->Get(ref);
		// TODO: Under BeOS R5 the entry name is not encoded in the
		// "entry removed" node monitoring message. If we have seen the entry
		// before, we can get the entry nevertheless (see above). Usually we
		// get 2 "entry removed" events: One for watching the directory and one
		// for watching the node. After the first one has been processed, we've
		// forgotten everything about the entry and we won't be able to find out
		// the entry's name for the second one. Hence we will never find the
		// previous event in the fEntryRemovedEvents map. We should probably
		// fall back to using a NodeRef as key under BeOS R5.

	// remove the old event
	if (oldEvent) {
		fEntryRemovedEvents->Remove(ref);
		fRecentNodeMonitoringEvents.Remove(oldEvent);
		notify = !_IsRecentEvent(oldEvent);
		oldEvent->ReleaseReference();
	}

	// add the new event
	if (fEntryRemovedEvents->Put(ref, event) == B_OK) {
		fRecentNodeMonitoringEvents.Insert(event);
		event->AcquireReference();
	}

	// remove the entry
	if (entry) {
		RemoveEntry(entry);
		delete entry;
	}

	// remove the node, if it doesn't have any more actual referring entries
	if (node && !keepNode && !node->GetActualReferringEntry()) {
		RemoveNode(node);
		if (node != node->GetVolume()->GetRootDirectory())
			delete node;
	}

	// send notifications
	if (notify) {
		NodeRef nodeRef(event->nodeVolumeID, event->nodeID);
		for (ClientVolumeMap::Iterator it = fClientVolumes->GetIterator();
			 it.HasNext();) {
			// We send a notification, if the client volume contains the entry,
			// but also, if the removed entry refers to the client volume's
			// root. The client connection has a special handling for this
			// case.
			ClientVolume* clientVolume = it.Next().value;
			Directory* rootDir = clientVolume->GetRootDirectory();
			if (DirectoryContains(rootDir, directory, true)
				|| clientVolume->GetRootNodeRef() == nodeRef) {
				clientVolume->ProcessNodeMonitoringEvent(event);
			}
		}
	}
}

// _EntryMoved
void
VolumeManager::_EntryMoved(EntryMovedEvent* event)
{
	_CheckVolumeRootMoved(event);

	Directory* fromDirectory
		= GetDirectory(event->volumeID, event->fromDirectoryID);
	Directory* toDirectory
		= GetDirectory(event->volumeID, event->toDirectoryID);
	Node* node = GetNode(event->nodeVolumeID, event->nodeID);

	// we should at least have one of the directories
	if (!fromDirectory && !toDirectory)
		return;

	// find the old entry
	Entry* oldEntry = NULL;
	if (node) {
		if (event->fromName.GetLength() == 0) {
			for (oldEntry = node->GetFirstReferringEntry();
				 oldEntry;
				 oldEntry = node->GetNextReferringEntry(oldEntry)) {
				if (!oldEntry->Exists()) {
					event->fromName.SetTo(oldEntry->GetName());
					break;
				}
			}
		} else {
			oldEntry = GetEntry(event->volumeID, event->fromDirectoryID,
				event->fromName.GetString());
		}
	}

	// check, if there is an earlier similar event
	bool notify = true;
	if (event->fromName.GetLength() > 0) {
		EntryMovedEventKey key(event->volumeID, event->fromDirectoryID,
			event->fromName.GetString(), event->toDirectoryID,
			event->toName.GetString());
		EntryMovedEvent* oldEvent = fEntryMovedEvents->Get(key);

		// remove the old event
		if (oldEvent) {
			fEntryMovedEvents->Remove(key);
			fRecentNodeMonitoringEvents.Remove(oldEvent);
			notify = !_IsRecentEvent(oldEvent);
			oldEvent->ReleaseReference();
		}

		// add the new event
		if (fEntryMovedEvents->Put(key, event) == B_OK) {
			fRecentNodeMonitoringEvents.Insert(event);
			event->AcquireReference();
		}
	}

	// remove the old entry
	if (oldEntry) {
		RemoveEntry(oldEntry);
		delete oldEntry;
	}

	// If the to directory is complete or at least has iterators attached to it,
	// we load the new entry. We also load it, if the node is the root of a
	// volume.
	if (toDirectory
		&& (toDirectory->IsComplete() || toDirectory->HasDirIterators()
			|| (node && node == node->GetVolume()->GetRootDirectory()))) {
		Entry* newEntry;
		LoadEntry(event->volumeID, event->toDirectoryID,
			event->toName.GetString(), false, &newEntry);
	}

	// remove the node, if it doesn't have any more actual referring entries
	if (node && !node->GetActualReferringEntry()) {
		RemoveNode(node);
		if (node != node->GetVolume()->GetRootDirectory())
			delete node;
	}

	// send notifications
	if (notify) {
		for (ClientVolumeMap::Iterator it = fClientVolumes->GetIterator();
			 it.HasNext();) {
			ClientVolume* clientVolume = it.Next().value;

			// check, if it contains the from/to directories
			Directory* rootDir = clientVolume->GetRootDirectory();
			bool containsFrom = DirectoryContains(rootDir, fromDirectory, true);
			bool containsTo = DirectoryContains(rootDir, toDirectory, true);

			if (containsFrom) {
				if (containsTo) {
					// contains source and target dir
					clientVolume->ProcessNodeMonitoringEvent(event);
				} else {
					// contains only the source dir: generate an "entry removed"
					// event
					EntryRemovedEvent *removedEvent
						= new(std::nothrow) EntryRemovedEvent;
					if (!removedEvent)
						continue;
					removedEvent->opcode = B_ENTRY_REMOVED;
					removedEvent->time = event->time;
					removedEvent->volumeID = event->volumeID;
					removedEvent->directoryID = event->fromDirectoryID;
					removedEvent->nodeVolumeID = event->nodeVolumeID;
					removedEvent->nodeID = event->nodeID;
					if (event->fromName.GetLength() > 0)
						removedEvent->name = event->fromName;
					clientVolume->ProcessNodeMonitoringEvent(removedEvent);
					removedEvent->ReleaseReference();
				}
			} else if (containsTo) {
				// contains only the target directory: generate an
				// "entry created" event
				EntryCreatedEvent *createdEvent
					= new(std::nothrow) EntryCreatedEvent;
				if (!createdEvent)
					continue;
				createdEvent->opcode = B_ENTRY_CREATED;
				createdEvent->time = event->time;
				createdEvent->volumeID = event->volumeID;
				createdEvent->directoryID = event->toDirectoryID;
				createdEvent->name = event->toName;
				clientVolume->ProcessNodeMonitoringEvent(createdEvent);
				createdEvent->ReleaseReference();
			}
		}
	}
}

// _NodeStatChanged
void
VolumeManager::_NodeStatChanged(StatChangedEvent* event)
{
	// get the node
	Node* node = GetNode(event->volumeID, event->nodeID);
	if (!node)
		return;

	// check, if there is an earlier similar event
	bool notify = true;
	NodeRef ref(event->volumeID, event->nodeID);
	StatChangedEvent* oldEvent = fNodeStatChangedEvents->Get(ref);

	// remove the old event
	if (oldEvent) {
		fNodeStatChangedEvents->Remove(ref);
		fRecentNodeMonitoringEvents.Remove(oldEvent);
		notify = !_IsRecentEvent(oldEvent);
		oldEvent->ReleaseReference();
	}

	// add the new event
	if (fNodeStatChangedEvents->Put(ref, event) == B_OK) {
		fRecentNodeMonitoringEvents.Insert(event);
		event->AcquireReference();
	}

	if (notify) {
		// update the cached node stat
		node->UpdateStat();

		// send notifications
		for (ClientVolumeMap::Iterator it = fClientVolumes->GetIterator();
			 it.HasNext();) {
			ClientVolume* clientVolume = it.Next().value;
			if (DirectoryContains(clientVolume->GetRootDirectory(), node, true))
				clientVolume->ProcessNodeMonitoringEvent(event);
		}
	}
}

// _NodeAttributeChanged
void
VolumeManager::_NodeAttributeChanged(AttributeChangedEvent* event)
{
	// get the node
	Node* node = GetNode(event->volumeID, event->nodeID);
	if (!node)
		return;

	// check, if there is an earlier similar event
	bool notify = true;
	AttributeRef ref(event->volumeID, event->nodeID,
		event->attribute.GetString());
	AttributeChangedEvent* oldEvent = fNodeAttributeChangedEvents->Get(ref);

	// remove the old event
	if (oldEvent) {
		fNodeAttributeChangedEvents->Remove(ref);
		fRecentNodeMonitoringEvents.Remove(oldEvent);
		notify = !_IsRecentEvent(oldEvent);
		oldEvent->ReleaseReference();
	}

	// add the new event
	if (fNodeAttributeChangedEvents->Put(ref, event) == B_OK) {
		fRecentNodeMonitoringEvents.Insert(event);
		event->AcquireReference();
	}

	// send notifications
	if (notify) {
		for (ClientVolumeMap::Iterator it = fClientVolumes->GetIterator();
			 it.HasNext();) {
			ClientVolume* clientVolume = it.Next().value;
			if (DirectoryContains(clientVolume->GetRootDirectory(), node, true))
				clientVolume->ProcessNodeMonitoringEvent(event);
		}
	}
}

// _VolumeMounted
void
VolumeManager::_VolumeMounted(VolumeMountedEvent* event)
{
	entry_ref rootRef;
	bool rootRefInitialized = false;

	// remove the entry referring to the covered directory
	Directory* coveredDirectory = GetDirectory(event->volumeID,
		event->directoryID);
	if (coveredDirectory) {
		if (Entry* entry = coveredDirectory->GetActualReferringEntry()) {
			// get an entry for later
			rootRef = entry->GetEntryRef();
			rootRefInitialized = true;

			// send the "entry removed" event
			EntryRemovedEvent* event;
			if (_GenerateEntryRemovedEvent(entry, system_time(),
					&event) == B_OK) {
				_EntryRemoved(event, true);
				event->ReleaseReference();
			} else {
				RemoveEntry(entry);
				delete entry;
			}
		}
	}

	// add the volume
	_AddVolume(event->newVolumeID);

	// generate an "entry created" event for the root dir entry
	if (rootRefInitialized)
		_GenerateEntryCreatedEvent(rootRef, event->time);
}

// _VolumeUnmounted
void
VolumeManager::_VolumeUnmounted(VolumeUnmountedEvent* event)
{
	// get the volume
	Volume* volume = GetVolume(event->volumeID);
	if (!volume)
		return;

	entry_ref rootRef;
	bool rootRefInitialized = false;

	// remove all actual entries referring to the root directory (should only
	// be one)
	if (Directory* rootDir = volume->GetRootDirectory()) {
		// get an entry ref for the root dir
		if (Entry* entry = rootDir->GetActualReferringEntry()) {
			rootRef = entry->GetEntryRef();
			rootRefInitialized = true;
		}

		Entry* entry = rootDir->GetFirstReferringEntry();
		while (entry) {
			Entry* nextEntry = rootDir->GetNextReferringEntry(entry);

			if (entry->IsActualEntry()) {
				EntryRemovedEvent* removedEvent;
				if (_GenerateEntryRemovedEvent(entry, event->time,
						&removedEvent) == B_OK) {
					_EntryRemoved(removedEvent, true);
					removedEvent->ReleaseReference();
				} else {
					RemoveEntry(entry);
					delete entry;
				}
			}

			entry = nextEntry;
		}
	}

	// remove all entries of the volume
	while (Entry* entry = volume->GetFirstEntry()) {
		bool remove = true;
		if (entry->IsActualEntry()) {
			if (_GenerateEntryRemovedEvent(entry, event->time) != B_OK)
				remove = false;
		}

		if (remove) {
			RemoveEntry(entry);
			delete entry;
		}
	}

	// remove all nodes
	while (Node* node = volume->GetFirstNode()) {
		RemoveNode(node);
		if (node != volume->GetRootDirectory())
			delete node;
	}

	// remove the volume
	fVolumes->Remove(volume->GetID());
	delete volume;

	// generate an "entry created" event for the covered node
	if (rootRefInitialized)
		_GenerateEntryCreatedEvent(rootRef, event->time);
}

// _QueryEntryCreated
void
VolumeManager::_QueryEntryCreated(EntryCreatedEvent* event)
{
	// get the query handler
	QueryHandler* queryHandler
		= dynamic_cast<QueryHandler*>(event->queryHandler);
	if (!queryHandler)
		return;

	// load the entry (just to make sure that it really exists)
	Entry* entry = NULL;
	status_t error = LoadEntry(event->volumeID, event->directoryID,
		event->name.GetString(), true, &entry);
	if (error != B_OK)
		return;

	// get remote port and token
	if (!queryHandler->LockLooper())
		return;

	QueryHandle* queryHandle = queryHandler->GetQueryHandle();
	event->remotePort = queryHandle->GetRemotePort();
	event->remoteToken = queryHandle->GetRemoteToken();
	queryHandler->UnlockLooper();

	// send a notification to the client volume
	queryHandler->GetQueryDomain()->ProcessQueryEvent(event);
}

// _QueryEntryRemoved
void
VolumeManager::_QueryEntryRemoved(EntryRemovedEvent* event)
{
	// get the query handler
	QueryHandler* queryHandler
		= dynamic_cast<QueryHandler*>(event->queryHandler);
	if (!queryHandler)
		return;

	// load the directory (just to make sure that it really exists)
	Directory* directory = NULL;
	status_t error = LoadDirectory(event->volumeID, event->directoryID,
		&directory);
	if (error != B_OK)
		return;

	// get remote port and token
	if (!queryHandler->LockLooper())
		return;
	QueryHandle* queryHandle = queryHandler->GetQueryHandle();
	event->remotePort = queryHandle->GetRemotePort();
	event->remoteToken = queryHandle->GetRemoteToken();
	queryHandler->UnlockLooper();

	// send a notification to the client volume
	queryHandler->GetQueryDomain()->ProcessQueryEvent(event);
}

// _QueryEntryMoved
void
VolumeManager::_QueryEntryMoved(EntryMovedEvent* event)
{
	// we simply split the event into a `removed' and a `created' event

	// allocate the events
	EntryRemovedEvent* removedEvent = new(std::nothrow) EntryRemovedEvent;
	EntryCreatedEvent* createdEvent = new(std::nothrow) EntryCreatedEvent;
	if (!removedEvent || !createdEvent) {
		delete removedEvent;
		delete createdEvent;
		return;
	}

	// init the removed event
	removedEvent->opcode = B_ENTRY_REMOVED;
	removedEvent->time = event->time;
	removedEvent->queryHandler = event->queryHandler;
	removedEvent->queryHandler->AcquireReference();
	removedEvent->volumeID = event->volumeID;
	removedEvent->directoryID = event->fromDirectoryID;
	removedEvent->nodeVolumeID = event->volumeID;
	removedEvent->nodeID = event->nodeID;
	removedEvent->name = event->fromName;

	// init the created event
	createdEvent->opcode = B_ENTRY_CREATED;
	createdEvent->time = event->time;
	createdEvent->queryHandler = event->queryHandler;
	createdEvent->queryHandler->AcquireReference();
	createdEvent->volumeID = event->volumeID;
	createdEvent->directoryID = event->toDirectoryID;
	createdEvent->nodeID = event->nodeID;
	createdEvent->name = event->toName;

	// send them
	_QueryEntryRemoved(removedEvent);
	removedEvent->ReleaseReference();
	_QueryEntryCreated(createdEvent);
	createdEvent->ReleaseReference();
}

// _IsRecentEvent
bool
VolumeManager::_IsRecentEvent(NodeMonitoringEvent* event) const
{
	return (event && system_time() < event->time + kRecentEventLifeTime);
}

// _GenerateEntryCreatedEvent
status_t
VolumeManager::_GenerateEntryCreatedEvent(const entry_ref& ref, bigtime_t time,
	EntryCreatedEvent** _event)
{
	// load the entry
	Entry* entry;
	status_t error = LoadEntry(ref.device, ref.directory, ref.name, true,
		&entry);
	if (error != B_OK)
		return error;

	// create the event
	EntryCreatedEvent* event = new(std::nothrow) EntryCreatedEvent;
	if (!event)
		return B_NO_MEMORY;

	// fill in the fields
	event->opcode = B_ENTRY_CREATED;
	event->time = time;
	event->volumeID = entry->GetVolumeID();
	event->directoryID = entry->GetDirectoryID();
	event->nodeID = entry->GetNode()->GetID();
	event->name.SetTo(entry->GetName());

	if (_event) {
		*_event = event;
	} else {
		_EntryCreated(event);
		event->ReleaseReference();
	}

	return B_OK;
}

// _GenerateEntryRemovedEvent
status_t
VolumeManager::_GenerateEntryRemovedEvent(Entry* entry, bigtime_t time,
	EntryRemovedEvent** _event)
{
	if (!entry)
		return B_BAD_VALUE;

	// create the event
	EntryRemovedEvent* event = new(std::nothrow) EntryRemovedEvent;
	if (!event)
		return B_NO_MEMORY;

	// fill in the fields
	event->opcode = B_ENTRY_REMOVED;
	event->time = time;
	event->volumeID = entry->GetVolumeID();
	event->directoryID = entry->GetDirectoryID();
	event->nodeVolumeID = entry->GetNode()->GetVolumeID();
	event->nodeID = entry->GetNode()->GetID();
	event->name.SetTo(entry->GetName());

	if (_event) {
		*_event = event;
	} else {
		_EntryRemoved(event, false);
		event->ReleaseReference();
	}

	return B_OK;
}

// _CheckVolumeRootMoved
void
VolumeManager::_CheckVolumeRootMoved(EntryMovedEvent* event)
{
	// If a volume root is moved, the sent node monitoring message does
	// unforunately contain the node_ref of the covered node, not that of the
	// volume root -- a BeOS R5 VFS bug. Since we have the entry_ref of the
	// new entry, we can stat the node.

	// check whether the node is the root of a volume
	NoAllocEntryRef ref(event->volumeID, event->toDirectoryID,
		event->toName.GetString());
	BEntry entry;
	struct stat st;
	if (FDManager::SetEntry(&entry, &ref) == B_OK
		&& entry.GetStat(&st) == B_OK) {
		event->nodeVolumeID = st.st_dev;
		event->nodeID = st.st_ino;
		if (Volume* volume = GetVolume(st.st_dev)) {
			if (volume->GetRootID() == st.st_ino) {
				PRINT("Mount point for volume %" B_PRIdDEV " renamed\n",
					volume->GetID());
			}
		}
	}
}

// _NodeMonitoringProcessorEntry
int32
VolumeManager::_NodeMonitoringProcessorEntry(void* data)
{
	return ((VolumeManager*)data)->_NodeMonitoringProcessor();
}

// _NodeMonitoryProcessor
int32
VolumeManager::_NodeMonitoringProcessor()
{
	do {
		NodeMonitoringEvent* event = NULL;
		status_t error = fNodeMonitoringEvents.Pop(&event);

		VolumeManagerLocker managerLocker;

		while (error == B_OK) {
			if (event->queryHandler) {
				switch (event->opcode) {
					case B_ENTRY_CREATED:
						_QueryEntryCreated(
							dynamic_cast<EntryCreatedEvent*>(event));
						break;
					case B_ENTRY_REMOVED:
						_QueryEntryRemoved(
							dynamic_cast<EntryRemovedEvent*>(event));
						break;
					case B_ENTRY_MOVED:
						_QueryEntryMoved(dynamic_cast<EntryMovedEvent*>(event));
						break;
				}
			} else {
				switch (event->opcode) {
					case B_ENTRY_CREATED:
						_EntryCreated(dynamic_cast<EntryCreatedEvent*>(event));
						break;
					case B_ENTRY_REMOVED:
						_EntryRemoved(dynamic_cast<EntryRemovedEvent*>(event),
							false);
						break;
					case B_ENTRY_MOVED:
						_EntryMoved(dynamic_cast<EntryMovedEvent*>(event));
						break;
					case B_STAT_CHANGED:
						_NodeStatChanged(
							dynamic_cast<StatChangedEvent*>(event));
						break;
					case B_ATTR_CHANGED:
						_NodeAttributeChanged(
							dynamic_cast<AttributeChangedEvent*>(event));
						break;
					case B_DEVICE_MOUNTED:
						_VolumeMounted(dynamic_cast<VolumeMountedEvent*>(event));
						break;
					case B_DEVICE_UNMOUNTED:
						_VolumeUnmounted(
							dynamic_cast<VolumeUnmountedEvent*>(event));
						break;
				}
			}
			event->ReleaseReference();

			// If there is another event available, get it as long as we
			// have the VolumeManager lock.
			error = fNodeMonitoringEvents.Pop(&event, 0);
		}
	} while (!fTerminating);

	return 0;
}


// sManager
VolumeManager* VolumeManager::sManager = NULL;