haiku.git

/*
 * Copyright 2005-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2010-2013, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */

#include <new>

#include <string.h>

#include <AutoDeleter.h>
#include <debug_support.h>

#include "arch_debug_support.h"
#include "Image.h"
#include "SymbolLookup.h"


using std::nothrow;


struct debug_symbol_lookup_context {
	SymbolLookup*	lookup;
};

struct debug_symbol_iterator : BPrivate::Debug::SymbolIterator {
	bool	ownsImage;

	debug_symbol_iterator()
		:
		ownsImage(false)
	{
	}

	~debug_symbol_iterator()
	{
		if (ownsImage)
			delete image;
	}
};


// init_debug_context
status_t
init_debug_context(debug_context *context, team_id team, port_id nubPort)
{
	if (!context || team < 0 || nubPort < 0)
		return B_BAD_VALUE;

	context->team = team;
	context->nub_port = nubPort;

	// create the reply port
	context->reply_port = create_port(1, "debug reply port");
	if (context->reply_port < 0)
		return context->reply_port;

	return B_OK;
}

// destroy_debug_context
void
destroy_debug_context(debug_context *context)
{
	if (context) {
		if (context->reply_port >= 0)
			delete_port(context->reply_port);

		context->team = -1;
		context->nub_port = -1;
		context->reply_port = -1;
	}
}

// send_debug_message
status_t
send_debug_message(debug_context *context, int32 messageCode,
	const void *message, int32 messageSize, void *reply, int32 replySize)
{
	if (!context)
		return B_BAD_VALUE;

	// send message
	while (true) {
		status_t result = write_port(context->nub_port, messageCode, message,
			messageSize);
		if (result == B_OK)
			break;
		if (result != B_INTERRUPTED)
			return result;
	}

	if (!reply)
		return B_OK;

	// read reply
	while (true) {
		int32 code;
		ssize_t bytesRead = read_port(context->reply_port, &code, reply,
			replySize);
		if (bytesRead > 0)
			return B_OK;
		if (bytesRead != B_INTERRUPTED)
			return bytesRead;
	}
}

// debug_read_memory_partial
ssize_t
debug_read_memory_partial(debug_context *context, const void *address,
	void *buffer, size_t size)
{
	if (!context)
		return B_BAD_VALUE;

	if (size == 0)
		return 0;
	if (size > B_MAX_READ_WRITE_MEMORY_SIZE)
		size = B_MAX_READ_WRITE_MEMORY_SIZE;

	// prepare the message
	debug_nub_read_memory message;
	message.reply_port = context->reply_port;
	message.address = (void*)address;
	message.size = size;

	// send the message
	debug_nub_read_memory_reply reply;
	status_t error = send_debug_message(context, B_DEBUG_MESSAGE_READ_MEMORY,
		&message, sizeof(message), &reply, sizeof(reply));

	if (error != B_OK)
		return error;
	if (reply.error != B_OK)
		return reply.error;

	// copy the read data
	memcpy(buffer, reply.data, reply.size);
	return reply.size;
}

// debug_read_memory
ssize_t
debug_read_memory(debug_context *context, const void *_address, void *_buffer,
	size_t size)
{
	const char *address = (const char *)_address;
	char *buffer = (char*)_buffer;

	// check parameters
	if (!context || !address || !buffer)
		return B_BAD_VALUE;
	if (size == 0)
		return 0;

	// read as long as we can read data
	ssize_t sumRead = 0;
	while (size > 0) {
		ssize_t bytesRead = debug_read_memory_partial(context, address, buffer,
			size);
		if (bytesRead < 0) {
			if (sumRead > 0)
				return sumRead;
			return bytesRead;
		}

		address += bytesRead;
		buffer += bytesRead;
		sumRead += bytesRead;
		size -= bytesRead;
	}

	return sumRead;
}

