haiku.git

// BeOSKernelFileSystem.cpp

#include "BeOSKernelFileSystem.h"

#include <new>

#include "beos_kernel_emu.h"
#include "BeOSKernelVolume.h"
#include "fs_cache.h"
#include "fs_interface.h"


static const int32 kMaxBlockCacheBlocks = 16384;


// constructor
BeOSKernelFileSystem::BeOSKernelFileSystem(const char* fsName,
	beos_vnode_ops* fsOps)
	:
	FileSystem(fsName),
	fFSOps(fsOps),
	fBlockCacheInitialized(false)
{
	_InitCapabilities();
}


// destructor
BeOSKernelFileSystem::~BeOSKernelFileSystem()
{
	if (fBlockCacheInitialized)
		beos_shutdown_block_cache();
}


// Init
status_t
BeOSKernelFileSystem::Init()
{
	// init the block cache
	status_t error = beos_init_block_cache(kMaxBlockCacheBlocks, 0);
	if (error != B_OK)
		RETURN_ERROR(error);

	fBlockCacheInitialized = true;
	return B_OK;
}


// CreateVolume
status_t
BeOSKernelFileSystem::CreateVolume(Volume** volume, dev_t id)
{
	// check initialization and parameters
	if (!fFSOps || !volume)
		return B_BAD_VALUE;

	// create the volume
	*volume = new(std::nothrow) BeOSKernelVolume(this, id, fFSOps,
		fVolumeCapabilities);
	if (!*volume)
		return B_NO_MEMORY;
	return B_OK;
}

// DeleteVolume
status_t
BeOSKernelFileSystem::DeleteVolume(Volume* volume)
{
	if (!volume || !dynamic_cast<BeOSKernelVolume*>(volume))
		return B_BAD_VALUE;
	delete volume;
	return B_OK;
}

