server/beos/BeOSKernelVolume.cpp

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

#include "BeOSKernelVolume.h"

#include <new>

#include <fcntl.h>
#include <unistd.h>

#include "Debug.h"

#include "../kernel_emu.h"

#include "BeOSKernelFileSystem.h"
#include "fs_interface.h"


using std::nothrow;

static int open_mode_to_access(int openMode);


// AttributeCookie
class BeOSKernelVolume::AttributeCookie {
public:
	AttributeCookie(const char* name, uint32 type, int openMode, bool exists,
		bool create)
		: fType(type),
		  fOpenMode(openMode),
		  fExists(exists),
		  fCreate(create)
	{
		strcpy(fName, name);
	}

	char	fName[B_ATTR_NAME_LENGTH];
	uint32	fType;
	int		fOpenMode;
	bool	fExists;
	bool	fCreate;
};


// _FileSystem
inline BeOSKernelFileSystem*
BeOSKernelVolume::_FileSystem() const
{
	return static_cast<BeOSKernelFileSystem*>(fFileSystem);
}


// constructor
BeOSKernelVolume::BeOSKernelVolume(FileSystem* fileSystem, dev_t id,
	beos_vnode_ops* fsOps, const FSVolumeCapabilities& capabilities)
	:
	Volume(fileSystem, id),
	fFSOps(fsOps),
	fVolumeCookie(NULL),
	fMounted(false)
{
	fCapabilities = capabilities;
}

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

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

// Mount
status_t
BeOSKernelVolume::Mount(const char* device, uint32 flags,
	const char* parameters, ino_t* rootID)
{
	if (!fFSOps->mount)
		return B_BAD_VALUE;

	size_t len = (parameters ? strlen(parameters) : 0);
	status_t error = fFSOps->mount(GetID(), device, flags, (void*)parameters,
		len, &fVolumeCookie, rootID);
	if (error != B_OK)
		return error;

	fMounted = true;
	return B_OK;
}

// Unmount
status_t
BeOSKernelVolume::Unmount()
{
	if (!fFSOps->unmount)
		return B_BAD_VALUE;
	return fFSOps->unmount(fVolumeCookie);
}

// Sync
status_t
BeOSKernelVolume::Sync()
{
	if (!fFSOps->sync)
		return B_BAD_VALUE;
	return fFSOps->sync(fVolumeCookie);
}

// ReadFSInfo
status_t
BeOSKernelVolume::ReadFSInfo(fs_info* info)
{
	if (!fFSOps->rfsstat)
		return B_BAD_VALUE;

	// Haiku's fs_info equals BeOS's version
	return fFSOps->rfsstat(fVolumeCookie, (beos_fs_info*)info);
}

// WriteFSInfo
status_t
BeOSKernelVolume::WriteFSInfo(const struct fs_info* info, uint32 mask)
{
	if (!fFSOps->wfsstat)
		return B_BAD_VALUE;

	// Haiku's fs_info equals BeOS's version
	return fFSOps->wfsstat(fVolumeCookie, (beos_fs_info*)info, (long)mask);
}


// #pragma mark - vnodes


// Lookup
status_t
BeOSKernelVolume::Lookup(void* dir, const char* entryName, ino_t* vnid)
{
	if (!fFSOps->walk)
		return B_BAD_VALUE;
	return fFSOps->walk(fVolumeCookie, dir, entryName, NULL, vnid);
}


// GetVNodeType
status_t
BeOSKernelVolume::GetVNodeType(void* node, int* type)
{
	if (fMounted) {
		// The volume is mounted. We can stat() the node to get its type.
		struct stat st;
		status_t error = ReadStat(node, &st);
		if (error != B_OK)
			return error;

		*type = st.st_mode & S_IFMT;
	} else {
		// Not mounted yet. That particularly means we don't have a volume
		// cookie yet and cannot use calls into the FS to get the node type.
		// Just assume the node is a directory. That definitely is the case for
		// the root node and shouldn't do harm for the index directory or
		// indices, which could get published while mounting as well.
		*type = S_IFDIR;
			// TODO: Store the concerned nodes and check their type as soon as
			// possible (at the end of Mount()). The incorrect ones could be
			// corrected in the kernel: remove_vnode(), x*put_vnode() (catching
			// the "remove_vnode()" callback), publish_vnode(),
			// (x-1)*get_vnode().
	}

	return B_OK;
}


