/*
 * Copyright 2012-2020 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Paweł Dziepak, pdziepak@quarnos.org
 */


#include "FileSystem.h"

#include <string.h>

#include <AutoDeleter.h>
#include <lock.h>
#include <util/Random.h>

#include "Request.h"
#include "RootInode.h"
#include "VnodeToInode.h"
#include "WorkQueue.h"


extern RPC::ServerManager* gRPCServerManager;
extern RPC::ProgramData* CreateNFS4Server(RPC::Server* serv);


FileSystem::FileSystem(const MountConfiguration& configuration)
	:
	fOpenCount(0),
	fOpenOwnerSequence(0),
	fNamedAttrs(true),
	fPath(NULL),
	fRoot(NULL),
	fServer(NULL),
	fId(1),
	fConfiguration(configuration)
{
	fOpenOwner = get_random<uint64>();

	mutex_init(&fOpenOwnerLock, "nfs4 FileSystem::fOpenOwnerLock");
	mutex_init(&fOpenLock, "nfs4 FileSystem::fOpenLock");
	mutex_init(&fDelegationLock, "nfs4 FileSystem::fDelegationLock");
	mutex_init(&fCreateFileLock, "nfs4 FileSystem::fCreateFileLock");
}


FileSystem::~FileSystem()
{
	if (fServer != NULL) {
		NFS4Server* server
			= reinterpret_cast<NFS4Server*>(fServer->PrivateData());
		if (server != NULL)
			server->RemoveFileSystem(this);
	}

	mutex_destroy(&fDelegationLock);
	mutex_destroy(&fOpenLock);
	mutex_destroy(&fOpenOwnerLock);
	mutex_destroy(&fCreateFileLock);

	if (fPath != NULL) {
		for (uint32 i = 0; fPath[i] != NULL; i++)
			free(const_cast<char*>(fPath[i]));
	}
	delete[] fPath;
}


static InodeNames*
GetInodeNames(const char** root, const char* _path)
{
	CALLED();

	ASSERT(_path != NULL);

	int i;
	char* path = strdup(_path);
	if (path == NULL)
		return NULL;
	MemoryDeleter _(path);

	if (root != NULL) {
		for (i = 0; root[i] != NULL; i++) {
			char* pathEnd = strchr(path, '/');
			if (pathEnd == path) {
				path++;
				i--;
				continue;
			}

			if (pathEnd == NULL) {
				path = NULL;
				break;
			} else
				path = pathEnd + 1;
		}
	}

	InodeNames* names = NULL;
	if (path == NULL) {
		names = new InodeNames;
		if (names == NULL)
			return NULL;

		names->AddName(NULL, "");
		return names;
	}

	do {
		char* pathEnd = strchr(path, '/');
		if (pathEnd != NULL)
			*pathEnd = '\0';

		InodeNames* name = new InodeNames;
		if (name == NULL) {
			delete names;
			return NULL;
		}

		name->AddName(names, path);
		names = name;
		if (pathEnd == NULL)
			break;

		path = pathEnd + 1;
	} while (*path != '\0');

	return names;
}


