haiku.git

/*
 * Copyright 2001-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include "UserlandFS.h"

#include <KernelExport.h>

#include "Compatibility.h"
#include "Debug.h"
#include "FileSystem.h"
#include "FileSystemInitializer.h"
#include "KernelDebug.h"
#include "RequestPort.h"
#include "Requests.h"
#include "UserlandFSDefs.h"


UserlandFS* UserlandFS::sUserlandFS = NULL;

// constructor
UserlandFS::UserlandFS()
	:
	fFileSystems(NULL),
	fDebuggerCommandsAdded(false)
{
}

// destructor
UserlandFS::~UserlandFS()
{
PRINT(("UserlandFS::~UserlandFS()\n"))
	delete fFileSystems;
	if (fDebuggerCommandsAdded)
		KernelDebug::RemoveDebuggerCommands();
}

// InitUserlandFS
status_t
UserlandFS::InitUserlandFS(UserlandFS** _userlandFS)
{
	// create the singleton instance
	sUserlandFS = new(nothrow) UserlandFS;
	if (!sUserlandFS)
		return B_NO_MEMORY;

	// init the thing
	status_t error = sUserlandFS->_Init();
	if (error != B_OK) {
		delete sUserlandFS;
		sUserlandFS = NULL;
		return error;
	}

	*_userlandFS = sUserlandFS;

	return B_OK;
}

// UninitUserlandFS
void
UserlandFS::UninitUserlandFS()
{
	delete sUserlandFS;
	sUserlandFS = NULL;
}

// GetUserlandFS
UserlandFS*
UserlandFS::GetUserlandFS()
{
	return sUserlandFS;
}

// RegisterFileSystem
status_t
UserlandFS::RegisterFileSystem(const char* name, FileSystem** _fileSystem)
{
	// check parameters
	if (!name || !_fileSystem)
		return B_BAD_VALUE;

	// check, if we do already know this file system, and create it, if not
	FileSystemInitializer* fileSystemInitializer;
	{
		FileSystemLocker _(fFileSystems);
		fileSystemInitializer = fFileSystems->Get(name);
		if (fileSystemInitializer) {
			fileSystemInitializer->AcquireReference();
		} else {
			fileSystemInitializer = new(nothrow) FileSystemInitializer(name);
			if (!fileSystemInitializer)
				return B_NO_MEMORY;

			status_t error = fFileSystems->Put(name, fileSystemInitializer);
			if (error != B_OK) {
				delete fileSystemInitializer;
				return error;
			}
		}
	}

	// prepare the file system
	status_t error = fileSystemInitializer->Access();
	if (error != B_OK) {
		_UnregisterFileSystem(name);
		return error;
	}

	*_fileSystem = fileSystemInitializer->GetFileSystem();
	return error;
}

// UnregisterFileSystem
status_t
UserlandFS::UnregisterFileSystem(FileSystem* fileSystem)
{
	if (!fileSystem)
		return B_BAD_VALUE;

	return _UnregisterFileSystem(fileSystem->GetName());
}

// CountFileSystems
int32
UserlandFS::CountFileSystems() const
{
	return fFileSystems->Size();
}

// _Init
status_t
UserlandFS::_Init()
{
	// add debugger commands
	KernelDebug::AddDebuggerCommands();
	fDebuggerCommandsAdded = true;

	// create file system map
	fFileSystems = new(nothrow) FileSystemMap;
	if (!fFileSystems)
		RETURN_ERROR(B_NO_MEMORY);
	status_t error = fFileSystems->InitCheck();
	if (error != B_OK)
		RETURN_ERROR(error);

	return B_OK;
}

// _UnregisterFileSystem
status_t
UserlandFS::_UnregisterFileSystem(const char* name)
{
	if (!name)
		return B_BAD_VALUE;

	// find the FS and decrement its reference counter
	FileSystemInitializer* fileSystemInitializer = NULL;
	bool deleteFS = false;
	{
		FileSystemLocker _(fFileSystems);
		fileSystemInitializer = fFileSystems->Get(name);
		if (!fileSystemInitializer)
			return B_BAD_VALUE;

		deleteFS = fileSystemInitializer->ReleaseReference() == 1;
		if (deleteFS)
			fFileSystems->Remove(name);
	}

	// delete the FS, if the last reference has been removed
	if (deleteFS)
		delete fileSystemInitializer;
	return B_OK;
}