// ReadVNode
status_t
BeOSKernelVolume::ReadVNode(ino_t vnid, bool reenter, void** node, int* type,
	uint32* flags, FSVNodeCapabilities* _capabilities)
{
	if (!fFSOps->read_vnode)
		return B_BAD_VALUE;

	// get the node
	status_t error = fFSOps->read_vnode(fVolumeCookie, vnid, (char)reenter,
		node);
	if (error != B_OK)
		return error;

	// stat it -- we need to get the node type
	struct stat st;
	error = ReadStat(*node, &st);
	if (error != B_OK) {
		WriteVNode(*node, reenter);
		return error;
	}

	*type = (st.st_mode & S_IFMT);
	*flags = 0;
	_FileSystem()->GetNodeCapabilities(*_capabilities);

	return B_OK;
}

// WriteVNode
status_t
BeOSKernelVolume::WriteVNode(void* node, bool reenter)
{
	if (!fFSOps->write_vnode)
		return B_BAD_VALUE;
	return fFSOps->write_vnode(fVolumeCookie, node, (char)reenter);
}

// RemoveVNode
status_t
BeOSKernelVolume::RemoveVNode(void* node, bool reenter)
{
	if (!fFSOps->remove_vnode)
		return B_BAD_VALUE;
	return fFSOps->remove_vnode(fVolumeCookie, node, (char)reenter);
}


// #pragma mark - nodes


// IOCtl
status_t
BeOSKernelVolume::IOCtl(void* node, void* cookie, uint32 command,
	void* buffer, size_t size)
{
	if (!fFSOps->ioctl)
		return B_BAD_VALUE;
	return fFSOps->ioctl(fVolumeCookie, node, cookie, (int)command, buffer,
		size);
}

// SetFlags
status_t
BeOSKernelVolume::SetFlags(void* node, void* cookie, int flags)
{
	if (!fFSOps->setflags)
		return B_BAD_VALUE;
	return fFSOps->setflags(fVolumeCookie, node, cookie, flags);
}

// Select
status_t
BeOSKernelVolume::Select(void* node, void* cookie, uint8 event,
	selectsync* sync)
{
	if (!fFSOps->select) {
		UserlandFS::KernelEmu::notify_select_event(sync, event, false);
		return B_OK;
	}
	return fFSOps->select(fVolumeCookie, node, cookie, event, 0, sync);
}

// Deselect
status_t
BeOSKernelVolume::Deselect(void* node, void* cookie, uint8 event,
	selectsync* sync)
{
	if (!fFSOps->select || !fFSOps->deselect)
		return B_OK;
	return fFSOps->deselect(fVolumeCookie, node, cookie, event, sync);
}

// FSync
status_t
BeOSKernelVolume::FSync(void* node)
{
	if (!fFSOps->fsync)
		return B_BAD_VALUE;
	return fFSOps->fsync(fVolumeCookie, node);
}

// ReadSymlink
status_t
BeOSKernelVolume::ReadSymlink(void* node, char* buffer, size_t bufferSize,
	size_t* bytesRead)
{
	if (!fFSOps->readlink)
		return B_BAD_VALUE;
	*bytesRead = bufferSize;
	return fFSOps->readlink(fVolumeCookie, node, buffer, bytesRead);
}

// CreateSymlink
status_t
BeOSKernelVolume::CreateSymlink(void* dir, const char* name,
	const char* target, int mode)
{
	if (!fFSOps->symlink)
		return B_BAD_VALUE;
// TODO: Don't ignore mode?
	return fFSOps->symlink(fVolumeCookie, dir, name, target);
}

// Link
status_t
BeOSKernelVolume::Link(void* dir, const char* name, void* node)
{
	if (!fFSOps->link)
		return B_BAD_VALUE;
	return fFSOps->link(fVolumeCookie, dir, name, node);
}