status_t
FileSystem::Mount(FileSystem** _fs, RPC::Server* serv, const char* serverName, const char* fsPath,
	fs_volume* volume, const MountConfiguration& configuration)
{
	CALLED();

	ASSERT(_fs != NULL);
	ASSERT(serv != NULL);
	ASSERT(fsPath != NULL);

	FileSystem* fs = new(std::nothrow) FileSystem(configuration);
	if (fs == NULL)
		return B_NO_MEMORY;
	ObjectDeleter<FileSystem> fsDeleter(fs);

	Request request(serv, fs, geteuid(), getegid());
	RequestBuilder& req = request.Builder();

	req.PutRootFH();

	uint32 lookupCount = 0;
	status_t result = _ParsePath(req, lookupCount, fsPath);
	if (result != B_OK)
		return result;

	req.GetFH();
	req.Access();

	Attribute attr[] = { FATTR4_SUPPORTED_ATTRS, FATTR4_FH_EXPIRE_TYPE,
		FATTR4_FSID, FATTR4_FS_LOCATIONS };
	req.GetAttr(attr, sizeof(attr) / sizeof(Attribute));

	result = request.Send();
	if (result != B_OK)
		return result;

	ReplyInterpreter& reply = request.Reply();

	reply.PutRootFH();

	for (uint32 i = 0; i < lookupCount; i++)
		reply.LookUp();

	FileHandle fh;
	reply.GetFH(&fh);

	uint32 allowed;
	result = reply.Access(NULL, &allowed);
	if (result != B_OK)
		return result;
	else if ((allowed & (ACCESS4_READ | ACCESS4_LOOKUP))
		!= (ACCESS4_READ | ACCESS4_LOOKUP))
		return B_PERMISSION_DENIED;

	AttrValue* values;
	uint32 count;
	result = reply.GetAttr(&values, &count);
	if (result != B_OK || count < 2)
		return result;

	// FATTR4_SUPPORTED_ATTRS is mandatory
	memcpy(fs->fSupAttrs, &values[0].fData.fValue64, sizeof(fs->fSupAttrs));

	// FATTR4_FH_EXPIRE_TYPE is mandatory
	fs->fExpireType = values[1].fData.fValue32;

	// FATTR4_FSID is mandatory
	FileSystemId* fsid
		= reinterpret_cast<FileSystemId*>(values[2].fData.fPointer);

	if (count == 4 && values[3].fAttribute == FATTR4_FS_LOCATIONS) {
		FSLocations* locs
			= reinterpret_cast<FSLocations*>(values[3].fData.fLocations);

		fs->fPath = locs->fRootPath;
		locs->fRootPath = NULL;
	} else
		fs->fPath = NULL;

	FileInfo fi;

	fs->fServer = serv;
	fs->fDevId = volume->id;
	fs->fFsId = *fsid;
	fs->fFsVolume = volume;

	fi.fHandle = fh;

	fi.fNames = GetInodeNames(fs->fPath, fsPath);
	if (fi.fNames == NULL) {
		delete[] values;
		return B_NO_MEMORY;
	}
	fi.fNames->fHandle = fh;

	delete[] values;

	Inode* inode;
	result = Inode::CreateInode(fs, fi, &inode);
	if (result != B_OK)
		return result;
	RootInode* rootInode = reinterpret_cast<RootInode*>(inode);
	fs->fRoot = rootInode;

	char* fsName = strdup(fsPath);
	if (fsName == NULL)
		return B_NO_MEMORY;
	for (int i = strlen(fsName) - 1; i >= 0 && fsName[i] == '/'; i--)
		fsName[i] = '\0';

	char* name = strrchr(fsName, '/');
	if (name != NULL)
		rootInode->SetName(name + 1);
	else if (fsName[0] != '\0')
		rootInode->SetName(fsName);
	else
		rootInode->SetName(serverName);
	free(fsName);

	fs->NFSServer()->AddFileSystem(fs);
	*_fs = fs;

	fsDeleter.Detach();
	return B_OK;
}


status_t
FileSystem::GetInode(ino_t id, Inode** _inode)
{
	CALLED();

	ASSERT(_inode != NULL);

	FileInfo fi;
	status_t result = fInoIdMap.GetFileInfo(&fi, id);
	if (result != B_OK)
		return result;

	Inode* inode;
	result = Inode::CreateInode(this, fi, &inode);
	if (result != B_OK)
		return result;

	*_inode = inode;
	return B_OK;
}


status_t
FileSystem::Migrate(const RPC::Server* serv)
{
	CALLED();

	ASSERT(serv != NULL);

	MutexLocker _(fOpenLock);
	if (serv != fServer)
		return B_OK;

	if (!fRoot->ProbeMigration())
		return B_OK;

	AttrValue* values;
	status_t result = fRoot->GetLocations(&values);
	if (result != B_OK)
		return result;

	FSLocations* locs
		= reinterpret_cast<FSLocations*>(values[0].fData.fLocations);

	RPC::Server* server = fServer;
	for (uint32 i = 0; i < locs->fCount; i++) {
		for (uint32 j = 0; j < locs->fLocations[i].fCount; j++) {
			AddressResolver resolver(locs->fLocations[i].fLocations[j]);

			if (gRPCServerManager->Acquire(&fServer, &resolver,
					CreateNFS4Server) == B_OK) {

				if (fPath != NULL) {
					for (uint32 i = 0; fPath[i] != NULL; i++)
						free(const_cast<char*>(fPath[i]));
				}
				delete[] fPath;

				fPath = locs->fLocations[i].fRootPath;
				locs->fLocations[i].fRootPath = NULL;

				if (fPath == NULL) {
					gRPCServerManager->Release(fServer);
					fServer = server;

					delete[] values;
					return B_NO_MEMORY;
				}

				break;
			}
		}
	}

	delete[] values;

	if (server == fServer) {
		gRPCServerManager->Release(server);
		return B_ERROR;
	}

	NFS4Server* old = reinterpret_cast<NFS4Server*>(server->PrivateData());
	old->RemoveFileSystem(this);
	NFSServer()->AddFileSystem(this);

	gRPCServerManager->Release(server);

	return B_OK;
}


