haiku.git

// VirtualVolume.cpp

#include <new>
#include <stdio.h>
#include <string.h>

#include <AutoLocker.h>

#include "Compatibility.h"
#include "DebugSupport.h"
#include "QueryIterator.h"
#include "QueryManager.h"
#include "VirtualDir.h"
#include "VirtualVolume.h"
#include "VolumeManager.h"
#include "VolumeSupport.h"

// constructor
VirtualVolume::VirtualVolume(VolumeManager* volumeManager)
	: Volume(volumeManager),
	  fRootNode(NULL)
{
}

// destructor
VirtualVolume::~VirtualVolume()
{
	delete fRootNode;
}

// Init
status_t
VirtualVolume::Init(const char* name)
{
	status_t error = Volume::Init(name);
	if (error != B_OK)
		return error;

	// get an ID for the root node
	vnode_id rootNodeID = fVolumeManager->NewNodeID(this);
	if (rootNodeID < 0) {
		Uninit();
		return rootNodeID;
	}

	// create the root node
	fRootNode = new(std::nothrow) VirtualDir(this, rootNodeID);
	if (!fRootNode) {
		Uninit();
		fVolumeManager->RemoveNodeID(rootNodeID);
		return B_NO_MEMORY;
	}
	error = fRootNode->InitCheck();
	if (error != B_OK) {
		Uninit();
		return error;
	}

	return B_OK;
}

// Uninit
void
VirtualVolume::Uninit()
{
	if (fRootNode) {
		fVolumeManager->RemoveNodeID(fRootNode->GetID());
		delete fRootNode;
		fRootNode = NULL;
	}

	Volume::Uninit();
}

// GetRootNode
Node*
VirtualVolume::GetRootNode() const
{
	return fRootNode;
}

// PrepareToUnmount
void
VirtualVolume::PrepareToUnmount()
{
	Volume::PrepareToUnmount();

	// remove all child volumes

	// init a directory iterator
	fLock.Lock();
	VirtualDirIterator iterator;
	iterator.SetDirectory(fRootNode, true);

	// iterate through the directory
	const char* name;
	Node* node;
	while (iterator.GetCurrentEntry(&name, &node)) {
		iterator.NextEntry();
		Volume* volume = fVolumeManager->GetVolume(node->GetID());
		fLock.Unlock();
		if (volume) {
			RemoveChildVolume(volume);
			volume->SetUnmounting(true);
			volume->PutVolume();
		}
		fLock.Lock();
	}

	// uninit the directory iterator
	iterator.SetDirectory(NULL);

	// remove the our root node
	vnode_id rootNodeID = fRootNode->GetID();

	fLock.Unlock();

	if (GetVNode(rootNodeID, &node) == B_OK) {
		Volume::RemoveVNode(rootNodeID);
		PutVNode(rootNodeID);
	}
}

// AddChildVolume
status_t
VirtualVolume::AddChildVolume(Volume* volume)
{
	if (!volume)
		return B_BAD_VALUE;

	// don't add anything, if we are already unmounting
	AutoLocker<Locker> locker(fLock);
	if (fUnmounting)
		return B_BAD_VALUE;

	// get and check the node name
	char name[B_FILE_NAME_LENGTH];
	int32 nameLen = strlen(volume->GetName());
	if (nameLen == 0 || nameLen >= B_FILE_NAME_LENGTH)
		return B_BAD_VALUE;
	strcpy(name, volume->GetName());

	// add the volume's root node
	status_t error = fRootNode->AddEntry(name, volume->GetRootNode());
	if (error != B_OK)
		return error;

	// set the volume's parent volume
	volume->SetParentVolume(this);
	AcquireReference();

	// send out a notification
	vnode_id dirID = fRootNode->GetID();
	vnode_id nodeID = volume->GetRootID();
	locker.Unlock();
	NotifyListener(B_ENTRY_CREATED, fVolumeManager->GetID(), dirID, 0, nodeID,
		name);

	return B_OK;
}

