/*
 * Copyright 2012 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Paweł Dziepak, pdziepak@quarnos.org
 */
 
 
#include "RootInode.h"
 
#include <string.h>
 
#include "MetadataCache.h"
#include "Request.h"
 
 
RootInode::RootInode()
	:
	fInfoCacheExpire(0),
	fName(NULL),
	fIOSize(0)
{
	mutex_init(&fInfoCacheLock, NULL);
}
 
 
RootInode::~RootInode()
{
	free(const_cast<char*>(fName));
	mutex_destroy(&fInfoCacheLock);
}
 
 
status_t
RootInode::ReadInfo(struct fs_info* info)
{
	ASSERT(info != NULL);
 
	status_t result = _UpdateInfo();
	if (result != B_OK)
		return result;
 
	memcpy(info, &fInfoCache, sizeof(struct fs_info));
 
	return B_OK;
}
 
 
status_t
RootInode::_UpdateInfo(bool force)
{
	if (!force && fInfoCacheExpire > time(NULL))
		return B_OK;
 
	MutexLocker _(fInfoCacheLock);
 
	if (fInfoCacheExpire > time(NULL))
		return B_OK;
 
	uint32 attempt = 0;
	do {
		RPC::Server* server = fFileSystem->Server();
		Request request(server, fFileSystem);
		RequestBuilder& req = request.Builder();
 
		req.PutFH(fInfo.fHandle);
		Attribute attr[] = { FATTR4_FILES_FREE, FATTR4_FILES_TOTAL,
			FATTR4_MAXREAD, FATTR4_MAXWRITE, FATTR4_SPACE_FREE,
			FATTR4_SPACE_TOTAL };
		req.GetAttr(attr, sizeof(attr) / sizeof(Attribute));
 
		status_t result = request.Send();
		if (result != B_OK)
			return result;
 
		ReplyInterpreter& reply = request.Reply();
 
		if (HandleErrors(attempt, reply.NFS4Error(), server))
			continue;
 
		reply.PutFH();
 
		AttrValue* values;
		uint32 count, next = 0;
		result = reply.GetAttr(&values, &count);
		if (result != B_OK)
			return result;
 
		if (count >= next && values[next].fAttribute == FATTR4_FILES_FREE) {
			fInfoCache.free_nodes = values[next].fData.fValue64;
			next++;
		}
 
		if (count >= next && values[next].fAttribute == FATTR4_FILES_TOTAL) {
			fInfoCache.total_nodes = values[next].fData.fValue64;
			next++;
		}
 
		uint64 ioSize = LONGLONG_MAX;
		if (count >= next && values[next].fAttribute == FATTR4_MAXREAD) {
			ioSize = min_c(ioSize, values[next].fData.fValue64);
			next++;
		}
 
		if (count >= next && values[next].fAttribute == FATTR4_MAXWRITE) {
			ioSize = min_c(ioSize, values[next].fData.fValue64);
			next++;
		}
 
		if (ioSize == LONGLONG_MAX)
			ioSize = 32768;
		if (ioSize == 0)
			ioSize = 4096;
		fInfoCache.io_size = ioSize;
		fInfoCache.block_size = ioSize;
		fIOSize = ioSize;
 
		if (count >= next && values[next].fAttribute == FATTR4_SPACE_FREE) {
			fInfoCache.free_blocks = values[next].fData.fValue64 / ioSize;
			next++;
		}
 
		if (count >= next && values[next].fAttribute == FATTR4_SPACE_TOTAL) {
			fInfoCache.total_blocks = values[next].fData.fValue64 / ioSize;
			next++;
		}
 
		delete[] values;
 
		break;
	} while (true);
 
	fInfoCache.flags = 	B_FS_IS_PERSISTENT | B_FS_IS_SHARED
		| B_FS_SUPPORTS_NODE_MONITORING;
 
	if (fFileSystem->NamedAttrs()
		|| fFileSystem->GetConfiguration().fEmulateNamedAttrs)
		fInfoCache.flags |= B_FS_HAS_MIME | B_FS_HAS_ATTR;
 
	strlcpy(fInfoCache.volume_name, fName, sizeof(fInfoCache.volume_name));
 
	fInfoCacheExpire = time(NULL) + MetadataCache::kExpirationTime;
 
	return B_OK;
}
 
 
bool
RootInode::ProbeMigration()
{
	uint32 attempt = 0;
	do {
		RPC::Server* server = fFileSystem->Server();
		Request request(server, fFileSystem);
		RequestBuilder& req = request.Builder();
 
		req.PutFH(fInfo.fHandle);
		req.Access();
 
		status_t result = request.Send();
		if (result != B_OK)
			continue;
 
		ReplyInterpreter& reply = request.Reply();
 
		if (reply.NFS4Error() == NFS4ERR_MOVED)
			return true;
 
		if (HandleErrors(attempt, reply.NFS4Error(), server))
			continue;
 
		return false;
	} while (true);
}
 
 
status_t
RootInode::GetLocations(AttrValue** attrv)
{
	ASSERT(attrv != NULL);
 
	uint32 attempt = 0;
	do {
		RPC::Server* server = fFileSystem->Server();
		Request request(server, fFileSystem);
		RequestBuilder& req = request.Builder();
 
		req.PutFH(fInfo.fHandle);
		Attribute attr[] = { FATTR4_FS_LOCATIONS };
		req.GetAttr(attr, sizeof(attr) / sizeof(Attribute));
 
		status_t result = request.Send();
		if (result != B_OK)
			return result;
 
		ReplyInterpreter& reply = request.Reply();
 
		if (HandleErrors(attempt, reply.NFS4Error(), server))
			continue;
 
		reply.PutFH();
 
		uint32 count;
		result = reply.GetAttr(attrv, &count);
		if (result != B_OK)
			return result;
		if (count < 1) {
			delete[] *attrv;
			return B_ERROR;
		}
 
		return B_OK;
	} while (true);
 
	return B_OK;
}
 
 
const char*
RootInode::Name() const
{
	ASSERT(fName != NULL);
	return fName;
}