/*
 * Copyright 2001-2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
 
 
#include "Volume.h"
 
#include <util/AutoLock.h>
 
#include <fs/node_monitor.h>
#include <Notifications.h>
 
#include "AutoLocker.h"
#include "Compatibility.h"
#include "Debug.h"
#include "FileSystem.h"
#include "HashMap.h"
#include "kernel_interface.h"
#include "KernelRequestHandler.h"
#include "PortReleaser.h"
#include "RequestAllocator.h"
#include "Requests.h"
#include "Settings.h"
#include "SingleReplyRequestHandler.h"
 
 
// The time after which the notification thread times out at the port and
// restarts the loop. Of interest only when the FS is deleted. It is the
// maximal time the destructor has to wait for the thread.
static const bigtime_t kNotificationRequestTimeout = 50000;	// 50 ms
 
 
// #pragma mark - SelectSyncMap
 
 
struct FileSystem::SelectSyncMap
	: public SynchronizedHashMap<HashKeyPointer<selectsync*>, int32*, Locker> {
};
 
 
// #pragma mark - NodeListenerKey
 
 
struct FileSystem::NodeListenerKey {
	NodeListenerKey(void* clientListener, dev_t device, ino_t node)
		:
		fClientListener(clientListener),
		fDevice(device),
		fNode(node)
	{
	}
 
	void* ClientListener() const
	{
		return fClientListener;
	}
 
	dev_t Device() const
	{
		return fDevice;
	}
 
	ino_t Node() const
	{
		return fNode;
	}
 
	uint32 HashValue() const
	{
		return (uint32)(addr_t)fClientListener ^ (uint32)fDevice
			^ (uint32)fNode ^ (uint32)(fNode >> 32);
	}
 
	bool operator==(const NodeListenerKey& other) const
	{
		return fClientListener == other.fClientListener
			&& fDevice == other.fDevice && fNode == other.fNode;
	}
 
protected:
	void*	fClientListener;
	dev_t	fDevice;
	ino_t	fNode;
};
 
 
// #pragma mark - NodeListenerProxy
 
 
struct FileSystem::NodeListenerProxy : NodeListenerKey, NotificationListener {
	NodeListenerProxy(FileSystem* fileSystem, void* clientListener,
		dev_t device, ino_t node)
		:
		NodeListenerKey(clientListener, device, node),
		fFileSystem(fileSystem)
	{
	}
 
	virtual void EventOccurred(NotificationService& service,
		const KMessage* event)
	{
		fFileSystem->_NodeListenerEventOccurred(this, event);
	}
 
	NodeListenerProxy*& HashTableLink()
	{
		return fHashTableLink;
	}
 
	status_t StartListening(uint32 flags)
	{
		return add_node_listener(fDevice, fNode, flags, *this);
	}
 
	status_t StopListening()
	{
		return remove_node_listener(fDevice, fNode, *this);
	}
 
private:
	FileSystem*			fFileSystem;
	NodeListenerProxy*	fHashTableLink;
};
 
 
// #pragma mark - NodeListenerHashDefinition
 
 
struct FileSystem::NodeListenerHashDefinition {
	typedef NodeListenerKey		KeyType;
	typedef	NodeListenerProxy	ValueType;
 
	size_t HashKey(const NodeListenerKey& key) const
	{
		return key.HashValue();
	}
 
	size_t Hash(const NodeListenerProxy* value) const
	{
		return value->HashValue();
	}
 
	bool Compare(const NodeListenerKey& key,
		const NodeListenerProxy* value) const
	{
		return key == *value;
	}
 
	NodeListenerProxy*& GetLink(NodeListenerProxy* value) const
	{
		return value->HashTableLink();
	}
};
 
 
// #pragma mark - FileSystem
 
 
// constructor
FileSystem::FileSystem()
	:
	fVolumes(),
	fName(),
	fTeam(-1),
	fNotificationPort(NULL),
	fNotificationThread(-1),
	fPortPool(),
	fSelectSyncs(NULL),
	fSettings(NULL),
	fUserlandServerTeam(-1),
	fInitialized(false),
	fTerminating(false)
{
	mutex_init(&fVolumeLock, "userlandfs volumes");
	mutex_init(&fVNodeOpsLock, "userlandfs vnode ops");
	mutex_init(&fNodeListenersLock, "userlandfs node listeners");
}
 
// destructor
FileSystem::~FileSystem()
{
	fTerminating = true;
 
	// wait for the notification thread to terminate
	if (fNotificationThread >= 0) {
		int32 result;
		wait_for_thread(fNotificationThread, &result);
	}
 
	// delete our data structures
	if (fNodeListeners != NULL) {
		MutexLocker nodeListenersLocker(fNodeListenersLock);
		NodeListenerProxy* proxy = fNodeListeners->Clear(true);
		while (proxy != NULL) {
			NodeListenerProxy* next = proxy->HashTableLink();
			proxy->StopListening();
			delete proxy;
			proxy = next;
		}
	}
 
	if (fSelectSyncs) {
		for (SelectSyncMap::Iterator it = fSelectSyncs->GetIterator();
				it.HasNext();) {
			SelectSyncMap::Entry entry = it.Next();
			delete entry.value;
		}
		delete fSelectSyncs;
	}
 
	delete fSettings;
 
	// delete vnode ops vectors -- there shouldn't be any left, though
	VNodeOps* ops = fVNodeOps.Clear();
	int32 count = 0;
	while (ops != NULL) {
		count++;
		VNodeOps* next = ops->hash_link;
		free(ops);
		ops = next;
	}
	if (count > 0)
		WARN(("Deleted %" B_PRId32 " vnode ops vectors!\n", count));
 
 
	mutex_destroy(&fVolumeLock);
	mutex_destroy(&fVNodeOpsLock);
	mutex_destroy(&fNodeListenersLock);
}
 
// Init
status_t
FileSystem::Init(const char* name, team_id team, Port::Info* infos, int32 count,
	const FSCapabilities& capabilities)
{
	PRINT(("FileSystem::Init(\"%s\", %p, %" B_PRId32 ")\n", name, infos,
		count));
	capabilities.Dump();
 
	// check parameters
	if (!name || !infos || count < 2)
		RETURN_ERROR(B_BAD_VALUE);
 
	// set the name
	if (!fName.SetTo(name))
		return B_NO_MEMORY;
 
	// init VNodeOps map
	status_t error = fVNodeOps.Init();
	if (error != B_OK)
		return error;
 
	fTeam = team;
	fCapabilities = capabilities;
 
	// create the select sync entry map
	fSelectSyncs = new(nothrow) SelectSyncMap;
	if (!fSelectSyncs)
		return B_NO_MEMORY;
 
	// create the node listener proxy map
	fNodeListeners = new(std::nothrow) NodeListenerMap;
	if (fNodeListeners == NULL || fNodeListeners->Init() != B_OK)
		return B_NO_MEMORY;
 
	// create the request ports
	// the notification port
	fNotificationPort = new(nothrow) RequestPort(infos);
	if (!fNotificationPort)
		RETURN_ERROR(B_NO_MEMORY);
	error = fNotificationPort->InitCheck();
	if (error != B_OK)
		return error;
 
	// the other request ports
	for (int32 i = 1; i < count; i++) {
		RequestPort* port = new(nothrow) RequestPort(infos + i);
		if (!port)
			RETURN_ERROR(B_NO_MEMORY);
		error = port->InitCheck();
		if (error == B_OK)
			error = fPortPool.AddPort(port);
		if (error != B_OK) {
			delete port;
			RETURN_ERROR(error);
		}
	}
 
	// get the userland team
	port_info portInfo;
	error = get_port_info(infos[0].owner_port, &portInfo);
	if (error != B_OK)
		RETURN_ERROR(error);
	fUserlandServerTeam = portInfo.team;
 
	// print some info about the userland team
	D(
		PRINT(("  userland team is: %" B_PRId32 "\n", fUserlandServerTeam));
		int32 cookie = 0;
		thread_info threadInfo;
		while (get_next_thread_info(fUserlandServerTeam, &cookie, &threadInfo)
			   == B_OK) {
			PRINT(("    userland thread: %" B_PRId32 ": `%s'\n",
				threadInfo.thread, threadInfo.name));
		}
	);
 
	// load the settings
	fSettings = new(nothrow) Settings;
	if (fSettings) {
		status_t settingsError = fSettings->SetTo(fName.GetString());
		if (settingsError != B_OK) {
			PRINT(("Failed to load settings: %s\n", strerror(settingsError)));
			delete fSettings;
			fSettings = NULL;
		} else
			fSettings->Dump();
	} else
		ERROR(("Failed to allocate settings.\n"));
 
	// spawn the notification thread
	#if USER
		fNotificationThread = spawn_thread(_NotificationThreadEntry,
			"UFS notification thread", B_NORMAL_PRIORITY, this);
	#else
		fNotificationThread = spawn_kernel_thread(_NotificationThreadEntry,
			"UFS notification thread", B_NORMAL_PRIORITY, this);
	#endif
	if (fNotificationThread < 0)
		RETURN_ERROR(fNotificationThread);
	resume_thread(fNotificationThread);
 
	fInitialized = (error == B_OK);
	RETURN_ERROR(error);
}
 
// GetName
const char*
FileSystem::GetName() const
{
	return fName.GetString();
}
 
// GetCapabilities
const FSCapabilities&
FileSystem::GetCapabilities() const
{
	return fCapabilities;
}
 
// GetPortPool
RequestPortPool*
FileSystem::GetPortPool()
{
	return &fPortPool;
}
 
// Mount
status_t
FileSystem::Mount(fs_volume* fsVolume, const char* device, uint32 flags,
	const char* parameters, Volume** _volume)
{
	// check initialization and parameters
	if (!fInitialized || !_volume)
		return B_BAD_VALUE;
 
	// create volume
	Volume* volume = new(nothrow) Volume(this, fsVolume);
	if (!volume)
		return B_NO_MEMORY;
 
	// add volume to the volume list
	MutexLocker locker(fVolumeLock);
	status_t error = fVolumes.PushBack(volume);
	locker.Unlock();
	if (error != B_OK)
		return error;
 
	// mount volume
	error = volume->Mount(device, flags, parameters);
	if (error != B_OK) {
		MutexLocker locker(fVolumeLock);
		fVolumes.Remove(volume);
		locker.Unlock();
		volume->ReleaseReference();
		return error;
	}
 
	*_volume = volume;
	return error;
}
 
// Initialize
/*status_t
FileSystem::Initialize(const char* deviceName, const char* parameters,
	size_t len)
{
	// get a free port
	RequestPort* port = fPortPool.AcquirePort();
	if (!port)
		return B_ERROR;
	PortReleaser _(&fPortPool, port);
	// prepare the request
	RequestAllocator allocator(port->GetPort());
	MountVolumeRequest* request;
	status_t error = AllocateRequest(allocator, &request);
	if (error != B_OK)
		return error;
	error = allocator.AllocateString(request->device, deviceName);
	if (error == B_OK)
		error = allocator.AllocateData(request->parameters, parameters, len, 1);
	if (error != B_OK)
		return error;
	// send the request
	SingleReplyRequestHandler handler(MOUNT_VOLUME_REPLY);
	InitializeVolumeReply* reply;
	error = port->SendRequest(&allocator, &handler, (Request**)&reply);
	if (error != B_OK)
		return error;
	RequestReleaser requestReleaser(port, reply);
	// process the reply
	if (reply->error != B_OK)
		return reply->error;
	return error;
}*/
 