// RemoveChildVolume
void
VirtualVolume::RemoveChildVolume(Volume* volume)
{
	if (!volume)
		return;

	// check, if the volume's root node is a child of our root node
	AutoLocker<Locker> locker(fLock);
	Node* node = fRootNode->GetChildNode(volume->GetName());
	if (!node)
		return;
	if (node != volume->GetRootNode())
		return;

	// remove it
	fRootNode->RemoveEntry(volume->GetName());
	volume->SetParentVolume(NULL);

	// get the data needed for the node monitoring notification
	vnode_id dirID = fRootNode->GetID();
	vnode_id nodeID = volume->GetRootID();
	char name[B_FILE_NAME_LENGTH];
	strcpy(name, volume->GetName());

	// surrender the child volumes reference to us
	// Since the caller of this method must have a valid reference to us,
	// this is unproblematic, even if fLock is being held, while this method
	// is invoked.
	locker.Unlock();
	PutVolume();

	// send out a notification
	locker.Unlock();
	NotifyListener(B_ENTRY_REMOVED, fVolumeManager->GetID(), dirID, 0, nodeID,
		name);
}

// GetChildVolume
Volume*
VirtualVolume::GetChildVolume(const char* name)
{
	if (!name)
		return NULL;

	// get the child node of the root node
	AutoLocker<Locker> locker(fLock);
	Node* node = fRootNode->GetChildNode(name);
	if (!node)
		return NULL;

	// get its volume, if it is the root volume
	Volume* volume = node->GetVolume();
	if (volume->GetRootNode() != node)
		return NULL;
	locker.Unlock();

	return fVolumeManager->GetVolume(node->GetID());
}

// GetUniqueEntryName
status_t
VirtualVolume::GetUniqueEntryName(const char* baseName, char* buffer)
{
	if (!baseName || !buffer)
		return B_BAD_VALUE;

	// check the base name len
	int32 baseLen = strlen(baseName);
	if (baseLen == 0 || baseLen >= B_FILE_NAME_LENGTH)
		return B_BAD_VALUE;

	strcpy(buffer, baseName);

	AutoLocker<Locker> _(fLock);

	// adjust the name, if necessary
	int32 suffixNumber = 2;
	while (fRootNode->GetChildNode(baseName)) {
		// create a suffix
		char suffix[13];
		sprintf(suffix, " %" B_PRId32, suffixNumber);
		suffixNumber++;

		// check the len
		int32 suffixLen = strlen(suffix);
		if (baseLen + suffixLen >= B_FILE_NAME_LENGTH)
			return B_NAME_TOO_LONG;

		// compose the final name
		strcpy(buffer + baseLen, suffix);
	}

	return B_OK;
}


// #pragma mark -
// #pragma mark ----- FS -----

// Unmount
status_t
VirtualVolume::Unmount()
{
	return B_OK;
}

// Sync
status_t
VirtualVolume::Sync()
{
// TODO: Recursively call Sync().
	return B_BAD_VALUE;
}


// #pragma mark -
// #pragma mark ----- vnodes -----

// ReadVNode
status_t
VirtualVolume::ReadVNode(vnode_id vnid, char reenter, Node** node)
{
	if (vnid != GetRootID())
		return B_BAD_VALUE;

	AutoLocker<Locker> _(fLock);
	fRootNode->SetKnownToVFS(true);
	*node = fRootNode;

	// add a volume reference for the node
	AcquireReference();

	return B_OK;
}

// WriteVNode
status_t
VirtualVolume::WriteVNode(Node* node, char reenter)
{
	if (node != fRootNode)
		return B_BAD_VALUE;

	AutoLocker<Locker> locker(fLock);
	fRootNode->SetKnownToVFS(false);

	// surrender the volume reference of the node
	locker.Unlock();
	PutVolume();

	return B_OK;
}

// RemoveVNode
status_t
VirtualVolume::RemoveVNode(Node* node, char reenter)
{
	if (node != fRootNode)
		return B_BAD_VALUE;

	AutoLocker<Locker> locker(fLock);
	fRootNode->SetKnownToVFS(false);

	// surrender the volume reference of the node
	locker.Unlock();
	PutVolume();

	return B_OK;
}

// #pragma mark -
// #pragma mark ----- nodes -----

// FSync
status_t
VirtualVolume::FSync(Node* node)
{
	return B_OK;
}

