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


//! kernel-side implementation of the messaging service


#include <new>

#include <AutoDeleter.h>
#include <BytePointer.h>
#include <KernelExport.h>
#include <KMessage.h>
#include <messaging.h>
#include <MessagingServiceDefs.h>

#include "MessagingService.h"

//#define TRACE_MESSAGING_SERVICE
#ifdef TRACE_MESSAGING_SERVICE
#	define PRINT(x) dprintf x
#else
#	define PRINT(x) ;
#endif


using namespace std;

static MessagingService *sMessagingService = NULL;

static const int32 kMessagingAreaSize = B_PAGE_SIZE * 4;


// #pragma mark - MessagingArea


MessagingArea::MessagingArea()
{
}


MessagingArea::~MessagingArea()
{
	if (fID >= 0)
		delete_area(fID);
}


MessagingArea *
MessagingArea::Create(sem_id lockSem, sem_id counterSem)
{
	// allocate the object on the heap
	MessagingArea *area = new(nothrow) MessagingArea;
	if (!area)
		return NULL;

	// create the area
	area->fID = create_area("messaging", (void**)&area->fHeader,
		B_ANY_KERNEL_ADDRESS, kMessagingAreaSize, B_FULL_LOCK,
		B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA | B_CLONEABLE_AREA);
	if (area->fID < 0) {
		delete area;
		return NULL;
	}

	// finish the initialization of the object
	area->fSize = kMessagingAreaSize;
	area->fLockSem = lockSem;
	area->fCounterSem = counterSem;
	area->fNextArea = NULL;
	area->InitHeader();

	return area;
}


void
MessagingArea::InitHeader()
{
	fHeader->lock_counter = 1;			// create locked
	fHeader->size = fSize;
	fHeader->kernel_area = fID;
	fHeader->next_kernel_area = (fNextArea ? fNextArea->ID() : -1);
	fHeader->command_count = 0;
	fHeader->first_command = 0;
	fHeader->last_command = 0;
}


bool
MessagingArea::CheckCommandSize(int32 dataSize)
{
	int32 size = sizeof(messaging_command) + dataSize;

	return (dataSize >= 0
		&& size <= kMessagingAreaSize - (int32)sizeof(messaging_area_header));
}


bool
MessagingArea::Lock()
{
	// benaphore-like locking
	if (atomic_add(&fHeader->lock_counter, 1) == 0)
		return true;

	return (acquire_sem(fLockSem) == B_OK);
}


void
MessagingArea::Unlock()
{
	if (atomic_add(&fHeader->lock_counter, -1) > 1)
		release_sem(fLockSem);
}


area_id
MessagingArea::ID() const
{
	return fID;
}


int32
MessagingArea::Size() const
{
	return fSize;
}


bool
MessagingArea::IsEmpty() const
{
	return fHeader->command_count == 0;
}


void *
MessagingArea::AllocateCommand(uint32 commandWhat, int32 dataSize,
	bool &wasEmpty)
{
	int32 size = sizeof(messaging_command) + dataSize;

	if (dataSize < 0 || size > fSize - (int32)sizeof(messaging_area_header))
		return NULL;

	// the area is used as a ring buffer
	int32 startOffset = sizeof(messaging_area_header);

	// the simple case first: the area is empty
	int32 commandOffset;
	wasEmpty = (fHeader->command_count == 0);
	if (wasEmpty) {
		commandOffset = startOffset;

		// update the header
		fHeader->command_count++;
		fHeader->first_command = fHeader->last_command = commandOffset;
	} else {
		int32 firstCommandOffset = fHeader->first_command;
		int32 lastCommandOffset = fHeader->last_command;
		int32 firstCommandSize;
		int32 lastCommandSize;
		messaging_command *firstCommand = _CheckCommand(firstCommandOffset,
			firstCommandSize);
		messaging_command *lastCommand = _CheckCommand(lastCommandOffset,
			lastCommandSize);
		if (!firstCommand || !lastCommand) {
			// something has been screwed up
			return NULL;
		}

		// find space for the command
		if (firstCommandOffset <= lastCommandOffset) {
			// not wrapped
			// try to allocate after the last command
			if (size <= fSize - (lastCommandOffset + lastCommandSize)) {
				commandOffset = (lastCommandOffset + lastCommandSize);
			} else {
				// is there enough space before the first command?
				if (size > firstCommandOffset - startOffset)
					return NULL;
				commandOffset = startOffset;
			}
		} else {
			// wrapped: we can only allocate between the last and the first
			// command
			commandOffset = lastCommandOffset + lastCommandSize;
			if (size > firstCommandOffset - commandOffset)
				return NULL;
		}

		// update the header and the last command
		fHeader->command_count++;
		lastCommand->next_command = fHeader->last_command = commandOffset;
	}

	// init the command
	BytePointer<messaging_command> command(fHeader);
	command += commandOffset;
	command->next_command = 0;
	command->command = commandWhat;
	command->size = size;

	return command->data;
}


