haiku.git

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

#include <stdlib.h>
#include <KernelExport.h>

#include <kernel.h>

#include "AreaSupport.h"
#include "Compatibility.h"
#include "Debug.h"
#include "Port.h"
#include "RequestAllocator.h"


// constructor
RequestAllocator::RequestAllocator(Port* port)
	:
	fError(B_NO_INIT),
	fPort(NULL),
	fRequest(NULL),
	fRequestSize(0),
	fPortReservedOffset(0),
	fAllocatedAreaCount(0),
	fDeferredInitInfoCount(0),
	fRequestInPortBuffer(false)
{
	Init(port);
}

// destructor
RequestAllocator::~RequestAllocator()
{
	Uninit();
}

// Init
status_t
RequestAllocator::Init(Port* port)
{
	Uninit();
	if (port) {
		fPort = port;
		fError = fPort->InitCheck();
		fPortReservedOffset = fPort->ReservedSize();
	}
	return fError;
}

// Uninit
void
RequestAllocator::Uninit()
{
	if (fRequestInPortBuffer)
		fPort->Unreserve(fPortReservedOffset);
	else
		free(fRequest);

	for (int32 i = 0; i < fAllocatedAreaCount; i++)
		delete_area(fAllocatedAreas[i]);
	fAllocatedAreaCount = 0;

	for (int32 i = 0; i < fDeferredInitInfoCount; i++) {
		if (fDeferredInitInfos[i].inPortBuffer)
			free(fDeferredInitInfos[i].data);
	}

	fDeferredInitInfoCount = 0;
	fError = B_NO_INIT;
	fPort = NULL;
	fRequest = NULL;
	fRequestSize = 0;
	fPortReservedOffset = 0;
}

// Error
status_t
RequestAllocator::Error() const
{
	return fError;
}

// FinishDeferredInit
void
RequestAllocator::FinishDeferredInit()
{
	if (fError != B_OK)
		return;
	for (int32 i = 0; i < fDeferredInitInfoCount; i++) {
		DeferredInitInfo& info = fDeferredInitInfos[i];
		if (info.inPortBuffer) {
			if (info.size > 0)
				memcpy((uint8*)fRequest + info.offset, info.data, info.size);
			free(info.data);
		}
		PRINT(("RequestAllocator::FinishDeferredInit(): area: %" B_PRId32 ", "
			"offset: %" B_PRId32 ", size: %" B_PRId32 "\n", info.area,
			info.offset, info.size));
		info.target->SetTo(info.area, info.offset, info.size);
	}
	fDeferredInitInfoCount = 0;
}

// AllocateRequest
status_t
RequestAllocator::AllocateRequest(int32 size)
{
	if (fError != B_OK)
		RETURN_ERROR(fError);

	fRequestOffset = (fPortReservedOffset + 7) / 8 * 8;

	if (size < (int32)sizeof(Request)
		|| fRequestOffset + size > fPort->GetCapacity()) {
		RETURN_ERROR(fError = B_BAD_VALUE);
	}

	fRequest = (Request*)((uint8*)fPort->GetBuffer() + fRequestOffset);
	fRequestSize = size;
	fRequestInPortBuffer = true;
	fPort->Reserve(fRequestOffset + fRequestSize);
	return B_OK;
}

// ReadRequest
status_t
RequestAllocator::ReadRequest(bigtime_t timeout)
{
	if (fError != B_OK)
		RETURN_ERROR(fError);

	// read the message from the port
	void* message;
	size_t messageSize;
	status_t error = fPort->Receive(&message, &messageSize, timeout);
	if (error != B_OK) {
		if (error != B_TIMED_OUT && error != B_WOULD_BLOCK)
			RETURN_ERROR(fError = error);
		return error;
	}

	// shouldn't be shorter than the base Request
	if (messageSize < (int32)sizeof(Request)) {
		free(message);
		RETURN_ERROR(fError = B_BAD_DATA);
	}

	// init the request
	fRequest = (Request*)message;
	fRequestOffset = 0;
	fRequestSize = messageSize;
	fRequestInPortBuffer = false;

	// relocate the request
	fError = relocate_request(fRequest, fRequestSize, fAllocatedAreas,
		&fAllocatedAreaCount);
	RETURN_ERROR(fError);
}

// GetRequest
Request*
RequestAllocator::GetRequest() const
{
	return fRequest;
}

// GetRequestSize
int32
RequestAllocator::GetRequestSize() const
{
	return fRequestSize;
}

