/*
 * Copyright 2004-2008, Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 * 		Axel Dörfler <axeld@pinc-software.de>
 * 		Ingo Weinhold <bonefish@cs.tu-berlin.de>
 */

#include "fssh_fs_cache.h"

#include <new>

#include <stdlib.h>

#include "DoublyLinkedList.h"
#include "fssh_kernel_export.h"
#include "fssh_lock.h"
#include "fssh_stdio.h"
#include "fssh_string.h"
#include "fssh_uio.h"
#include "fssh_unistd.h"
#include "hash.h"
#include "vfs.h"


#undef TRACE
//#define TRACE_FILE_CACHE
#ifdef TRACE_FILE_CACHE
#	define TRACE(x) fssh_dprintf x
#else
#	define TRACE(x) ;
#endif

using std::nothrow;


// This is a hacked version of the kernel file cache implementation. The main
// part of the implementation didn't change that much -- some code not needed
// in userland has been removed, most notably everything on the page level.
// On the downside, the cache now never caches anything, but will always
// directly work on the underlying device. Since that is usually cached by the
// host operating system, it shouldn't hurt much, though.

// maximum number of iovecs per request
#define MAX_IO_VECS			64	// 256 kB
#define MAX_FILE_IO_VECS	32
#define MAX_TEMP_IO_VECS	8

#define user_memcpy(a, b, c) fssh_memcpy(a, b, c)

#define PAGE_ALIGN(x) (((x) + (FSSH_B_PAGE_SIZE - 1)) & ~(FSSH_B_PAGE_SIZE - 1))
#define ASSERT(x)

namespace FSShell {

struct file_cache_ref;

typedef fssh_status_t (*cache_func)(file_cache_ref *ref, void *cookie,
	fssh_off_t offset, int32_t pageOffset, fssh_addr_t buffer,
	fssh_size_t bufferSize);

struct file_cache_ref {
	fssh_mutex					lock;
	fssh_mount_id				mountID;
	fssh_vnode_id				nodeID;
	struct vnode*				node;
	fssh_off_t					virtual_size;
};


fssh_status_t
file_cache_init()
{
	return FSSH_B_OK;
}


//	#pragma mark -


static fssh_status_t
read_from_file(file_cache_ref *ref, void *cookie, fssh_off_t offset,
	int32_t pageOffset, fssh_addr_t buffer, fssh_size_t bufferSize)
{
	fssh_iovec vec;
	vec.iov_base = (void *)buffer;
	vec.iov_len = bufferSize;

	fssh_mutex_unlock(&ref->lock);

	fssh_status_t status = vfs_read_pages(ref->node, cookie,
		offset + pageOffset, &vec, 1, &bufferSize);

	fssh_mutex_lock(&ref->lock);

	return status;
}


static fssh_status_t
write_to_file(file_cache_ref *ref, void *cookie, fssh_off_t offset,
	int32_t pageOffset, fssh_addr_t buffer, fssh_size_t bufferSize)
{
	fssh_iovec vec;
	vec.iov_base = (void *)buffer;
	vec.iov_len = bufferSize;

	fssh_mutex_unlock(&ref->lock);

	fssh_status_t status = vfs_write_pages(ref->node, cookie,
		offset + pageOffset, &vec, 1, &bufferSize);

	fssh_mutex_lock(&ref->lock);

	return status;
}


static inline fssh_status_t
satisfy_cache_io(file_cache_ref *ref, void *cookie, cache_func function,
	fssh_off_t offset, fssh_addr_t buffer, int32_t &pageOffset,
	fssh_size_t bytesLeft, fssh_off_t &lastOffset,
	fssh_addr_t &lastBuffer, int32_t &lastPageOffset, fssh_size_t &lastLeft)
{
	if (lastBuffer == buffer)
		return FSSH_B_OK;

	fssh_size_t requestSize = buffer - lastBuffer;

	fssh_status_t status = function(ref, cookie, lastOffset, lastPageOffset,
		lastBuffer, requestSize);
	if (status == FSSH_B_OK) {
		lastBuffer = buffer;
		lastLeft = bytesLeft;
		lastOffset = offset;
		lastPageOffset = 0;
		pageOffset = 0;
	}
	return status;
}


static fssh_status_t
cache_io(void *_cacheRef, void *cookie, fssh_off_t offset, fssh_addr_t buffer,
	fssh_size_t *_size, bool doWrite)
{
	if (_cacheRef == NULL)
		fssh_panic("cache_io() called with NULL ref!\n");

	file_cache_ref *ref = (file_cache_ref *)_cacheRef;
	fssh_off_t fileSize = ref->virtual_size;

	TRACE(("cache_io(ref = %p, offset = %lld, buffer = %p, size = %u, %s)\n",
		ref, offset, (void *)buffer, *_size, doWrite ? "write" : "read"));

	// out of bounds access?
	if (offset >= fileSize || offset < 0) {
		*_size = 0;
		return FSSH_B_OK;
	}

	int32_t pageOffset = offset & (FSSH_B_PAGE_SIZE - 1);
	fssh_size_t size = *_size;
	offset -= pageOffset;

	if ((uint64_t)offset + pageOffset + size > (uint64_t)fileSize) {
		// adapt size to be within the file's offsets
		size = fileSize - pageOffset - offset;
		*_size = size;
	}
	if (size == 0)
		return FSSH_B_OK;

	cache_func function;
	if (doWrite) {
		// in low memory situations, we bypass the cache beyond a
		// certain I/O size
		function = write_to_file;
	} else {
		function = read_from_file;
	}

	// "offset" and "lastOffset" are always aligned to B_PAGE_SIZE,
	// the "last*" variables always point to the end of the last
	// satisfied request part

	const uint32_t kMaxChunkSize = MAX_IO_VECS * FSSH_B_PAGE_SIZE;
	fssh_size_t bytesLeft = size, lastLeft = size;
	int32_t lastPageOffset = pageOffset;
	fssh_addr_t lastBuffer = buffer;
	fssh_off_t lastOffset = offset;

	MutexLocker locker(ref->lock);

	while (bytesLeft > 0) {
		// check if this page is already in memory
		fssh_size_t bytesInPage = fssh_min_c(
			fssh_size_t(FSSH_B_PAGE_SIZE - pageOffset), bytesLeft);

		if (bytesLeft <= bytesInPage)
			break;

		buffer += bytesInPage;
		bytesLeft -= bytesInPage;
		pageOffset = 0;
		offset += FSSH_B_PAGE_SIZE;

		if (buffer - lastBuffer + lastPageOffset >= kMaxChunkSize) {
			fssh_status_t status = satisfy_cache_io(ref, cookie, function,
				offset, buffer, pageOffset, bytesLeft, lastOffset,
				lastBuffer, lastPageOffset, lastLeft);
			if (status != FSSH_B_OK)
				return status;
		}
	}

	// fill the last remaining bytes of the request (either write or read)

	return function(ref, cookie, lastOffset, lastPageOffset, lastBuffer,
		lastLeft);
}


}	// namespace FSShell