// ReadStat
status_t
VirtualVolume::ReadStat(Node* node, struct stat* st)
{
	if (node != fRootNode)
		return B_BAD_VALUE;

	AutoLocker<Locker> _(fLock);
	st->st_ino = node->GetID();
	st->st_mode = S_IFDIR | S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH
		| S_IXOTH;
	st->st_nlink = 1;
	st->st_size = 1;
	st->st_blksize = 1024;
	st->st_crtime = fRootNode->GetCreationTime();
	st->st_ctime = st->st_mtime = st->st_atime = st->st_crtime;
	st->st_dev = fVolumeManager->GetID();
	// we set the UID/GID fields to the one who mounted the FS
	st->st_uid = fVolumeManager->GetMountUID();
	st->st_gid = fVolumeManager->GetMountGID();
	return B_OK;
}

// WriteStat
status_t
VirtualVolume::WriteStat(Node* node, struct stat *st, uint32 mask)
{
	return B_NOT_ALLOWED;
}

// Access
status_t
VirtualVolume::Access(Node* node, int mode)
{
	// TODO: Implement!
	return B_OK;
}

// #pragma mark -
// #pragma mark ----- files -----

// Create
status_t
VirtualVolume::Create(Node* dir, const char* name, int openMode, int mode,
	vnode_id* vnid, void** cookie)
{
	return B_NOT_ALLOWED;
}

// Open
status_t
VirtualVolume::Open(Node* node, int openMode, void** cookie)
{
	if (node != fRootNode)
		return B_BAD_VALUE;

	// we're read-only
	if ((openMode & O_RWMASK) == O_WRONLY)
		return B_PERMISSION_DENIED;
	if (openMode & O_TRUNC)
		return B_PERMISSION_DENIED;
	if ((openMode & O_RWMASK) == O_RDWR)
		openMode = (openMode & ~O_RWMASK) | O_RDONLY;

	// set the result
	*cookie = NULL;
	return B_OK;
}

// Close
status_t
VirtualVolume::Close(Node* node, void* cookie)
{
	// no-op: FreeCookie() does the job
	return B_OK;
}

// FreeCookie
status_t
VirtualVolume::FreeCookie(Node* node, void* cookie)
{
	// nothing to do: we didn't allocate anything
	return B_OK;
}

// Read
status_t
VirtualVolume::Read(Node* node, void* cookie, off_t pos, void* _buffer,
	size_t bufferSize, size_t* _bytesRead)
{
	// can't read() directories
	return B_NOT_ALLOWED;
}

// Write
status_t
VirtualVolume::Write(Node* node, void* cookie, off_t pos, const void* _buffer,
	size_t bufferSize, size_t* bytesWritten)
{
	// can't write() directories
	return B_NOT_ALLOWED;
}

// IOCtl
status_t
VirtualVolume::IOCtl(Node* node, void* cookie, int cmd, void* buffer,
	size_t bufferSize)
{
	return B_BAD_VALUE;
}

// SetFlags
status_t
VirtualVolume::SetFlags(Node* node, void* cookie, int flags)
{
	return B_BAD_VALUE;
}

// #pragma mark -
// #pragma mark ----- hard links / symlinks -----

// Link
status_t
VirtualVolume::Link(Node* dir, const char* name, Node* node)
{
	// we're read-only
	return B_NOT_ALLOWED;
}

// Unlink
status_t
VirtualVolume::Unlink(Node* dir, const char* name)
{
	// we're read-only
	return B_NOT_ALLOWED;
}

// Symlink
status_t
VirtualVolume::Symlink(Node* dir, const char* name, const char* target)
{
	// we're read-only
	return B_NOT_ALLOWED;
}

// ReadLink
status_t
VirtualVolume::ReadLink(Node* node, char* buffer, size_t bufferSize,
	size_t* bytesRead)
{
	// there are no symlinks
	return B_BAD_VALUE;
}

// Rename
status_t
VirtualVolume::Rename(Node* oldDir, const char* oldName, Node* newDir,
	const char* newName)
{
	// we're read-only
	return B_NOT_ALLOWED;
}

// #pragma mark -
// #pragma mark ----- directories -----

// MkDir
status_t
VirtualVolume::MkDir(Node* dir, const char* name, int mode)
{
	// we're read-only
	return B_NOT_ALLOWED;
}

// RmDir
status_t
VirtualVolume::RmDir(Node* dir, const char* name)
{
	// we're read-only
	return B_NOT_ALLOWED;
}