DoublyLinkedList<OpenState>&
FileSystem::OpenFilesLock()
{
	CALLED();

	mutex_lock(&fOpenLock);
	return fOpenFiles;
}


void
FileSystem::OpenFilesUnlock()
{
	CALLED();

	mutex_unlock(&fOpenLock);
}


void
FileSystem::AddOpenFile(OpenState* state)
{
	CALLED();

	ASSERT(state != NULL);

	MutexLocker _(fOpenLock);

	fOpenFiles.InsertBefore(fOpenFiles.Head(), state);

	NFSServer()->IncUsage();
}


void
FileSystem::RemoveOpenFile(OpenState* state)
{
	CALLED();

	ASSERT(state != NULL);

	MutexLocker _(fOpenLock);

	fOpenFiles.Remove(state);

	NFSServer()->DecUsage();
}


DoublyLinkedList<Delegation>&
FileSystem::DelegationsLock()
{
	CALLED();

	mutex_lock(&fDelegationLock);
	return fDelegationList;
}


void
FileSystem::DelegationsUnlock()
{
	CALLED();

	mutex_unlock(&fDelegationLock);
}


void
FileSystem::AddDelegation(Delegation* delegation)
{
	CALLED();

	ASSERT(delegation != NULL);

	MutexLocker _(fDelegationLock);

	fDelegationList.InsertBefore(fDelegationList.Head(), delegation);

	fHandleToDelegation.Remove(delegation->fInfo.fHandle);
	fHandleToDelegation.Insert(delegation->fInfo.fHandle, delegation);
}


void
FileSystem::RemoveDelegation(Delegation* delegation)
{
	CALLED();

	ASSERT(delegation != NULL);

	MutexLocker _(fDelegationLock);

	fDelegationList.Remove(delegation);
	fHandleToDelegation.Remove(delegation->fInfo.fHandle);
}


Delegation*
FileSystem::GetDelegation(const FileHandle& handle)
{
	CALLED();

	MutexLocker _(fDelegationLock);

	AVLTreeMap<FileHandle, Delegation*>::Iterator it;
	it = fHandleToDelegation.Find(handle);
	if (!it.HasCurrent())
		return NULL;

	return it.Current();
}


/*! Mark this node removed and free it to ensure that no operation will try to use it.
	@pre We hold a VFS ref to this node.
	@post The ref needs to be released by the caller.
*/
status_t
FileSystem::TrashStaleNode(Inode* inode)
{
	ino_t ino = inode->ID();
	INFORM("TrashStaleNode %p %" B_PRIdINO "\n", inode, ino);

	inode->SetStale();

	status_t result = remove_vnode(fFsVolume, ino);
	ASSERT(result == B_OK);

	return result;
}


/*! Check whether the server node still has any hard links (including links that the client may be
	unaware of).  If none, mark the client node removed.
*/
status_t
FileSystem::TrashIfStale(Inode* inode)
{
	struct stat stat;
	status_t result = inode->Stat(&stat, NULL, true);
	if (result != B_OK)
		result = TrashStaleNode(inode);

	return result;
}


/*! Used when creating a file to check for a stale node with the same ino. If it exists,
	the stale node is deleted.
	@param newID The file ID assigned by the server to a file now being created.
	@param handle The handle assigned by the server to the same file.
	@pre The caller has not yet updated fInoIdMap with the FileInfo of the file that we are
	creating. The VFS list of vnodes has also not been updated yet.
	@post Any stale node object with this ID is gone. Any stale entry in fInoIdMap is still
	present, and will be replaced when the caller calls fInoIdMap->AddName.
*/
void
FileSystem::EnsureNoCollision(ino_t newId, const FileHandle& handle)
{
	VnodeToInode* existingVti = NULL;
	status_t result = get_vnode(fFsVolume, newId, reinterpret_cast<void**>(&existingVti));
	if (result == B_OK) {
		// We haven't finished creating the new node yet, so whatever get_vnode returned must be
		// stale since the server just re-issued its inode number.
		ASSERT(handle != existingVti->GetPointer()->fInfo.fHandle);
		result = TrashStaleNode(existingVti->GetPointer());
		if (result != B_OK)
			INFORM("EnsureNoCollision: Couldn't trash stale node %" B_PRIdINO "\n", newId);
		put_vnode(fFsVolume, newId);
	}

	return;
}