// Unlink
status_t
BeOSKernelVolume::Unlink(void* dir, const char* name)
{
	if (!fFSOps->unlink)
		return B_BAD_VALUE;
	return fFSOps->unlink(fVolumeCookie, dir, name);
}

// Rename
status_t
BeOSKernelVolume::Rename(void* oldDir, const char* oldName, void* newDir,
	const char* newName)
{
	if (!fFSOps->rename)
		return B_BAD_VALUE;
	return fFSOps->rename(fVolumeCookie, oldDir, oldName, newDir, newName);
}

// Access
status_t
BeOSKernelVolume::Access(void* node, int mode)
{
	if (!fFSOps->access)
		return B_OK;
	return fFSOps->access(fVolumeCookie, node, mode);
}

// ReadStat
status_t
BeOSKernelVolume::ReadStat(void* node, struct stat* st)
{
	if (!fFSOps->rstat)
		return B_BAD_VALUE;

	// Haiku's struct stat has an additional st_type field (for an attribute
	// type), but that doesn't matter here
	return fFSOps->rstat(fVolumeCookie, node, (struct beos_stat*)st);
}

// WriteStat
status_t
BeOSKernelVolume::WriteStat(void* node, const struct stat *st, uint32 mask)
{
	if (!fFSOps->wstat)
		return B_BAD_VALUE;

	// Haiku's struct stat has an additional st_type field (for an attribute
	// type), but that doesn't matter here
	return fFSOps->wstat(fVolumeCookie, node, (struct beos_stat*)st,
		(long)mask);
}


// #pragma mark - files


// Create
status_t
BeOSKernelVolume::Create(void* dir, const char* name, int openMode, int mode,
	void** cookie, ino_t* vnid)
{
	if (!fFSOps->create)
		return B_BAD_VALUE;
	return fFSOps->create(fVolumeCookie, dir, name, openMode, mode, vnid,
		cookie);
}

// Open
status_t
BeOSKernelVolume::Open(void* node, int openMode, void** cookie)
{
	if (!fFSOps->open)
		return B_BAD_VALUE;
	return fFSOps->open(fVolumeCookie, node, openMode, cookie);
}

// Close
status_t
BeOSKernelVolume::Close(void* node, void* cookie)
{
	if (!fFSOps->close)
		return B_OK;
	return fFSOps->close(fVolumeCookie, node, cookie);
}

// FreeCookie
status_t
BeOSKernelVolume::FreeCookie(void* node, void* cookie)
{
	if (!fFSOps->free_cookie)
		return B_OK;
	return fFSOps->free_cookie(fVolumeCookie, node, cookie);
}

// Read
status_t
BeOSKernelVolume::Read(void* node, void* cookie, off_t pos, void* buffer,
	size_t bufferSize, size_t* bytesRead)
{
	if (!fFSOps->read)
		return B_BAD_VALUE;
	*bytesRead = bufferSize;
	return fFSOps->read(fVolumeCookie, node, cookie, pos, buffer, bytesRead);
}

// Write
status_t
BeOSKernelVolume::Write(void* node, void* cookie, off_t pos,
	const void* buffer, size_t bufferSize, size_t* bytesWritten)
{
	if (!fFSOps->write)
		return B_BAD_VALUE;
	*bytesWritten = bufferSize;
	return fFSOps->write(fVolumeCookie, node, cookie, pos, buffer,
		bytesWritten);
}


// #pragma mark -  directories


// CreateDir
status_t
BeOSKernelVolume::CreateDir(void* dir, const char* name, int mode)
{
	if (!fFSOps->mkdir)
		return B_BAD_VALUE;

	return fFSOps->mkdir(fVolumeCookie, dir, name, mode);
}

// RemoveDir
status_t
BeOSKernelVolume::RemoveDir(void* dir, const char* name)
{
	if (!fFSOps->rmdir)
		return B_BAD_VALUE;
	return fFSOps->rmdir(fVolumeCookie, dir, name);
}

// OpenDir
status_t
BeOSKernelVolume::OpenDir(void* node, void** cookie)
{
	if (!fFSOps->opendir)
		return B_BAD_VALUE;
	return fFSOps->opendir(fVolumeCookie, node, cookie);
}

