// BlockCache.cpp
//
// Copyright (c) 2003, Ingo Weinhold (bonefish@cs.tu-berlin.de)
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// You can alternatively use *this file* under the terms of the the MIT
// license included in this package.

#include "BlockCache.h"

#include <new>

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <fs_cache.h>

#include "Block.h"
#include "Debug.h"
#include "reiserfs.h"

using std::nothrow;

/*!
	\class BlockCache
	\brief Implements a cache for disk blocks.

	The central methods are GetBlock() and PutBlock(). The former one
	requests a certain block and the latter tells the cache, that the caller
	is done with the block. When a block is unused it is either kept in
	memory until the next time it is needed or until its memory is needed
	for another block.
*/

// constructor
BlockCache::BlockCache()
	:
	fDevice(-1),
	fBlockSize(0),
	fBlockCount(0),
	fLock(),
	fBlocks(),
	fReads(0),
	fBlockGets(0),
	fBlockReleases(0)
{
}

// destructor
BlockCache::~BlockCache()
{
	fLock.Lock();
	for (int32 i = 0; Block *block = fBlocks.ItemAt(i); i++) {
		if (block->_GetRefCount() > 0) {
			INFORM(("WARNING: block not put: %p (ref count: %" B_PRId32 ")\n",
				block, block->_GetRefCount()));
		}
		delete block;
	}
	PRINT(("statistics: %" B_PRId64 " block reads\n", fReads));
	PRINT(("statistics: %" B_PRId64 " block gets\n", fBlockGets));
	PRINT(("statistics: %" B_PRId64 " block releases\n", fBlockReleases));
	if (fCacheHandle)
		block_cache_delete(fCacheHandle, false);
	fLock.Unlock();
}

// Init
status_t
BlockCache::Init(int device, uint64 blockCount, uint32 blockSize)
{
	if (device < 0 || blockSize <= 0)
		return B_BAD_VALUE;

	fDevice = device;
	fBlockSize = blockSize;
	fBlockCount = blockCount;

	// init block cache
	fCacheHandle = block_cache_create(fDevice, blockCount, blockSize, true);
	if (!fCacheHandle)
		return B_ERROR;

	return B_OK;
}

// GetBlock
status_t
BlockCache::GetBlock(Block *block)
{
	status_t error = (block ? B_OK : B_BAD_VALUE);
	if (error == B_OK) {
		fLock.Lock();
		if (fBlocks.HasItem(block))
			block->_Get();
		else
			error = B_BAD_VALUE;
		fLock.Unlock();
	}
	return error;
}

// GetBlock
status_t
BlockCache::GetBlock(uint64 number, Block **result)
{

	if (!result || number >= fBlockCount)
		return B_BAD_VALUE;

	fLock.Lock();

	// find the block in the cache
	status_t error = B_OK;
	Block *block = _FindBlock(number);
	if (!block) {
		// not found, read it from disk
		error = _ReadBlock(number, &block);
		if (error == B_OK)
			fBlocks.AddItem(block);
	}

	// increase the block's reference counter
	if (error == B_OK) {
		block->_Get();
		*result = block;
	}

	fLock.Unlock();
	return error;
}

// PutBlock
void
BlockCache::PutBlock(Block *block)
{
	fLock.Lock();
	if (block && fBlocks.HasItem(block)) {
		if (block->_Put()) {
			fBlocks.RemoveItem(block);
			delete block;
		}
	}
	fLock.Unlock();
}

// _FindBlock
Block *
BlockCache::_FindBlock(uint64 number)
{
	for (int32 i = 0; Block *block = fBlocks.ItemAt(i); i++) {
		if (block->GetNumber() == number)
			return block;
	}
	return NULL;
}

// _ReadBlock
status_t
BlockCache::_ReadBlock(uint64 number, Block **result)
{
	fReads++;	// statistics

	// get a free block and read the block data
	Block *block = new(nothrow) Block;
	if (!block)
		return B_NO_MEMORY;

	status_t error = block->_SetTo(this, number);

	// set the result / cleanup on error
	if (error == B_OK)
		*result = block;
	else if (block)
		delete block;
	return error;
}

// _GetBlock
void *
BlockCache::_GetBlock(off_t number) const
{
	fBlockGets++;	// statistics
	return const_cast<void*>(block_cache_get(fCacheHandle, number));
}

// _ReleaseBlock
void
BlockCache::_ReleaseBlock(off_t number, void *data) const
{
	fBlockReleases++;	// statistics
	block_cache_put(fCacheHandle, number);
}