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


#include "MetadataCache.h"

#include <NodeMonitor.h>

#include "Inode.h"


MetadataCache::MetadataCache(Inode* inode)
	:
	fExpire(0),
	fForceValid(false),
	fInode(inode),
	fInited(false)
{
	ASSERT(inode != NULL);
	mutex_init(&fLock, "nfs4 MetadataCache");
}


MetadataCache::~MetadataCache()
{
	mutex_destroy(&fLock);
}


status_t
MetadataCache::GetStat(struct stat* st)
{
	ASSERT(st != NULL);

	MutexLocker _(fLock);
	if (fForceValid || fExpire > time(NULL)) {
		// Do not touch other members of struct stat
		st->st_size = fStatCache.st_size;
		st->st_mode = fStatCache.st_mode;
		st->st_nlink = fStatCache.st_nlink;
		st->st_uid = fStatCache.st_uid;
		st->st_gid = fStatCache.st_gid;
		st->st_atim = fStatCache.st_atim;
		st->st_ctim = fStatCache.st_ctim;
		st->st_crtim = fStatCache.st_crtim;
		st->st_mtim = fStatCache.st_mtim;
		st->st_blksize = fStatCache.st_blksize;
		st->st_blocks = fStatCache.st_blocks;
		return B_OK;
	}

	return B_ERROR;
}


void
MetadataCache::SetStat(const struct stat& st)
{
	MutexLocker _(fLock);
	if (fInited)
		NotifyChanges(&fStatCache, &st);

	fStatCache = st;
	fExpire = time(NULL) + kExpirationTime;
	fInited = true;
}


void
MetadataCache::GrowFile(size_t newSize)
{
	MutexLocker _(fLock);
	off_t oldSize = fStatCache.st_size;
	fStatCache.st_size = max_c((off_t)newSize, fStatCache.st_size);

	if (oldSize != fStatCache.st_size) {
		notify_stat_changed(fInode->GetFileSystem()->DevId(), -1, fInode->ID(),
			B_STAT_SIZE);
	}
}


status_t
MetadataCache::GetAccess(uid_t uid, uint32* allowed)
{
	ASSERT(allowed != NULL);

	MutexLocker _(fLock);
	AVLTreeMap<uid_t, AccessEntry>::Iterator it = fAccessCache.Find(uid);
	if (!it.HasCurrent())
		return B_ENTRY_NOT_FOUND;

	if (!fForceValid)
		it.CurrentValuePointer()->fForceValid = false;

	if (!it.Current().fForceValid && it.Current().fExpire < time(NULL)) {
		it.Remove();
		return B_ERROR;
	}

	*allowed = it.Current().fAllowed;

	return B_OK;
}


void
MetadataCache::SetAccess(uid_t uid, uint32 allowed)
{
	MutexLocker _(fLock);
	AVLTreeMap<uid_t, AccessEntry>::Iterator it = fAccessCache.Find(uid);
	if (it.HasCurrent())
		it.Remove();

	AccessEntry entry;
	entry.fAllowed = allowed;
	entry.fExpire = time(NULL) + kExpirationTime;
	entry.fForceValid = fForceValid;

	fAccessCache.Insert(uid, entry);
}


status_t
MetadataCache::LockValid()
{
	MutexLocker _(fLock);
	if (fForceValid || fExpire > time(NULL)) {
		fForceValid = true;
		return B_OK;
	}

	return B_ERROR;
}


void
MetadataCache::UnlockValid()
{
	MutexLocker _(fLock);
	fExpire = time(NULL) + kExpirationTime;
	fForceValid = false;
}


void
MetadataCache::Dump(void (*xprintf)(const char*, ...))
{
	if (xprintf != kprintf) {
		status_t status = mutex_trylock(&fLock);
		if (status != B_OK) {
			xprintf("MetadataCache at %p locked\n", this);
			return;
		}
	}

	_DumpLocked(xprintf);

	if (xprintf != kprintf)
		mutex_unlock(&fLock);

	return;
}


void
MetadataCache::NotifyChanges(const struct stat* oldStat,
	const struct stat* newStat)
{
	ASSERT(oldStat != NULL);
	ASSERT(newStat != NULL);

	uint32 flags = 0;
	if (oldStat->st_size != newStat->st_size)
		flags |= B_STAT_SIZE;
	if (oldStat->st_mode != newStat->st_mode)
		flags |= B_STAT_MODE;
	if (oldStat->st_uid != newStat->st_uid)
		flags |= B_STAT_UID;
	if (oldStat->st_gid != newStat->st_gid)
		flags |= B_STAT_GID;

	if (memcmp(&oldStat->st_atim, &newStat->st_atim,
		sizeof(struct timespec)) == 0)
		flags |= B_STAT_ACCESS_TIME;

	if (memcmp(&oldStat->st_ctim, &newStat->st_ctim,
		sizeof(struct timespec)) == 0)
		flags |= B_STAT_CHANGE_TIME;

	if (memcmp(&oldStat->st_crtim, &newStat->st_crtim,
		sizeof(struct timespec)) == 0)
		flags |= B_STAT_CREATION_TIME;

	if (memcmp(&oldStat->st_mtim, &newStat->st_mtim,
		sizeof(struct timespec)) == 0)
		flags |= B_STAT_MODIFICATION_TIME;

	notify_stat_changed(fInode->GetFileSystem()->DevId(), -1, fInode->ID(),
		flags);
}


void
MetadataCache::_DumpLocked(void (*xprintf)(const char*, ...)) const
{
	xprintf("MetadataCache at %p for Inode at %p\n", this, fInode);
	xprintf("\tfInited %d, fForceValid %d\n", fInited, fForceValid);
	if (time(NULL) < fExpire)
		xprintf("\tExpires at %" B_PRIdTIME "\n", fExpire);
	else
		xprintf("\tExpired\n");

	xprintf("\tst_mode %" B_PRIo32 "\n", fStatCache.st_mode);
	xprintf("\tst_nlink %" B_PRId32 "\n", fStatCache.st_nlink);
	xprintf("\tst_uid %" B_PRIu32 "\n", fStatCache.st_uid);
	xprintf("\tst_gid %" B_PRIu32 "\n", fStatCache.st_gid);
	xprintf("\tst_size %" B_PRIdOFF "\n", fStatCache.st_size);

	return;
}