// OpenDir
status_t
VirtualVolume::OpenDir(Node* node, void** cookie)
{
	if (node != fRootNode)
		return B_BAD_VALUE;

	// allocate an iterator
	VirtualDirIterator* iterator = new(std::nothrow) VirtualDirIterator;
	if (!iterator)
		return B_NO_MEMORY;

	AutoLocker<Locker> locker(fLock);
	iterator->SetDirectory(fRootNode);
	*cookie = iterator;
	return B_OK;
}

// CloseDir
status_t
VirtualVolume::CloseDir(Node* node, void* cookie)
{
	// no-op: FreeDirCookie() does the job
	return B_OK;
}

// FreeDirCookie
status_t
VirtualVolume::FreeDirCookie(Node* node, void* cookie)
{
	if (node != fRootNode)
		return B_BAD_VALUE;

	// delete the iterator
	AutoLocker<Locker> locker(fLock);
	VirtualDirIterator* iterator = (VirtualDirIterator*)cookie;
	delete iterator;
	return B_OK;
}

// ReadDir
status_t
VirtualVolume::ReadDir(Node* node, void* cookie, struct dirent* buffer,
	size_t bufferSize, int32 count, int32* countRead)
{
	if (node != fRootNode)
		return B_BAD_VALUE;

	*countRead = 0;

	AutoLocker<Locker> locker(fLock);
	VirtualDirIterator* iterator = (VirtualDirIterator*)cookie;

	// get the current entry
	const char* name;
	Node* child;
	if (!iterator->GetCurrentEntry(&name, &child))
		return B_OK;

	// set the name: this also checks the size of the buffer
	status_t error = set_dirent_name(buffer, bufferSize, name, strlen(name));
	if (error != B_OK)
		RETURN_ERROR(error);

	// fill in the other fields
	buffer->d_pdev = fVolumeManager->GetID();
	buffer->d_pino = fRootNode->GetID();
	buffer->d_dev = fVolumeManager->GetID();
	buffer->d_ino = child->GetID();
	*countRead = 1;

	// fix d_ino, if this is the parent of the root node
	if (strcmp(name, "..") == 0) {
		if (Volume* parentVolume = GetParentVolume())
			buffer->d_ino = parentVolume->GetRootID();
	}

	iterator->NextEntry();
	return B_OK;
}

// RewindDir
status_t
VirtualVolume::RewindDir(Node* node, void* cookie)
{
	if (node != fRootNode)
		return B_BAD_VALUE;

	AutoLocker<Locker> locker(fLock);
	VirtualDirIterator* iterator = (VirtualDirIterator*)cookie;
	iterator->Rewind();

	return B_OK;
}

// Walk
status_t
VirtualVolume::Walk(Node* dir, const char* entryName, char** resolvedPath,
	vnode_id* vnid)
{
	if (dir != fRootNode)
		return B_BAD_VALUE;

	// get the referred to node ID
	AutoLocker<Locker> locker(fLock);
	if (strcmp(entryName, ".") == 0) {
		*vnid = dir->GetID();
	} else if (strcmp(entryName, "..") == 0) {
		if (Volume* parentVolume = GetParentVolume())
			*vnid = parentVolume->GetRootID();
		else
			*vnid = dir->GetID();
	} else {
		Node* node = fRootNode->GetChildNode(entryName);
		if (!node)
			return B_ENTRY_NOT_FOUND;
		*vnid = node->GetID();
	}
	locker.Unlock();

	// get a VFS node reference
	Node* dummyNode;
	status_t error = GetVNode(*vnid, &dummyNode);
	if (error != B_OK)
		return error;
	return B_OK;
}

// #pragma mark -
// #pragma mark ----- attributes -----

// OpenAttrDir
status_t
VirtualVolume::OpenAttrDir(Node* node, void** cookie)
{
	if (node != fRootNode)
		return B_BAD_VALUE;

	// we support no attributes at this time
	*cookie = NULL;
	return B_OK;
}

// CloseAttrDir
status_t
VirtualVolume::CloseAttrDir(Node* node, void* cookie)
{
	// no-op: FreeAttrDirCookie() does the job
	return B_OK;
}

// FreeAttrDirCookie
status_t
VirtualVolume::FreeAttrDirCookie(Node* node, void* _cookie)
{
	// nothing to do: we didn't allocate anything
	return B_OK;
}