// AllocateAddress
status_t
RequestAllocator::AllocateAddress(Address& address, int32 size, int32 align,
	void** data, bool deferredInit, int32 reserveForNextRequests)
{
	if (fError != B_OK)
		return fError;
	if (!fRequest)
		RETURN_ERROR(B_NO_INIT);
	if (size < 0)
		RETURN_ERROR(B_BAD_VALUE);
	if (fDeferredInitInfoCount >= MAX_REQUEST_ADDRESS_COUNT)
		RETURN_ERROR(B_BAD_VALUE);
	// fix the alignment -- valid is 1, 2, 4, 8
	if (align <= 0 || size == 0 || (align & 0x1))
		align = 1;
	else if (align & 0x2)
		align = 2;
	else if (align & 0x4)
		align = 4;
	else
		align = 8;
	// check address location
	// Currently we only support relocation of addresses inside the
	// port buffer.
	int32 addressOffset = (uint8*)&address - (uint8*)fRequest;
	if (addressOffset < (int32)sizeof(Request)
		|| addressOffset + (int32)sizeof(Address) > fRequestSize) {
		RETURN_ERROR(B_BAD_VALUE);
	}
	// get the next free aligned offset in the port buffer
	int32 offset = (fRequestSize + align - 1) / align * align;
	// allocate the data
	if (fRequestOffset + offset + size + reserveForNextRequests <= fPort->GetCapacity()) {
		// there's enough free space in the port buffer for the data and any anticipated requests
		fRequestSize = offset + size;
		fPort->Reserve(fRequestOffset + fRequestSize);
		if (deferredInit) {
			DeferredInitInfo& info
				= fDeferredInitInfos[fDeferredInitInfoCount];
			if (size > 0) {
				info.data = (uint8*)malloc(size);
				if (!info.data)
					RETURN_ERROR(B_NO_MEMORY);
			} else
				info.data = NULL;
			info.area = -1;
			info.offset = offset;
			info.size = size;
			info.inPortBuffer = true;
			info.target = &address;
			*data = info.data;
			fDeferredInitInfoCount++;
		} else {
			*data = (uint8*)fRequest + offset;
			address.SetTo(-1, offset, size);
		}
	} else {
		// not enough room in the port's buffer: we need to allocate an area
		if (fAllocatedAreaCount >= MAX_REQUEST_ADDRESS_COUNT)
			RETURN_ERROR(B_ERROR);
		int32 areaSize = (size + B_PAGE_SIZE - 1) / B_PAGE_SIZE * B_PAGE_SIZE;
		area_id area = create_area("request data", data,
#ifdef _KERNEL_MODE
			B_ANY_KERNEL_ADDRESS,
#else
			B_ANY_ADDRESS,
#endif
			areaSize, B_NO_LOCK,
#ifdef _KERNEL_MODE
			B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA | B_CLONEABLE_AREA
#else
			B_READ_AREA | B_WRITE_AREA
#endif
			);
		if (area < 0)
			RETURN_ERROR(area);
		fAllocatedAreas[fAllocatedAreaCount++] = area;
		if (deferredInit) {
			DeferredInitInfo& info
				= fDeferredInitInfos[fDeferredInitInfoCount];
			info.data = NULL;
			info.area = area;
			info.offset = 0;
			info.size = size;
			info.inPortBuffer = false;
			info.target = &address;
			fDeferredInitInfoCount++;
			PRINT(("  RequestAllocator::AllocateAddress(): deferred allocated "
				"area: %" B_PRId32 ", size: %" B_PRId32 " (%" B_PRId32
				"), data: %p\n", area, size, areaSize, *data));
		} else
			address.SetTo(area, 0, size);
	}
	return B_OK;
}

// AllocateData
status_t
RequestAllocator::AllocateData(Address& address, const void* data, int32 size,
	int32 align, bool deferredInit, int32 reserveForNextRequests)
{
	status_t error = B_OK;
	if (data != NULL) {
		void* destination;
		error = AllocateAddress(address, size, align, &destination,
			deferredInit, reserveForNextRequests);
		if (error != B_OK)
			return error;
		if (size > 0) {
#ifndef _KERNEL_MODE
			memcpy(destination, data, size);
#else
			if (user_memcpy(destination, data, size) < B_OK)
				return B_BAD_ADDRESS;
#endif
		}
	} else
		address.SetTo(-1, 0, 0);
	return error;
}

// AllocateString
status_t
RequestAllocator::AllocateString(Address& address, const char* data,
	bool deferredInit)
{
	int32 size = (data ? strlen(data) + 1 : 0);
	return AllocateData(address, data, size, 1, deferredInit);
}

// SetAddress
/*status_t
RequestAllocator::SetAddress(Address& address, void* data, int32 size)
{
	if (fError != B_OK)
		return fError;
	if (!fRequest)
		return (fError = B_NO_INIT);
	// check address location
	// Currently we only support relocation of addresses inside the
	// port buffer.
	int32 addressOffset = (uint8*)&address - (uint8*)fRequest;
	if (addressOffset < (int32)sizeof(Request)
		|| addressOffset + (int32)sizeof(Address) > fRequestSize) {
		return (fError = B_BAD_VALUE);
	}
	// if data does itself lie within the port buffer, we store only the
	// request relative offset
	int32 inRequestOffset = (uint8*)data - (uint8*)fRequest;
	if (!data) {
		address.SetTo(-1, 0, 0);
	} else if (inRequestOffset >= (int32)sizeof(Request)
		&& inRequestOffset <= fRequestSize) {
		if (inRequestOffset + size > fRequestSize)
			return (fError = B_BAD_VALUE);
		address.SetTo(-1, inRequestOffset, size);
	} else {
		// get the area and in-area offset for the address
		area_id area;
		int32 offset;
		fError = get_area_for_address(data, size, &area, &offset);
		if (fError != B_OK)
			return fError;
		// set the address
		address.SetTo(area, offset, size);
	}
	return fError;
}*/