// _InitCapabilities
void
BeOSKernelFileSystem::_InitCapabilities()
{
	fCapabilities.ClearAll();
	fVolumeCapabilities.ClearAll();
	fNodeCapabilities.ClearAll();

	// FS interface type
	fClientFSType = CLIENT_FS_BEOS_KERNEL;

	// FS operations
	fCapabilities.Set(FS_CAPABILITY_MOUNT, fFSOps->mount);


	// Volume operations
	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_UNMOUNT, fFSOps->unmount);

	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_READ_FS_INFO, fFSOps->rfsstat);
	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_WRITE_FS_INFO,
		fFSOps->wfsstat);
	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_SYNC, fFSOps->sync);

	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_GET_VNODE, fFSOps->read_vnode);

	// index directory & index operations
	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_OPEN_INDEX_DIR,
		fFSOps->open_indexdir);
	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_CLOSE_INDEX_DIR,
		fFSOps->close_indexdir);
	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_FREE_INDEX_DIR_COOKIE,
		fFSOps->free_indexdircookie);
	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_READ_INDEX_DIR,
		fFSOps->read_indexdir);
	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_REWIND_INDEX_DIR,
		fFSOps->rewind_indexdir);

	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_CREATE_INDEX,
		fFSOps->create_index);
	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_REMOVE_INDEX,
		fFSOps->remove_index);
	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_READ_INDEX_STAT,
		fFSOps->stat_index);

	// query operations
	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_OPEN_QUERY,
		fFSOps->open_query);
	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_CLOSE_QUERY,
		fFSOps->close_query);
	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_FREE_QUERY_COOKIE,
		fFSOps->free_querycookie);
	fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_READ_QUERY,
		fFSOps->read_query);
	// missing: FS_VOLUME_CAPABILITY_REWIND_QUERY,

	// vnode operations
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_LOOKUP, fFSOps->walk);
	// missing: FS_VNODE_CAPABILITY_GET_VNODE_NAME,

	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_PUT_VNODE, fFSOps->write_vnode);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_REMOVE_VNODE,
		fFSOps->remove_vnode);

	// VM file access
	// missing: FS_VNODE_CAPABILITY_CAN_PAGE,
	// missing: FS_VNODE_CAPABILITY_READ_PAGES,
	// missing: FS_VNODE_CAPABILITY_WRITE_PAGES,

	// cache file access
	// missing: FS_VNODE_CAPABILITY_GET_FILE_MAP,

	// common operations
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_IOCTL, fFSOps->ioctl);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_SET_FLAGS, fFSOps->setflags);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_SELECT, fFSOps->select);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_DESELECT, fFSOps->deselect);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_FSYNC, fFSOps->fsync);

	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_SYMLINK, fFSOps->readlink);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CREATE_SYMLINK, fFSOps->symlink);

	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_LINK, fFSOps->link);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_UNLINK, fFSOps->unlink);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_RENAME, fFSOps->rename);

	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_ACCESS, fFSOps->access);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_STAT, fFSOps->rstat);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_WRITE_STAT, fFSOps->wstat);

	// file operations
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CREATE, fFSOps->create);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_OPEN, fFSOps->open);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CLOSE, fFSOps->close);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_FREE_COOKIE, fFSOps->free_cookie);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ, fFSOps->read);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_WRITE, fFSOps->write);

	// directory operations
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CREATE_DIR, fFSOps->mkdir);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_REMOVE_DIR, fFSOps->rmdir);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_OPEN_DIR, fFSOps->opendir);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CLOSE_DIR, fFSOps->closedir);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_FREE_DIR_COOKIE,
		fFSOps->free_dircookie);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_DIR, fFSOps->readdir);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_REWIND_DIR, fFSOps->rewinddir);

	// attribute directory operations
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_OPEN_ATTR_DIR,
		fFSOps->open_attrdir);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CLOSE_ATTR_DIR,
		fFSOps->close_attrdir);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_FREE_ATTR_DIR_COOKIE,
		fFSOps->free_attrdircookie);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_ATTR_DIR,
		fFSOps->read_attrdir);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_REWIND_ATTR_DIR,
		fFSOps->rewind_attrdir);

	// attribute operations
	// we emulate open_attr() and free_attr_dir_cookie() if either read_attr()
	// or write_attr() is present
	bool hasAttributes = (fFSOps->read_attr || fFSOps->write_attr);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CREATE_ATTR, hasAttributes);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_OPEN_ATTR, hasAttributes);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CLOSE_ATTR, false);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_FREE_ATTR_COOKIE, hasAttributes);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_ATTR, fFSOps->read_attr);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_WRITE_ATTR, fFSOps->write_attr);

	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_ATTR_STAT,
		fFSOps->stat_attr);
	// missing: FS_VNODE_CAPABILITY_WRITE_ATTR_STAT
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_RENAME_ATTR, fFSOps->rename_attr);
	fNodeCapabilities.Set(FS_VNODE_CAPABILITY_REMOVE_ATTR, fFSOps->remove_attr);
}


// #pragma mark -


// get_beos_file_system_node_capabilities
//
// Service function for beos_kernel_emu.cpp. Declared in beos_kernel_emu.h.
void
get_beos_file_system_node_capabilities(FSVNodeCapabilities& capabilities)
{
	BeOSKernelFileSystem* fileSystem
		= static_cast<BeOSKernelFileSystem*>(FileSystem::GetInstance());
	fileSystem->GetNodeCapabilities(capabilities);
}


// #pragma mark - bootstrapping


status_t
userlandfs_create_file_system(const char* fsName, image_id image,
	FileSystem** _fileSystem)
{
	// get the symbols "fs_entry" and "api_version"
	beos_vnode_ops* fsOps;
	status_t error = get_image_symbol(image, "fs_entry", B_SYMBOL_TYPE_DATA,
		(void**)&fsOps);
	if (error != B_OK)
		RETURN_ERROR(error);
	int32* apiVersion;
	error = get_image_symbol(image, "api_version", B_SYMBOL_TYPE_DATA,
		(void**)&apiVersion);
	if (error != B_OK)
		RETURN_ERROR(error);

	// check api version
	if (*apiVersion != BEOS_FS_API_VERSION)
		RETURN_ERROR(B_ERROR);

	// create the file system
	BeOSKernelFileSystem* fileSystem
		= new(std::nothrow) BeOSKernelFileSystem(fsName, fsOps);
	if (!fileSystem)
		RETURN_ERROR(B_NO_MEMORY);

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

	*_fileSystem = fileSystem;
	return B_OK;
}