/*!	Delete a name from a client-side node after someone else has unlinked that name on the server
	side.  If that was the last name known to the client, call TrashIfStale.
	@param missingName A previously cached file name that is no longer valid.
*/
void
FileSystem::ServerUnlinkCleanup(ino_t id, Inode* parent, const char* missingName)
{
	FileInfo fileInfo;
	status_t result = fInoIdMap.GetFileInfo(&fileInfo, id);

	VnodeToInode* vti = NULL;
	result = get_vnode(fFsVolume, id, reinterpret_cast<void**>(&vti));
	if (result == B_OK) {
		bool noRemainingNames = false;
		noRemainingNames = fileInfo.fNames->RemoveName(parent->fInfo.fNames, missingName);
		if (noRemainingNames) {
			// This client knows of no hard links to this node.
			result = TrashIfStale(vti->GetPointer());
			if (result != B_OK)
				INFORM("ServerUnlinkCleanup: Couldn't trash stale node %" B_PRIdINO "\n", id);
		}
		put_vnode(fFsVolume, id);
	}

	return;
}


void
FileSystem::Dump(void (*xprintf)(const char*, ...))
{
	xprintf("FileSystem at %p\n", this);
	bool dumpDelegations = true;
	bool dumpOpenFiles = true;
	if (xprintf != kprintf) {
		status_t status = mutex_trylock(&fDelegationLock);
		if (status != B_OK)
			dumpDelegations = false;
		status = mutex_trylock(&fOpenLock);
		if (status != B_OK)
			dumpOpenFiles = false;
	}

	_DumpLocked(xprintf, dumpDelegations, dumpOpenFiles);

	if (xprintf != kprintf) {
		if (dumpDelegations)
			mutex_unlock(&fDelegationLock);
		if (dumpOpenFiles)
			mutex_unlock(&fOpenLock);
	}

	xprintf("\n");
	fInoIdMap.Dump(xprintf);

	xprintf("\n");
	gWorkQueue->Dump(xprintf);

	return;
}


status_t
FileSystem::_ParsePath(RequestBuilder& req, uint32& count, const char* _path)
{
	CALLED();

	ASSERT(_path != NULL);

	char* path = strdup(_path);
	if (path == NULL)
		return B_NO_MEMORY;

	char* pathStart = path;
	char* pathEnd;

	while (pathStart != NULL) {
		pathEnd = strchr(pathStart, '/');
		if (pathEnd != NULL)
			*pathEnd = '\0';

		if (pathEnd != pathStart) {
			if (!strcmp(pathStart, "..")) {
				req.LookUpUp();
				count++;
			} else if (strcmp(pathStart, ".")) {
				req.LookUp(pathStart);
				count++;
			}
		}

		if (pathEnd != NULL && pathEnd[1] != '\0')
			pathStart = pathEnd + 1;
		else
			pathStart = NULL;
	}
	free(path);

	return B_OK;
}


void
FileSystem::_DumpLocked(void (*xprintf)(const char*, ...), bool dumpDelegations,
	bool dumpOpenFiles) const
{
	xprintf("\tRootInode at %p\n", fRoot);

	xprintf("\tfOpenFiles\n", fOpenFiles);
	if (dumpOpenFiles) {
		uint64 entries = 0;
		for (DoublyLinkedList<OpenState>::ConstIterator it = fOpenFiles.GetIterator();
			const OpenState* state = it.Next(); ++entries) {
			xprintf("\t\tOpenState at %p for ino %" B_PRIdINO "\n", state, state->fInfo.fFileId);
		}
		if (entries == 0)
			xprintf("\t\tNone\n");
	} else {
		xprintf("\tfOpenLock is locked\n");
	}

	xprintf("\tDelegations\n");
	if (dumpDelegations) {
		uint64 entries = 0;
		for (DoublyLinkedList<Delegation>::ConstIterator it = fDelegationList.GetIterator();
			const Delegation* del = it.Next(); ++entries) {
			xprintf("\t\tDelegation at %p for Inode at %p (ino %" B_PRIdINO ")\n", del,
				del->GetInode(), del->GetInode()->ID());
		}
		if (entries == 0)
			xprintf("\t\tNone");
	} else {
		xprintf("\tfDelegationLock is locked\n");
	}

	return;
}