// VolumeUnmounted
void
FileSystem::VolumeUnmounted(Volume* volume)
{
	MutexLocker locker(fVolumeLock);
	fVolumes.Remove(volume);
}
 
// GetVolume
Volume*
FileSystem::GetVolume(dev_t id)
{
	MutexLocker _(fVolumeLock);
	for (Vector<Volume*>::Iterator it = fVolumes.Begin();
		 it != fVolumes.End();
		 it++) {
		 Volume* volume = *it;
		 if (volume->GetID() == id) {
		 	volume->AcquireReference();
		 	return volume;
		 }
	}
	return NULL;
}
 
// GetIOCtlInfo
const IOCtlInfo*
FileSystem::GetIOCtlInfo(int command) const
{
	return (fSettings ? fSettings->GetIOCtlInfo(command) : NULL);
}
 
// AddSelectSyncEntry
status_t
FileSystem::AddSelectSyncEntry(selectsync* sync)
{
	AutoLocker<SelectSyncMap> _(fSelectSyncs);
	int32* count = fSelectSyncs->Get(sync);
	if (!count) {
		count = new(nothrow) int32(0);
		if (!count)
			return B_NO_MEMORY;
		status_t error = fSelectSyncs->Put(sync, count);
		if (error != B_OK) {
			delete count;
			return error;
		}
	}
	(*count)++;
	return B_OK;
}
 
