/*
 * Copyright 2010, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "Transaction.h"

#include <errno.h>

#include <algorithm>

#include <AutoDeleter.h>

#include "BlockAllocator.h"
#include "DebugSupport.h"
#include "Volume.h"


static inline bool
swap_if_greater(Node*& a, Node*& b)
{
	if (a->BlockIndex() <= b->BlockIndex())
		return false;

	std::swap(a, b);
	return true;
}


// #pragma mark - Transaction


Transaction::Transaction(Volume* volume)
	:
	fVolume(volume),
	fSHA256(NULL),
	fCheckSum(NULL),
	fID(-1)
{
}


Transaction::~Transaction()
{
	Abort();

	delete fCheckSum;
	delete fSHA256;
}


status_t
Transaction::Start()
{
	ASSERT(fID < 0);

	status_t error = fBlockInfos.Init();
	if (error != B_OK)
		return error;

	if (fSHA256 == NULL) {
		fSHA256 = new(std::nothrow) SHA256;
		if (fSHA256 == NULL)
			return B_NO_MEMORY;
	}

	if (fCheckSum == NULL) {
		fCheckSum = new(std::nothrow) checksum_device_ioctl_check_sum;
		if (fCheckSum == NULL)
			return B_NO_MEMORY;
	}

	fVolume->TransactionStarted();

	fID = cache_start_transaction(fVolume->BlockCache());
	if (fID < 0) {
		fVolume->TransactionFinished();
		return fID;
	}

	fOldFreeBlockCount = fVolume->GetBlockAllocator()->FreeBlocks();

	return B_OK;
}


status_t
Transaction::StartAndAddNode(Node* node, uint32 flags)
{
	status_t error = Start();
	if (error != B_OK)
		return error;

	return AddNode(node, flags);
}


status_t
Transaction::Commit(const PostCommitNotification* notification1,
	const PostCommitNotification* notification2,
	const PostCommitNotification* notification3)
{
	ASSERT(fID >= 0);

	// flush the nodes
	for (NodeInfoList::Iterator it = fNodeInfos.GetIterator();
			NodeInfo* info = it.Next();) {
		status_t error = info->node->Flush(*this);
		if (error != B_OK) {
			Abort();
			return error;
		}
	}

	// Make sure the previous transaction is on disk. This is not particularly
	// performance friendly, but prevents race conditions between us setting
	// the new block check sums and the block writer deciding to write back the
	// old block data.
	status_t error = block_cache_sync(fVolume->BlockCache());
	if (error != B_OK) {
		Abort();
		return error;
	}

	// compute the new block check sums
	error = _UpdateBlockCheckSums();
	if (error != B_OK) {
		Abort();
		return error;
	}

	// commit the cache transaction
	error = cache_end_transaction(fVolume->BlockCache(), fID, NULL, NULL);
	if (error != B_OK) {
		Abort();
		return error;
	}

	// send notifications
	if (notification1 != NULL)
		notification1->NotifyPostCommit();
	if (notification2 != NULL)
		notification2->NotifyPostCommit();
	if (notification3 != NULL)
		notification3->NotifyPostCommit();

	// clean up
	_DeleteNodeInfosAndUnlock(false);

	fVolume->TransactionFinished();
	fID = -1;

	return B_OK;
}


void
Transaction::Abort()
{
	if (fID < 0)
		return;

	// abort the cache transaction
	cache_abort_transaction(fVolume->BlockCache(), fID);

	// revert the nodes
	for (NodeInfoList::Iterator it = fNodeInfos.GetIterator();
			NodeInfo* info = it.Next();) {
		info->node->RevertNodeData(info->oldNodeData);
	}

	// revert the block check sums
	_RevertBlockCheckSums();

	// clean up

	// delete the node infos
	_DeleteNodeInfosAndUnlock(true);

	// delete the block infos
	BlockInfo* blockInfo = fBlockInfos.Clear(true);
	while (blockInfo != NULL) {
		BlockInfo* nextInfo = blockInfo->hashNext;
		block_cache_put(fVolume->BlockCache(),
			blockInfo->indexAndCheckSum.blockIndex);
		delete nextInfo;
		blockInfo = nextInfo;
	}

	fVolume->GetBlockAllocator()->ResetFreeBlocks(fOldFreeBlockCount);

	fVolume->TransactionFinished();
	fID = -1;
}


status_t
Transaction::AddNode(Node* node, uint32 flags)
{
	ASSERT(fID >= 0);

	NodeInfo* info = _GetNodeInfo(node);
	if (info != NULL)
		return B_OK;

	info = new(std::nothrow) NodeInfo;
	if (info == NULL)
		return B_NO_MEMORY;

	if ((flags & TRANSACTION_NODE_ALREADY_LOCKED) == 0)
		node->WriteLock();

	info->node = node;
	info->oldNodeData = node->NodeData();
	info->flags = flags;

	fNodeInfos.Add(info);

	return B_OK;
}


status_t
Transaction::AddNodes(Node* node1, Node* node2, Node* node3)
{
	ASSERT(fID >= 0);

	// sort the nodes
	swap_if_greater(node1, node2);
	if (node3 != NULL && swap_if_greater(node2, node3))
		swap_if_greater(node1, node2);

	// add them
	status_t error = AddNode(node1);
	if (error == B_OK)
		error = AddNode(node2);
	if (error == B_OK && node3 != NULL)
		AddNode(node3);

	return error;
}


bool
Transaction::RemoveNode(Node* node)
{
	ASSERT(fID >= 0);

	NodeInfo* info = _GetNodeInfo(node);
	if (info == NULL)
		return false;

	fNodeInfos.Remove(info);

	_DeleteNodeInfoAndUnlock(info, false);

	return true;
}


void
Transaction::UpdateNodeFlags(Node* node, uint32 flags)
{
	ASSERT(fID >= 0);

	NodeInfo* info = _GetNodeInfo(node);
	if (info == NULL)
		return;

	info->flags = flags;
}


void
Transaction::KeepNode(Node* node)
{
	ASSERT(fID >= 0);

	NodeInfo* info = _GetNodeInfo(node);
	if (info == NULL)
		return;

	info->flags &= ~(uint32)TRANSACTION_DELETE_NODE;
}


status_t
Transaction::RegisterBlock(uint64 blockIndex)
{
	ASSERT(fID >= 0);

	// look it up -- maybe it's already registered
	BlockInfo* info = fBlockInfos.Lookup(blockIndex);
	if (info != NULL) {
		info->refCount++;
		return B_OK;
	}

	// nope, create a new one
	info = new(std::nothrow) BlockInfo;
	if (info == NULL)
		RETURN_ERROR(B_NO_MEMORY);
	ObjectDeleter<BlockInfo> infoDeleter(info);

	info->indexAndCheckSum.blockIndex = blockIndex;
	info->refCount = 1;
	info->dirty = false;

	// get the old check sum
	if (ioctl(fVolume->FD(), CHECKSUM_DEVICE_IOCTL_GET_CHECK_SUM,
			&info->indexAndCheckSum, sizeof(info->indexAndCheckSum)) < 0) {
		RETURN_ERROR(errno);
	}

	// get the data (we're fine with read-only)
	info->data = block_cache_get(fVolume->BlockCache(), blockIndex);
	if (info->data == NULL) {
		delete info;
		RETURN_ERROR(B_ERROR);
	}

	fBlockInfos.Insert(infoDeleter.Detach());

	return B_OK;
}


void
Transaction::PutBlock(uint64 blockIndex, const void* data)
{
	ASSERT(fID >= 0);

	BlockInfo* info = fBlockInfos.Lookup(blockIndex);
	if (info == NULL) {
		panic("checksumfs: Transaction::PutBlock(): unknown block %" B_PRIu64,
			blockIndex);
		return;
	}

	if (info->refCount == 0) {
		panic("checksumfs: Unbalanced Transaction::PutBlock(): for block %"
			B_PRIu64, blockIndex);
		return;
	}

	info->dirty |= data != NULL;

	if (--info->refCount == 0 && !info->dirty) {
		// block wasn't got successfully -- remove the info
		fBlockInfos.Remove(info);
		block_cache_put(fVolume->BlockCache(),
			info->indexAndCheckSum.blockIndex);
		delete info;
	}
}


Transaction::NodeInfo*
Transaction::_GetNodeInfo(Node* node) const
{
	for (NodeInfoList::ConstIterator it = fNodeInfos.GetIterator();
			NodeInfo* info = it.Next();) {
		if (node == info->node)
			return info;
	}

	return NULL;
}


void
Transaction::_DeleteNodeInfosAndUnlock(bool failed)
{
	while (NodeInfo* info = fNodeInfos.RemoveHead())
		_DeleteNodeInfoAndUnlock(info, failed);
}


void
Transaction::_DeleteNodeInfoAndUnlock(NodeInfo* info, bool failed)
{
	if (failed) {
		if ((info->flags & TRANSACTION_REMOVE_NODE_ON_ERROR) != 0)
			fVolume->RemoveNode(info->node);
		else if ((info->flags & TRANSACTION_UNREMOVE_NODE_ON_ERROR) != 0)
			fVolume->UnremoveNode(info->node);
	}

	if ((info->flags & TRANSACTION_DELETE_NODE) != 0)
		delete info->node;
	else if ((info->flags & TRANSACTION_KEEP_NODE_LOCKED) == 0)
		info->node->WriteUnlock();
	delete info;
}


status_t
Transaction::_UpdateBlockCheckSums()
{
	for (BlockInfoTable::Iterator it = fBlockInfos.GetIterator();
			BlockInfo* info = it.Next();) {
		if (info->refCount > 0) {
			panic("checksumfs: Transaction::Commit(): block %" B_PRIu64
				" still referenced", info->indexAndCheckSum.blockIndex);
		}

		if (!info->dirty)
			continue;

		// compute the check sum
		fSHA256->Init();
		fSHA256->Update(info->data, B_PAGE_SIZE);
		fCheckSum->blockIndex = info->indexAndCheckSum.blockIndex;
		fCheckSum->checkSum = fSHA256->Digest();

		// set it
		if (ioctl(fVolume->FD(), CHECKSUM_DEVICE_IOCTL_SET_CHECK_SUM, fCheckSum,
				sizeof(*fCheckSum)) < 0) {
			return errno;
		}
	}

	return B_OK;
}


status_t
Transaction::_RevertBlockCheckSums()
{
	for (BlockInfoTable::Iterator it = fBlockInfos.GetIterator();
			BlockInfo* info = it.Next();) {
		if (!info->dirty)
			continue;

		// set the old check sum
		if (ioctl(fVolume->FD(), CHECKSUM_DEVICE_IOCTL_SET_CHECK_SUM,
				&info->indexAndCheckSum, sizeof(info->indexAndCheckSum)) < 0) {
			return errno;
		}
	}

	return B_OK;
}


// #pragma mark - PostCommitNotification


PostCommitNotification::~PostCommitNotification()
{
}