// CloseDir
status_t
BeOSKernelVolume::CloseDir(void* node, void* cookie)
{
	if (!fFSOps->closedir)
		return B_OK;
	return fFSOps->closedir(fVolumeCookie, node, cookie);
}

// FreeDirCookie
status_t
BeOSKernelVolume::FreeDirCookie(void* node, void* cookie)
{
	if (!fFSOps->free_dircookie)
		return B_OK;
	return fFSOps->free_dircookie(fVolumeCookie, node, cookie);
}

// ReadDir
status_t
BeOSKernelVolume::ReadDir(void* node, void* cookie, void* buffer,
	size_t bufferSize, uint32 count, uint32* countRead)
{
	if (!fFSOps->readdir)
		return B_BAD_VALUE;

	*countRead = count;

	// Haiku's struct dirent equals BeOS's version
	return fFSOps->readdir(fVolumeCookie, node, cookie, (long*)countRead,
		(beos_dirent*)buffer, bufferSize);
}

// RewindDir
status_t
BeOSKernelVolume::RewindDir(void* node, void* cookie)
{
	if (!fFSOps->rewinddir)
		return B_BAD_VALUE;
	return fFSOps->rewinddir(fVolumeCookie, node, cookie);
}


// #pragma mark - attribute directories


// OpenAttrDir
status_t
BeOSKernelVolume::OpenAttrDir(void* node, void** cookie)
{
	if (!fFSOps->open_attrdir)
		return B_BAD_VALUE;
	return fFSOps->open_attrdir(fVolumeCookie, node, cookie);
}

// CloseAttrDir
status_t
BeOSKernelVolume::CloseAttrDir(void* node, void* cookie)
{
	if (!fFSOps->close_attrdir)
		return B_OK;
	return fFSOps->close_attrdir(fVolumeCookie, node, cookie);
}

// FreeAttrDirCookie
status_t
BeOSKernelVolume::FreeAttrDirCookie(void* node, void* cookie)
{
	if (!fFSOps->free_attrdircookie)
		return B_OK;
	return fFSOps->free_attrdircookie(fVolumeCookie, node, cookie);
}

// ReadAttrDir
status_t
BeOSKernelVolume::ReadAttrDir(void* node, void* cookie, void* buffer,
	size_t bufferSize, uint32 count, uint32* countRead)
{
	if (!fFSOps->read_attrdir)
		return B_BAD_VALUE;

	*countRead = count;

	// Haiku's struct dirent equals BeOS's version
	return fFSOps->read_attrdir(fVolumeCookie, node, cookie, (long*)countRead,
		(struct beos_dirent*)buffer, bufferSize);
}

// RewindAttrDir
status_t
BeOSKernelVolume::RewindAttrDir(void* node, void* cookie)
{
	if (!fFSOps->rewind_attrdir)
		return B_BAD_VALUE;
	return fFSOps->rewind_attrdir(fVolumeCookie, node, cookie);
}


// #pragma mark - attributes


// CreateAttr
status_t
BeOSKernelVolume::CreateAttr(void* node, const char* name, uint32 type,
	int openMode, void** cookie)
{
	return _OpenAttr(node, name, type, openMode, true, cookie);
}

// OpenAttr
status_t
BeOSKernelVolume::OpenAttr(void* node, const char* name, int openMode,
	void** cookie)
{
	return _OpenAttr(node, name, 0, openMode, false, cookie);
}

// CloseAttr
status_t
BeOSKernelVolume::CloseAttr(void* node, void* cookie)
{
	return B_OK;
}

// FreeAttrCookie
status_t
BeOSKernelVolume::FreeAttrCookie(void* node, void* _cookie)
{
	AttributeCookie* cookie = (AttributeCookie*)_cookie;

	// If the attribute doesn't exist yet and it was opened with
	// CreateAttr(), we could create it now. We have a race condition here
	// though, since someone else could have created it in the meantime.

	delete cookie;

	return B_OK;
}