void
MessagingArea::CommitCommand()
{
	// TODO: If invoked while locked, we should supply B_DO_NOT_RESCHEDULE.
	release_sem(fCounterSem);
}


void
MessagingArea::SetNextArea(MessagingArea *area)
{
	fNextArea = area;
	fHeader->next_kernel_area = (fNextArea ? fNextArea->ID() : -1);
}


MessagingArea *
MessagingArea::NextArea() const
{
	return fNextArea;
}


messaging_command *
MessagingArea::_CheckCommand(int32 offset, int32 &size)
{
	// check offset
	if (offset < (int32)sizeof(messaging_area_header)
		|| offset + (int32)sizeof(messaging_command) > fSize
		|| (offset & 0x3)) {
		return NULL;
	}

	// get and check size
	BytePointer<messaging_command> command(fHeader);
	command += offset;
	size = command->size;
	if (size < (int32)sizeof(messaging_command))
		return NULL;
	size = (size + 3) & ~0x3;	// align
	if (offset + size > fSize)
		return NULL;

	return &command;
}


// #pragma mark - MessagingService


MessagingService::MessagingService()
	:
	fFirstArea(NULL),
	fLastArea(NULL)
{
	recursive_lock_init(&fLock, "messaging service");
}


MessagingService::~MessagingService()
{
	// Should actually never be called. Once created the service stays till the
	// bitter end.
}


status_t
MessagingService::InitCheck() const
{
	return B_OK;
}


bool
MessagingService::Lock()
{
	return recursive_lock_lock(&fLock) == B_OK;
}


void
MessagingService::Unlock()
{
	recursive_lock_unlock(&fLock);
}


status_t
MessagingService::RegisterService(sem_id lockSem, sem_id counterSem,
	area_id &areaID)
{
	// check, if a service is already registered
	if (fFirstArea)
		return B_BAD_VALUE;

	status_t error = B_OK;

	// check, if the semaphores are valid and belong to the calling team
	thread_info threadInfo;
	error = get_thread_info(find_thread(NULL), &threadInfo);

	sem_info lockSemInfo;
	if (error == B_OK)
		error = get_sem_info(lockSem, &lockSemInfo);

	sem_info counterSemInfo;
	if (error == B_OK)
		error = get_sem_info(counterSem, &counterSemInfo);

	if (error != B_OK)
		return error;

	if (threadInfo.team != lockSemInfo.team
		|| threadInfo.team != counterSemInfo.team) {
		return B_BAD_VALUE;
	}

	// create an area
	fFirstArea = fLastArea = MessagingArea::Create(lockSem, counterSem);
	if (!fFirstArea)
		return B_NO_MEMORY;

	areaID = fFirstArea->ID();
	fFirstArea->Unlock();

	// store the server team and the semaphores
	fServerTeam = threadInfo.team;
	fLockSem = lockSem;
	fCounterSem = counterSem;

	return B_OK;
}


status_t
MessagingService::UnregisterService()
{
	// check, if the team calling this function is indeed the server team
	thread_info threadInfo;
	status_t error = get_thread_info(find_thread(NULL), &threadInfo);
	if (error != B_OK)
		return error;

	if (threadInfo.team != fServerTeam)
		return B_BAD_VALUE;

	// delete all areas
	while (fFirstArea) {
		MessagingArea *area = fFirstArea;
		fFirstArea = area->NextArea();
		delete area;
	}
	fLastArea = NULL;

	// unset the other members
	fLockSem = -1;
	fCounterSem = -1;
	fServerTeam = -1;

	return B_OK;
}


status_t
MessagingService::SendMessage(const void *message, int32 messageSize,
	const messaging_target *targets, int32 targetCount)
{
PRINT(("MessagingService::SendMessage(%p, %ld, %p, %ld)\n", message,
messageSize, targets, targetCount));
	if (!message || messageSize <= 0 || !targets || targetCount <= 0)
		return B_BAD_VALUE;

	int32 dataSize = sizeof(messaging_command_send_message)
		+ targetCount * sizeof(messaging_target) + messageSize;

	// allocate space for the command
	MessagingArea *area;
	void *data;
	bool wasEmpty;
	status_t error = _AllocateCommand(MESSAGING_COMMAND_SEND_MESSAGE, dataSize,
		area, data, wasEmpty);
	if (error != B_OK) {
		PRINT(("MessagingService::SendMessage(): Failed to allocate space for "
			"send message command.\n"));
		return error;
	}
PRINT(("  Allocated space for send message command: area: %p, data: %p, "
"wasEmpty: %d\n", area, data, wasEmpty));

	// prepare the command
	messaging_command_send_message *command
		= (messaging_command_send_message*)data;
	command->message_size = messageSize;
	command->target_count = targetCount;
	memcpy(command->targets, targets, sizeof(messaging_target) * targetCount);
	memcpy((char*)command + (dataSize - messageSize), message, messageSize);

	// shoot
	area->Unlock();
	if (wasEmpty)
		area->CommitCommand();

	return B_OK;
}