// debug_read_string
ssize_t
debug_read_string(debug_context *context, const void *_address, char *buffer,
	size_t size)
{
	const char *address = (const char *)_address;

	// check parameters
	if (!context || !address || !buffer || size == 0)
		return B_BAD_VALUE;

	// read as long as we can read data
	ssize_t sumRead = 0;
	while (size > 0) {
		ssize_t bytesRead = debug_read_memory_partial(context, address, buffer,
			size);
		if (bytesRead < 0) {
			// always null-terminate what we have (even, if it is an empty
			// string) and be done
			*buffer = '\0';
			return (sumRead > 0 ? sumRead : bytesRead);
		}

		int chunkSize = strnlen(buffer, bytesRead);
		if (chunkSize < bytesRead) {
			// we found a terminating null
			sumRead += chunkSize;
			return sumRead;
		}

		address += bytesRead;
		buffer += bytesRead;
		sumRead += bytesRead;
		size -= bytesRead;
	}

	// We filled the complete buffer without encountering a terminating null
	// replace the last char. But nevertheless return the full size to indicate
	// that the buffer was too small.
	buffer[-1] = '\0';

	return sumRead;
}

// debug_write_memory_partial
ssize_t
debug_write_memory_partial(debug_context *context, const void *address,
	void *buffer, size_t size)
{
	if (!context)
		return B_BAD_VALUE;

	if (size == 0)
		return 0;
	if (size > B_MAX_READ_WRITE_MEMORY_SIZE)
		size = B_MAX_READ_WRITE_MEMORY_SIZE;

	// prepare the message
	debug_nub_write_memory message;
	message.reply_port = context->reply_port;
	message.address = (void*)address;
	message.size = size;
	memcpy(message.data, buffer, size);

	// send the message
	debug_nub_write_memory_reply reply;
	status_t error = send_debug_message(context, B_DEBUG_MESSAGE_WRITE_MEMORY,
		&message, sizeof(message), &reply, sizeof(reply));

	if (error != B_OK)
		return error;
	if (reply.error != B_OK)
		return reply.error;

	return reply.size;
}

// debug_write_memory
ssize_t
debug_write_memory(debug_context *context, const void *_address, void *_buffer,
	size_t size)
{
	const char *address = (const char *)_address;
	char *buffer = (char*)_buffer;

	// check parameters
	if (!context || !address || !buffer)
		return B_BAD_VALUE;
	if (size == 0)
		return 0;

	ssize_t sumWritten = 0;
	while (size > 0) {
		ssize_t bytesWritten = debug_write_memory_partial(context, address, buffer,
			size);
		if (bytesWritten < 0) {
			if (sumWritten > 0)
				return sumWritten;
			return bytesWritten;
		}

		address += bytesWritten;
		buffer += bytesWritten;
		sumWritten += bytesWritten;
		size -= bytesWritten;
	}

	return sumWritten;
}

// debug_get_cpu_state
status_t
debug_get_cpu_state(debug_context *context, thread_id thread,
	debug_debugger_message *messageCode, debug_cpu_state *cpuState)
{
	if (!context || !cpuState)
		return B_BAD_VALUE;

	// prepare message
	debug_nub_get_cpu_state message;
	message.reply_port = context->reply_port;
	message.thread = thread;

	// send message
	debug_nub_get_cpu_state_reply reply;
	status_t error = send_debug_message(context, B_DEBUG_MESSAGE_GET_CPU_STATE,
		&message, sizeof(message), &reply, sizeof(reply));
	if (error == B_OK)
		error = reply.error;

	// get state
	if (error == B_OK) {
		*cpuState = reply.cpu_state;
		if (messageCode)
			*messageCode = reply.message;
	}

	return error;
}


// #pragma mark -

// debug_get_instruction_pointer
status_t
debug_get_instruction_pointer(debug_context *context, thread_id thread,
	void **ip, void **stackFrameAddress)
{
	if (!context || !ip || !stackFrameAddress)
		return B_BAD_VALUE;

	return arch_debug_get_instruction_pointer(context, thread, ip,
		stackFrameAddress);
}