// ReadAttr
status_t
BeOSKernelVolume::ReadAttr(void* node, void* _cookie, off_t pos,
	void* buffer, size_t bufferSize, size_t* bytesRead)
{
	AttributeCookie* cookie = (AttributeCookie*)_cookie;

	// check, if open mode allows reading
	if ((open_mode_to_access(cookie->fOpenMode) & R_OK) == 0)
		return B_FILE_ERROR;

	// read
	if (!fFSOps->read_attr)
		return B_BAD_VALUE;

	*bytesRead = bufferSize;
	return fFSOps->read_attr(fVolumeCookie, node, cookie->fName, cookie->fType,
		buffer, bytesRead, pos);
}

// WriteAttr
status_t
BeOSKernelVolume::WriteAttr(void* node, void* _cookie, off_t pos,
	const void* buffer, size_t bufferSize, size_t* bytesWritten)
{
	AttributeCookie* cookie = (AttributeCookie*)_cookie;

	// check, if open mode allows writing
	if ((open_mode_to_access(cookie->fOpenMode) & W_OK) == 0)
		return B_FILE_ERROR;

	// write
	if (!fFSOps->write_attr)
		return B_BAD_VALUE;

	*bytesWritten = bufferSize;
	return fFSOps->write_attr(fVolumeCookie, node, cookie->fName, cookie->fType,
		buffer, bytesWritten, pos);
}

// ReadAttrStat
status_t
BeOSKernelVolume::ReadAttrStat(void* node, void* _cookie,
	struct stat *st)
{
	AttributeCookie* cookie = (AttributeCookie*)_cookie;

	// get the stats
	beos_attr_info attrInfo;
	if (!fFSOps->stat_attr)
		return B_BAD_VALUE;

	status_t error = fFSOps->stat_attr(fVolumeCookie, node, cookie->fName,
		&attrInfo);
	if (error != B_OK)
		return error;

	// translate to struct stat
	st->st_size = attrInfo.size;
	st->st_type = attrInfo.type;

	return B_OK;
}

// RenameAttr
status_t
BeOSKernelVolume::RenameAttr(void* oldNode, const char* oldName,
	void* newNode, const char* newName)
{
	if (!fFSOps->rename_attr)
		return B_BAD_VALUE;
	if (oldNode != newNode)
		return B_BAD_VALUE;

	return fFSOps->rename_attr(fVolumeCookie, oldNode, oldName, newName);
}

// RemoveAttr
status_t
BeOSKernelVolume::RemoveAttr(void* node, const char* name)
{
	if (!fFSOps->remove_attr)
		return B_BAD_VALUE;
	return fFSOps->remove_attr(fVolumeCookie, node, name);
}


// #pragma mark - indices


// OpenIndexDir
status_t
BeOSKernelVolume::OpenIndexDir(void** cookie)
{
	if (!fFSOps->open_indexdir)
		return B_BAD_VALUE;
	return fFSOps->open_indexdir(fVolumeCookie, cookie);
}

// CloseIndexDir
status_t
BeOSKernelVolume::CloseIndexDir(void* cookie)
{
	if (!fFSOps->close_indexdir)
		return B_OK;
	return fFSOps->close_indexdir(fVolumeCookie, cookie);
}

// FreeIndexDirCookie
status_t
BeOSKernelVolume::FreeIndexDirCookie(void* cookie)
{
	if (!fFSOps->free_indexdircookie)
		return B_OK;
	return fFSOps->free_indexdircookie(fVolumeCookie, NULL, cookie);
}

// ReadIndexDir
status_t
BeOSKernelVolume::ReadIndexDir(void* cookie, void* buffer,
	size_t bufferSize, uint32 count, uint32* countRead)
{
	if (!fFSOps->read_indexdir)
		return B_BAD_VALUE;

	*countRead = count;

	// Haiku's struct dirent equals BeOS's version
	return fFSOps->read_indexdir(fVolumeCookie, cookie, (long*)countRead,
		(struct beos_dirent*)buffer, bufferSize);
}

// RewindIndexDir
status_t
BeOSKernelVolume::RewindIndexDir(void* cookie)
{
	if (!fFSOps->rewind_indexdir)
		return B_BAD_VALUE;
	return fFSOps->rewind_indexdir(fVolumeCookie, cookie);
}