// RemoveSelectSyncEntry
void
FileSystem::RemoveSelectSyncEntry(selectsync* sync)
{
	AutoLocker<SelectSyncMap> _(fSelectSyncs);
	if (int32* count = fSelectSyncs->Get(sync)) {
		if (--(*count) <= 0) {
			fSelectSyncs->Remove(sync);
			delete count;
		}
	}
}
 
 
// KnowsSelectSyncEntry
bool
FileSystem::KnowsSelectSyncEntry(selectsync* sync)
{
	return fSelectSyncs->ContainsKey(sync);
}
 
 
// AddNodeListener
status_t
FileSystem::AddNodeListener(dev_t device, ino_t node, uint32 flags,
	void* listener)
{
	MutexLocker nodeListenersLocker(fNodeListenersLock);
 
	// lookup the proxy
	NodeListenerProxy* proxy = fNodeListeners->Lookup(
		NodeListenerKey(listener, device, node));
	if (proxy != NULL)
		return proxy->StartListening(flags);
 
	// it doesn't exist yet -- create it
	proxy = new(std::nothrow) NodeListenerProxy(this, listener, device, node);
	if (proxy == NULL)
		return B_NO_MEMORY;
 
	// start listening
	status_t error = proxy->StartListening(flags);
	if (error != B_OK) {
		delete proxy;
		return error;
	}
 
	fNodeListeners->Insert(proxy);
	return B_OK;
}
 
 
// RemoveNodeListener
status_t
FileSystem::RemoveNodeListener(dev_t device, ino_t node, void* listener)
{
	MutexLocker nodeListenersLocker(fNodeListenersLock);
 
	// lookup the proxy
	NodeListenerProxy* proxy = fNodeListeners->Lookup(
		NodeListenerKey(listener, device, node));
	if (proxy == NULL)
		return B_BAD_VALUE;
 
	status_t error = proxy->StopListening();
 
	fNodeListeners->Remove(proxy);
	delete proxy;
 
	return error;
}
 
 
// GetVNodeOps
VNodeOps*
FileSystem::GetVNodeOps(const FSVNodeCapabilities& capabilities)
{
	MutexLocker locker(fVNodeOpsLock);
 
	// do we already have ops for those capabilities
	VNodeOps* ops = fVNodeOps.Lookup(capabilities);
	if (ops != NULL) {
		ops->refCount++;
		return ops;
	}
 
	// no, create a new object
	fs_vnode_ops* opsVector = new(std::nothrow) fs_vnode_ops;
	if (opsVector == NULL)
		return NULL;
 
	// set the operations
	_InitVNodeOpsVector(opsVector, capabilities);
 
	// create the VNodeOps object
	ops = new(std::nothrow) VNodeOps(capabilities, opsVector);
	if (ops == NULL) {
		delete opsVector;
		return NULL;
	}
 
	fVNodeOps.Insert(ops);
 
	return ops;
}
 
 
// PutVNodeOps
void
FileSystem::PutVNodeOps(VNodeOps* ops)
{
	MutexLocker locker(fVNodeOpsLock);
 
	if (--ops->refCount == 0) {
		fVNodeOps.Remove(ops);
		delete ops;
	}
}
 
 
// IsUserlandServerThread
bool
FileSystem::IsUserlandServerThread() const
{
	thread_info info;
	get_thread_info(find_thread(NULL), &info);
	return (info.team == fUserlandServerTeam);
}
 
 
// _InitVNodeOpsVector
void
FileSystem::_InitVNodeOpsVector(fs_vnode_ops* ops,
	const FSVNodeCapabilities& capabilities)
{
	memcpy(ops, &gUserlandFSVnodeOps, sizeof(fs_vnode_ops));
 
	#undef CLEAR_UNSUPPORTED
	#define CLEAR_UNSUPPORTED(capability, op) 	\
		if (!capabilities.Get(capability))				\
			ops->op = NULL
 
	// vnode operations
	// FS_VNODE_CAPABILITY_LOOKUP: lookup
	// FS_VNODE_CAPABILITY_GET_VNODE_NAME: get_vnode_name
		// emulated in userland
	// FS_VNODE_CAPABILITY_PUT_VNODE: put_vnode
	// FS_VNODE_CAPABILITY_REMOVE_VNODE: remove_vnode
		// needed by Volume to clean up
 
	// asynchronous I/O
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_IO, io);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_CANCEL_IO, cancel_io);
 
	// cache file access
	ops->get_file_map = NULL;	// never used
 
	// common operations
	// FS_VNODE_CAPABILITY_IOCTL: ioctl
		// needed by Volume
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_SET_FLAGS, set_flags);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_SELECT, select);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_DESELECT, deselect);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_FSYNC, fsync);
 
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_READ_SYMLINK, read_symlink);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_CREATE_SYMLINK, create_symlink);
 
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_LINK, link);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_UNLINK, unlink);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_RENAME, rename);
 
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_ACCESS, access);
	// FS_VNODE_CAPABILITY_READ_STAT: read_stat
		// needed by Volume
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_WRITE_STAT, write_stat);
 
	// file operations
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_CREATE, create);
	// FS_VNODE_CAPABILITY_OPEN: open
		// mandatory
	// FS_VNODE_CAPABILITY_CLOSE: close
		// needed by Volume
	// FS_VNODE_CAPABILITY_FREE_COOKIE: free_cookie
		// needed by Volume
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_READ, read);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_WRITE, write);
 
	// directory operations
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_CREATE_DIR, create_dir);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_REMOVE_DIR, remove_dir);
	// FS_VNODE_CAPABILITY_OPEN_DIR: open_dir
		// mandatory
	// FS_VNODE_CAPABILITY_CLOSE_DIR: close_dir
		// needed by Volume
	// FS_VNODE_CAPABILITY_FREE_DIR_COOKIE: free_dir_cookie
		// needed by Volume
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_READ_DIR, read_dir);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_REWIND_DIR, rewind_dir);
 
	// attribute directory operations
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_OPEN_ATTR_DIR, open_attr_dir);
	// FS_VNODE_CAPABILITY_CLOSE_ATTR_DIR: close_attr_dir
		// needed by Volume
	// FS_VNODE_CAPABILITY_FREE_ATTR_DIR_COOKIE: free_attr_dir_cookie
		// needed by Volume
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_READ_ATTR_DIR, read_attr_dir);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_REWIND_ATTR_DIR, rewind_attr_dir);
 
	// attribute operations
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_CREATE_ATTR, create_attr);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_OPEN_ATTR, open_attr);
	// FS_VNODE_CAPABILITY_CLOSE_ATTR: close_attr
		// needed by Volume
	// FS_VNODE_CAPABILITY_FREE_ATTR_COOKIE: free_attr_cookie
		// needed by Volume
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_READ_ATTR, read_attr);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_WRITE_ATTR, write_attr);
 
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_READ_ATTR_STAT, read_attr_stat);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_WRITE_ATTR_STAT, write_attr_stat);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_RENAME_ATTR, rename_attr);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_REMOVE_ATTR, remove_attr);
 
	// support for node and FS layers
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_CREATE_SPECIAL_NODE,
		create_special_node);
	CLEAR_UNSUPPORTED(FS_VNODE_CAPABILITY_GET_SUPER_VNODE, get_super_vnode);
 
	#undef CLEAR_UNSUPPORTED
}
 
 
// _NodeListenerEventOccurred
void
FileSystem::_NodeListenerEventOccurred(NodeListenerProxy* proxy,
	const KMessage* event)
{
	// get a free port
	RequestPort* port = fPortPool.AcquirePort();
	if (port == NULL)
		return;
	PortReleaser _(&fPortPool, port);
 
	// prepare the request
	RequestAllocator allocator(port->GetPort());
	NodeMonitoringEventRequest* request;
	status_t error = AllocateRequest(allocator, &request);
	if (error != B_OK)
		return;
 
	error = allocator.AllocateData(request->event, event->Buffer(),
		event->ContentSize(), 1);
	if (error != B_OK)
		return;
 
	Thread* thread = thread_get_current_thread();
	request->team = thread->team->id;
	request->thread = thread->id;
	request->user = geteuid();
	request->group = getegid();
	request->listener = proxy->ClientListener();
 
	// send the request
	KernelRequestHandler handler(this, NODE_MONITORING_EVENT_REPLY);
	port->SendRequest(&allocator, &handler);
}
 
 
// _NotificationThreadEntry
int32
FileSystem::_NotificationThreadEntry(void* data)
{
	return ((FileSystem*)data)->_NotificationThread();
}
 
 
// _NotificationThread
int32
FileSystem::_NotificationThread()
{
	// process the notification requests until the FS is deleted
	while (!fTerminating) {
		if (fNotificationPort->InitCheck() != B_OK)
			return fNotificationPort->InitCheck();
		KernelRequestHandler handler(this, NO_REQUEST);
		fNotificationPort->HandleRequests(&handler, NULL,
			kNotificationRequestTimeout);
	}
	// We eat all remaining notification requests, so that they aren't
	// presented to the file system, when it is mounted next time.
	// TODO: We should probably use a special handler that sends an ack reply,
	// but ignores the requests otherwise.
	KernelRequestHandler handler(this, NO_REQUEST);
	fNotificationPort->HandleRequests(&handler, NULL, 0);
	return 0;
}