// debug_get_stack_frame
status_t
debug_get_stack_frame(debug_context *context, void *stackFrameAddress,
	debug_stack_frame_info *stackFrameInfo)
{
	if (!context || !stackFrameAddress || !stackFrameInfo)
		return B_BAD_VALUE;

	return arch_debug_get_stack_frame(context, stackFrameAddress,
		stackFrameInfo);
}


// #pragma mark -

// debug_create_symbol_lookup_context
status_t
debug_create_symbol_lookup_context(debug_context *context, image_id image,
	debug_symbol_lookup_context **_lookupContext)
{
	if (context == NULL || _lookupContext == NULL)
		return B_BAD_VALUE;

	// create the lookup context
	debug_symbol_lookup_context *lookupContext
		= new(std::nothrow) debug_symbol_lookup_context;
	if (lookupContext == NULL)
		return B_NO_MEMORY;
	ObjectDeleter<debug_symbol_lookup_context> contextDeleter(lookupContext);

	// create and init symbol lookup
	SymbolLookup *lookup = new(std::nothrow) SymbolLookup(context, image);
	if (lookup == NULL)
		return B_NO_MEMORY;
	ObjectDeleter<SymbolLookup> lookupDeleter(lookup);

	try {
		status_t error = lookup->Init();
		if (error != B_OK)
			return error;
	} catch (BPrivate::Debug::Exception& exception) {
		return exception.Error();
	}

	// everything went fine: return the result
	lookupContext->lookup = lookup;
	*_lookupContext = lookupContext;
	contextDeleter.Detach();
	lookupDeleter.Detach();

	return B_OK;
}

// debug_delete_symbol_lookup_context
void
debug_delete_symbol_lookup_context(debug_symbol_lookup_context *lookupContext)
{
	if (lookupContext) {
		delete lookupContext->lookup;
		delete lookupContext;
	}
}


// debug_get_symbol
status_t
debug_get_symbol(debug_symbol_lookup_context* lookupContext, image_id image,
	const char* name, int32 symbolType, void** _symbolLocation,
	size_t* _symbolSize, int32* _symbolType)
{
	if (!lookupContext || !lookupContext->lookup)
		return B_BAD_VALUE;
	SymbolLookup* lookup = lookupContext->lookup;

	return lookup->GetSymbol(image, name, symbolType, _symbolLocation,
		_symbolSize, _symbolType);
}


// debug_lookup_symbol_address
status_t
debug_lookup_symbol_address(debug_symbol_lookup_context *lookupContext,
	const void *address, void **baseAddress, char *symbolName,
	int32 symbolNameSize, char *imageName, int32 imageNameSize,
	bool *exactMatch)
{
	if (!lookupContext || !lookupContext->lookup)
		return B_BAD_VALUE;
	SymbolLookup *lookup = lookupContext->lookup;

	// find the symbol
	addr_t _baseAddress;
	const char *_symbolName;
	size_t _symbolNameLen;
	const char *_imageName;
	try {
		status_t error = lookup->LookupSymbolAddress((addr_t)address,
			&_baseAddress, &_symbolName, &_symbolNameLen, &_imageName,
			exactMatch);
		if (error != B_OK)
			return error;
	} catch (BPrivate::Debug::Exception& exception) {
		return exception.Error();
	}

	// translate/copy the results
	if (baseAddress)
		*baseAddress = (void*)_baseAddress;

	if (symbolName && symbolNameSize > 0) {
		if (_symbolName && _symbolNameLen > 0) {
			strlcpy(symbolName, _symbolName,
				min_c((size_t)symbolNameSize, _symbolNameLen + 1));
		} else
			symbolName[0] = '\0';
	}

	if (imageName) {
		if (imageNameSize > B_PATH_NAME_LENGTH)
			imageNameSize = B_PATH_NAME_LENGTH;
		strlcpy(imageName, _imageName, imageNameSize);
	}

	return B_OK;
}