//	#pragma mark - public FS API


using namespace FSShell;


void *
fssh_file_cache_create(fssh_mount_id mountID, fssh_vnode_id vnodeID,
	fssh_off_t size)
{
	TRACE(("file_cache_create(mountID = %d, vnodeID = %lld, size = %lld)\n",
		mountID, vnodeID, size));

	file_cache_ref *ref = new(nothrow) file_cache_ref;
	if (ref == NULL)
		return NULL;

	ref->mountID = mountID;
	ref->nodeID = vnodeID;
	ref->virtual_size = size;

	// get vnode
	fssh_status_t error = vfs_lookup_vnode(mountID, vnodeID, &ref->node);
	if (error != FSSH_B_OK) {
		fssh_dprintf("file_cache_create(): Failed get vnode %d:%" FSSH_B_PRIdINO
			": %s\n", mountID, vnodeID, fssh_strerror(error));
		delete ref;
		return NULL;
	}

	// create lock
	char buffer[32];
	fssh_snprintf(buffer, sizeof(buffer), "file cache %d:%" FSSH_B_PRIdINO,
		(int)mountID, vnodeID);
	fssh_mutex_init(&ref->lock, buffer);

	return ref;
}


void
fssh_file_cache_delete(void *_cacheRef)
{
	file_cache_ref *ref = (file_cache_ref *)_cacheRef;

	if (ref == NULL)
		return;

	TRACE(("file_cache_delete(ref = %p)\n", ref));

	fssh_mutex_lock(&ref->lock);
	fssh_mutex_destroy(&ref->lock);

	delete ref;
}


void
fssh_file_cache_enable(void *_cacheRef)
{
	fssh_panic("fssh_file_cache_enable() called");
}


fssh_status_t
fssh_file_cache_disable(void *_cacheRef)
{
	fssh_panic("fssh_file_cache_disable() called");
	return FSSH_B_ERROR;
}


bool
fssh_file_cache_is_enabled(void *_cacheRef)
{
	return true;
}


fssh_status_t
fssh_file_cache_set_size(void *_cacheRef, fssh_off_t size)
{
	file_cache_ref *ref = (file_cache_ref *)_cacheRef;

	TRACE(("file_cache_set_size(ref = %p, size = %lld)\n", ref, size));

	if (ref == NULL)
		return FSSH_B_OK;

	fssh_mutex_lock(&ref->lock);
	ref->virtual_size = size;
	fssh_mutex_unlock(&ref->lock);

	return FSSH_B_OK;
}


fssh_status_t
fssh_file_cache_sync(void *_cacheRef)
{
	file_cache_ref *ref = (file_cache_ref *)_cacheRef;
	if (ref == NULL)
		return FSSH_B_BAD_VALUE;

	return FSSH_B_OK;
}


fssh_status_t
fssh_file_cache_read(void *_cacheRef, void *cookie, fssh_off_t offset,
	void *bufferBase, fssh_size_t *_size)
{
	file_cache_ref *ref = (file_cache_ref *)_cacheRef;

	TRACE(("file_cache_read(ref = %p, offset = %lld, buffer = %p, size = %u)\n",
		ref, offset, bufferBase, *_size));

	return cache_io(ref, cookie, offset, (fssh_addr_t)bufferBase, _size, false);
}


fssh_status_t
fssh_file_cache_write(void *_cacheRef, void *cookie, fssh_off_t offset,
	const void *buffer, fssh_size_t *_size)
{
	file_cache_ref *ref = (file_cache_ref *)_cacheRef;

	fssh_status_t status = cache_io(ref, cookie, offset,
		(fssh_addr_t)const_cast<void *>(buffer), _size, true);
	TRACE(("file_cache_write(ref = %p, offset = %lld, buffer = %p, size = %u) = %d\n",
		ref, offset, buffer, *_size, status));

	return status;
}