haiku.git

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


#include <fs_interface.h>

#include <util/OpenHashTable.h>

#include <lock.h>

#include "FSCapabilities.h"
#include "LazyInitializable.h"
#include "Locker.h"
#include "RequestPort.h"
#include "RequestPortPool.h"
#include "String.h"
#include "Vector.h"


struct IOCtlInfo;
namespace BPrivate { class KMessage; }
using BPrivate::KMessage;
class Settings;
class Volume;


struct VNodeOps {
	int32				refCount;
	FSVNodeCapabilities	capabilities;
	fs_vnode_ops*		ops;
	VNodeOps*			hash_link;

	VNodeOps(const FSVNodeCapabilities& capabilities, fs_vnode_ops* ops)
		:
		refCount(1),
		capabilities(capabilities),
		ops(ops)
	{
	}

	~VNodeOps()
	{
		delete ops;
	}
};


struct VNodeOpsHashDefinition {
	typedef FSVNodeCapabilities	KeyType;
	typedef	VNodeOps			ValueType;

	size_t HashKey(const FSVNodeCapabilities& key) const
		{ return key.GetHashCode(); }
	size_t Hash(const VNodeOps* value) const
		{ return HashKey(value->capabilities); }
	bool Compare(const FSVNodeCapabilities& key, const VNodeOps* value) const
		{ return value->capabilities == key; }
	VNodeOps*& GetLink(VNodeOps* value) const
		{ return value->hash_link; }
};


class FileSystem {
public:
								FileSystem();
								~FileSystem();

			status_t			Init(const char* name, team_id team,
									Port::Info* infos, int32 infoCount,
									const FSCapabilities& capabilities);

			const char*			GetName() const;
			team_id				GetTeam() const	{ return fTeam; }

			const FSCapabilities& GetCapabilities() const;
	inline	bool				HasCapability(uint32 capability) const;

			RequestPortPool*	GetPortPool();

			status_t			Mount(fs_volume* fsVolume, const char* device,
									uint32 flags, const char* parameters,
									Volume** volume);
//			status_t			Initialize(const char* deviceName,
//									const char* parameters, size_t len);
			void				VolumeUnmounted(Volume* volume);

			Volume*				GetVolume(dev_t id);

			const IOCtlInfo*	GetIOCtlInfo(int command) const;

			status_t			AddSelectSyncEntry(selectsync* sync);
			void				RemoveSelectSyncEntry(selectsync* sync);
			bool				KnowsSelectSyncEntry(selectsync* sync);

			status_t			AddNodeListener(dev_t device, ino_t node,
									uint32 flags, void* listener);
			status_t			RemoveNodeListener(dev_t device, ino_t node,
									void* listener);

			VNodeOps*			GetVNodeOps(
									const FSVNodeCapabilities& capabilities);
			void				PutVNodeOps(VNodeOps* ops);

			bool				IsUserlandServerThread() const;

private:
			struct SelectSyncMap;
			struct NodeListenerKey;
			struct NodeListenerProxy;
			struct NodeListenerHashDefinition;

			friend class KernelDebug;
			friend struct NodeListenerProxy;

			typedef BOpenHashTable<VNodeOpsHashDefinition> VNodeOpsMap;
			typedef BOpenHashTable<NodeListenerHashDefinition> NodeListenerMap;


private:
			void				_InitVNodeOpsVector(fs_vnode_ops* ops,
									const FSVNodeCapabilities& capabilities);

			void				_NodeListenerEventOccurred(
									NodeListenerProxy* proxy,
									const KMessage* event);

	static	int32				_NotificationThreadEntry(void* data);
			int32				_NotificationThread();

private:
			Vector<Volume*>		fVolumes;
			mutex				fVolumeLock;
			VNodeOpsMap			fVNodeOps;
			mutex				fVNodeOpsLock;
			String				fName;
			team_id				fTeam;
			FSCapabilities		fCapabilities;
			RequestPort*		fNotificationPort;
			thread_id			fNotificationThread;
			RequestPortPool		fPortPool;
			SelectSyncMap*		fSelectSyncs;
			mutex				fNodeListenersLock;
			NodeListenerMap*	fNodeListeners;
			Settings*			fSettings;
			team_id				fUserlandServerTeam;
			bool				fInitialized;
	volatile bool				fTerminating;
};


// HasCapability
inline bool
FileSystem::HasCapability(uint32 capability) const
{
	return fCapabilities.Get(capability);
}

#endif	// USERLAND_FS_FILE_SYSTEM_H