status_t
MessagingService::_AllocateCommand(int32 commandWhat, int32 size,
	MessagingArea *&area, void *&data, bool &wasEmpty)
{
	if (!fFirstArea)
		return B_NO_INIT;

	if (!MessagingArea::CheckCommandSize(size))
		return B_BAD_VALUE;

	// delete the discarded areas (save one)
	ObjectDeleter<MessagingArea> discardedAreaDeleter;
	MessagingArea *discardedArea = NULL;

	while (fFirstArea != fLastArea) {
		area = fFirstArea;
		area->Lock();
		if (!area->IsEmpty()) {
			area->Unlock();
			break;
		}

		PRINT(("MessagingService::_AllocateCommand(): Discarding area: %p\n",
			area));

		fFirstArea = area->NextArea();
		area->SetNextArea(NULL);
		discardedArea = area;
		discardedAreaDeleter.SetTo(area);
	}

	// allocate space for the command in the last area
	area = fLastArea;
	area->Lock();
	data = area->AllocateCommand(commandWhat, size, wasEmpty);

	if (!data) {
		// not enough space in the last area: create a new area or reuse a
		// discarded one
		if (discardedArea) {
			area = discardedAreaDeleter.Detach();
			area->InitHeader();
			PRINT(("MessagingService::_AllocateCommand(): Not enough space "
				"left in current area. Recycling discarded one: %p\n", area));
		} else {
			area = MessagingArea::Create(fLockSem, fCounterSem);
			PRINT(("MessagingService::_AllocateCommand(): Not enough space "
				"left in current area. Allocated new one: %p\n", area));
		}
		if (!area) {
			fLastArea->Unlock();
			return B_NO_MEMORY;
		}

		// add the new area
		fLastArea->SetNextArea(area);
		fLastArea->Unlock();
		fLastArea = area;

		// allocate space for the command
		data = area->AllocateCommand(commandWhat, size, wasEmpty);

		if (!data) {
			// that should never happen
			area->Unlock();
			return B_NO_MEMORY;
		}
	}

	return B_OK;
}


// #pragma mark - kernel private


status_t
send_message(const void *message, int32 messageSize,
	const messaging_target *targets, int32 targetCount)
{
	// check, if init_messaging_service() has been called yet
	if (!sMessagingService)
		return B_NO_INIT;

	if (!sMessagingService->Lock())
		return B_BAD_VALUE;

	status_t error = sMessagingService->SendMessage(message, messageSize,
		targets, targetCount);

	sMessagingService->Unlock();

	return error;
}


status_t
send_message(const KMessage *message, const messaging_target *targets,
	int32 targetCount)
{
	if (!message)
		return B_BAD_VALUE;

	return send_message(message->Buffer(), message->ContentSize(), targets,
		targetCount);
}


status_t
init_messaging_service()
{
	static char buffer[sizeof(MessagingService)];

	if (!sMessagingService)
		sMessagingService = new(buffer) MessagingService;

	status_t error = sMessagingService->InitCheck();

	// cleanup on error
	if (error != B_OK) {
		dprintf("ERROR: Failed to init messaging service: %s\n",
			strerror(error));
		sMessagingService->~MessagingService();
		sMessagingService = NULL;
	}

	return error;
}


// #pragma mark - syscalls


/** \brief Called by the userland server to register itself as a messaging
		   service for the kernel.
	\param lockingSem A semaphore used for locking the shared data. Semaphore
		   counter must be initialized to 0.
	\param counterSem A semaphore released every time the kernel pushes a
		   command into an empty area. Semaphore counter must be initialized
		   to 0.
	\return
	- The ID of the kernel area used for communication, if everything went fine,
	- an error code otherwise.
*/
area_id
_user_register_messaging_service(sem_id lockSem, sem_id counterSem)
{
	// check, if init_messaging_service() has been called yet
	if (!sMessagingService)
		return B_NO_INIT;

	if (!sMessagingService->Lock())
		return B_BAD_VALUE;

	area_id areaID = 0;
	status_t error = sMessagingService->RegisterService(lockSem, counterSem,
		areaID);

	sMessagingService->Unlock();

	return (error != B_OK ? error : areaID);
}


status_t
_user_unregister_messaging_service()
{
	// check, if init_messaging_service() has been called yet
	if (!sMessagingService)
		return B_NO_INIT;

	if (!sMessagingService->Lock())
		return B_BAD_VALUE;

	status_t error = sMessagingService->UnregisterService();

	sMessagingService->Unlock();

	return error;
}