status_t
debug_create_image_symbol_iterator(debug_symbol_lookup_context* lookupContext,
	image_id imageID, debug_symbol_iterator** _iterator)
{
	if (!lookupContext || !lookupContext->lookup)
		return B_BAD_VALUE;
	SymbolLookup *lookup = lookupContext->lookup;

	debug_symbol_iterator* iterator = new(std::nothrow) debug_symbol_iterator;
	if (iterator == NULL)
		return B_NO_MEMORY;

	status_t error;
	try {
		error = lookup->InitSymbolIterator(imageID, *iterator);
	} catch (BPrivate::Debug::Exception& exception) {
		error = exception.Error();
	}

	// Work-around for a runtime loader problem. A freshly fork()ed child does
	// still have image_t structures with the parent's image ID's, so we
	// wouldn't find the image in this case.
	if (error != B_OK) {
		// Get the image info and re-try looking with the text base address.
		// Note, that we can't easily check whether the image is part of the
		// target team at all (there's no image_info::team, we'd have to
		// iterate through all images).
		image_info imageInfo;
		error = get_image_info(imageID, &imageInfo);
		if (error == B_OK) {
			try {
				error = lookup->InitSymbolIteratorByAddress(
					(addr_t)imageInfo.text, *iterator);
			} catch (BPrivate::Debug::Exception& exception) {
				error = exception.Error();
			}
		}
	}

	if (error != B_OK) {
		delete iterator;
		return error;
	}

	*_iterator = iterator;
	return B_OK;
}


status_t
debug_create_file_symbol_iterator(const char* path,
	debug_symbol_iterator** _iterator)
{
	if (path == NULL)
		return B_BAD_VALUE;

	// create the iterator
	debug_symbol_iterator* iterator = new(std::nothrow) debug_symbol_iterator;
	if (iterator == NULL)
		return B_NO_MEMORY;
	ObjectDeleter<debug_symbol_iterator> iteratorDeleter(iterator);

	// create the image file
	ImageFile* imageFile = new(std::nothrow) ImageFile;
	if (imageFile == NULL)
		return B_NO_MEMORY;

	// init the iterator
	iterator->image = imageFile;
	iterator->ownsImage = true;
	iterator->currentIndex = -1;

	// init the image file
	status_t error = imageFile->Init(path);
	if (error != B_OK)
		return error;

	iteratorDeleter.Detach();
	*_iterator = iterator;

	return B_OK;
}


void
debug_delete_symbol_iterator(debug_symbol_iterator* iterator)
{
	delete iterator;
}


// debug_next_image_symbol
status_t
debug_next_image_symbol(debug_symbol_iterator* iterator, char* nameBuffer,
	size_t nameBufferLength, int32* _symbolType, void** _symbolLocation,
	size_t* _symbolSize)
{
	if (iterator == NULL || iterator->image == NULL)
		return B_BAD_VALUE;

	const char* symbolName;
	size_t symbolNameLen;
	addr_t symbolLocation;

	try {
		status_t error = iterator->image->NextSymbol(iterator->currentIndex,
			&symbolName, &symbolNameLen, &symbolLocation, _symbolSize,
			_symbolType);
		if (error != B_OK)
			return error;
	} catch (BPrivate::Debug::Exception& exception) {
		return exception.Error();
	}

	*_symbolLocation = (void*)symbolLocation;

	if (symbolName != NULL && symbolNameLen > 0) {
		strlcpy(nameBuffer, symbolName,
			min_c(nameBufferLength, symbolNameLen + 1));
	} else
		nameBuffer[0] = '\0';

	return B_OK;
}


status_t
debug_get_symbol_iterator_image_info(debug_symbol_iterator* iterator,
	image_info* info)
{
	if (iterator == NULL || iterator->image == NULL || info == NULL)
		return B_BAD_VALUE;

	*info = iterator->image->Info();
	return B_OK;
}