// ReadAttrDir
status_t
VirtualVolume::ReadAttrDir(Node* node, void* _cookie, struct dirent* buffer,
	size_t bufferSize, int32 count, int32* countRead)
{
	// no attributes for the time being
	*countRead = 0;
	return B_OK;
}

// RewindAttrDir
status_t
VirtualVolume::RewindAttrDir(Node* node, void* _cookie)
{
	return B_OK;
}

// ReadAttr
status_t
VirtualVolume::ReadAttr(Node* node, const char* name, int type, off_t pos,
	void* _buffer, size_t bufferSize, size_t* bytesRead)
{
	// no attributes for the time being
	*bytesRead = 0;
	return B_ENTRY_NOT_FOUND;
}

// WriteAttr
status_t
VirtualVolume::WriteAttr(Node* node, const char* name, int type, off_t pos,
	const void* _buffer, size_t bufferSize, size_t* bytesWritten)
{
	// no attributes for the time being
	*bytesWritten = 0;
	return B_NOT_ALLOWED;
}

// RemoveAttr
status_t
VirtualVolume::RemoveAttr(Node* node, const char* name)
{
	return B_NOT_ALLOWED;
}

// RenameAttr
status_t
VirtualVolume::RenameAttr(Node* node, const char* oldName, const char* newName)
{
	// no attributes for the time being
	return B_ENTRY_NOT_FOUND;
}

// StatAttr
status_t
VirtualVolume::StatAttr(Node* node, const char* name, struct attr_info* attrInfo)
{
	// no attributes for the time being
	return B_ENTRY_NOT_FOUND;
}

// #pragma mark -
// #pragma mark ----- queries -----

// OpenQuery
status_t
VirtualVolume::OpenQuery(const char* queryString, uint32 flags, port_id port,
	int32 token, QueryIterator** _iterator)
{
	QueryManager* queryManager = fVolumeManager->GetQueryManager();

	// allocate a hierarchical iterator
	HierarchicalQueryIterator* iterator
		= new(std::nothrow) HierarchicalQueryIterator(this);
	if (!iterator)
		return B_NO_MEMORY;

	// add it to the query manager
	status_t error = queryManager->AddIterator(iterator);
	if (error != B_OK) {
		delete iterator;
		return error;
	}
	QueryIteratorPutter iteratorPutter(queryManager, iterator);

	// iterate through the child volumes and open subqueries for them
	// init a directory iterator
	fLock.Lock();
	VirtualDirIterator dirIterator;
	dirIterator.SetDirectory(fRootNode, true);

	// iterate through the directory
	const char* name;
	Node* node;
	while (dirIterator.GetCurrentEntry(&name, &node)) {
		dirIterator.NextEntry();
		Volume* volume = fVolumeManager->GetVolume(node->GetID());
		fLock.Unlock();

		// open the subquery
		QueryIterator* subIterator;
		if (volume->OpenQuery(queryString, flags, port, token,
			&subIterator) == B_OK) {
			// add the subiterator
			if (queryManager->AddSubIterator(iterator, subIterator) != B_OK)
				queryManager->PutIterator(subIterator);
		}
		volume->PutVolume();

		fLock.Lock();
	}

	// uninit the directory iterator
	dirIterator.SetDirectory(NULL);
	fLock.Unlock();

	// return the result
	*_iterator = iterator;
	iteratorPutter.Detach();

	return B_OK;
}

// FreeQueryIterator
void
VirtualVolume::FreeQueryIterator(QueryIterator* iterator)
{
	delete iterator;
}

// ReadQuery
status_t
VirtualVolume::ReadQuery(QueryIterator* _iterator, struct dirent* buffer,
	size_t bufferSize, int32 count, int32* countRead)
{
	HierarchicalQueryIterator* iterator
		= dynamic_cast<HierarchicalQueryIterator*>(_iterator);

	QueryManager* queryManager = fVolumeManager->GetQueryManager();
	while (QueryIterator* subIterator
			= queryManager->GetCurrentSubIterator(iterator)) {
		QueryIteratorPutter _(queryManager, subIterator);

		status_t error = subIterator->GetVolume()->ReadQuery(subIterator,
			buffer, bufferSize, count, countRead);
		if (error != B_OK)
			return error;

		if (*countRead > 0)
			return B_OK;

		queryManager->NextSubIterator(iterator, subIterator);
	}

	*countRead = 0;
	return B_OK;
}