// CreateIndex
status_t
BeOSKernelVolume::CreateIndex(const char* name, uint32 type, uint32 flags)
{
	if (!fFSOps->create_index)
		return B_BAD_VALUE;
	return fFSOps->create_index(fVolumeCookie, name, (int)type, (int)flags);
}

// RemoveIndex
status_t
BeOSKernelVolume::RemoveIndex(const char* name)
{
	if (!fFSOps->remove_index)
		return B_BAD_VALUE;
	return fFSOps->remove_index(fVolumeCookie, name);
}

// StatIndex
status_t
BeOSKernelVolume::ReadIndexStat(const char *name, struct stat *st)
{
	if (!fFSOps->stat_index)
		return B_BAD_VALUE;

	beos_index_info indexInfo;
	status_t error = fFSOps->stat_index(fVolumeCookie, name, &indexInfo);
	if (error != B_OK)
		return error;

	// translate index_info into struct stat
	st->st_type = indexInfo.type;
	st->st_size = indexInfo.size;
	st->st_mtime = indexInfo.modification_time;
	st->st_crtime = indexInfo.creation_time;
	st->st_uid = indexInfo.uid;
	st->st_gid = indexInfo.gid;

	return B_OK;
}


// #pragma mark - queries


// OpenQuery
status_t
BeOSKernelVolume::OpenQuery(const char* queryString, uint32 flags, port_id port,
	uint32 token, void** cookie)
{
	if (!fFSOps->open_query)
		return B_BAD_VALUE;
	return fFSOps->open_query(fVolumeCookie, queryString, flags, port,
		(long)token, cookie);
}

// CloseQuery
status_t
BeOSKernelVolume::CloseQuery(void* cookie)
{
	if (!fFSOps->close_query)
		return B_OK;
	return fFSOps->close_query(fVolumeCookie, cookie);
}

// FreeQueryCookie
status_t
BeOSKernelVolume::FreeQueryCookie(void* cookie)
{
	if (!fFSOps->free_querycookie)
		return B_OK;
	return fFSOps->free_querycookie(fVolumeCookie, NULL, cookie);
}

// ReadQuery
status_t
BeOSKernelVolume::ReadQuery(void* cookie, void* buffer, size_t bufferSize,
	uint32 count, uint32* countRead)
{
	if (!fFSOps->read_query)
		return B_BAD_VALUE;

	*countRead = count;

	// Haiku's struct dirent equals BeOS's version
	return fFSOps->read_query(fVolumeCookie, cookie, (long*)countRead,
		(struct beos_dirent*)buffer, bufferSize);
}


// #pragma mark - Private


// _OpenAttr
status_t
BeOSKernelVolume::_OpenAttr(void* node, const char* name, uint32 type,
	int openMode, bool create, void** _cookie)
{
	// check permissions first
	int accessMode = open_mode_to_access(openMode) | (create ? W_OK : 0);
	status_t error = Access(node, accessMode);
	if (error != B_OK)
		return error;

	// check whether the attribute already exists
	beos_attr_info attrInfo;
	if (!fFSOps->stat_attr)
		return B_BAD_VALUE;
	bool exists
		= (fFSOps->stat_attr(fVolumeCookie, node, name, &attrInfo) == B_OK);

	if (create) {
		// create: fail, if attribute exists and non-existence was required
		if (exists && (openMode & O_EXCL))
			return B_FILE_EXISTS;
	} else {
		// open: fail, if attribute doesn't exist
		if (!exists)
			return B_ENTRY_NOT_FOUND;

		// keep the attribute type
		type = attrInfo.type;
	}

	// create an attribute cookie
	AttributeCookie* cookie = new(nothrow) AttributeCookie(name, type,
		openMode, exists, create);
	if (!cookie)
		return B_NO_MEMORY;

	// TODO: If we want to support O_TRUNC, we should do that here.

	*_cookie = cookie;
	return B_OK;
}

// open_mode_to_access
static int
open_mode_to_access(int openMode)
{
 	switch (openMode & O_RWMASK) {
		case O_RDONLY:
			return R_OK;
		case O_WRONLY:
			return W_OK;
		case O_RDWR:
		default:
			return W_OK | R_OK;
 	}
}