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


#include "x86_signals.h"

#include <string.h>

#include <KernelExport.h>

#include <commpage.h>
#include <cpu.h>
#include <elf.h>
#include <smp.h>

#include "syscall_numbers.h"


// implemented in assembly
extern "C" void x86_signal_frame_function_beos(signal_frame_data* frameData);


extern "C" void
x86_signal_frame_function(signal_frame_data* frameData)
{
	// Note: This function is copied to the commpage. Hence it needs to be
	// position independent. We don't build this source file with the respective
	// flags, but the code the compiler generates for this function is position
	// independent anyway. It simply doesn't contain constructs that could
	// result in position dependent code. The potentially problematic jumps
	// needed due to the "if" statement are all harmless relative jumps.

	if (frameData->siginfo_handler) {
		// SA_SIGINFO style handler function -- we additionally pass the user
		// data pointer
		void (*handler)(int, siginfo_t*, void*, void*)
			= (void (*)(int, siginfo_t*, void*, void*))frameData->handler;
		handler(frameData->info.si_signo, &frameData->info,
			&frameData->context, frameData->user_data);
	} else {
		// Simple handler function -- we call it with additional user data
		// pointer and vregs parameters. Note that unlike in BeOS the last
		// parameter is a pointer to a vregs structure, while in BeOS the
		// structure was passed be value. For setting up a BeOS binary
		// compatible signal handler call x86_signal_frame_function_beos() is
		// used instead.
		void (*handler)(int, void*, vregs*)
			= (void (*)(int, void*, vregs*))frameData->handler;
		handler(frameData->info.si_signo, frameData->user_data,
			&frameData->context.uc_mcontext);
	}

	#define TO_STRING_LITERAL_HELPER(number)	#number
	#define TO_STRING_LITERAL(number)	TO_STRING_LITERAL_HELPER(number)

	// call the restore_signal_frame() syscall -- does not return (here)
	asm volatile(
		// push frameData -- the parameter to restore_signal_frame()
		"pushl %0;"
		// push a dummy return value
		"pushl $0;"
		// syscall number to eax
		"movl $" TO_STRING_LITERAL(SYSCALL_RESTORE_SIGNAL_FRAME) ", %%eax;"
		// syscall
		"int $99;"
		:: "r"(frameData)
	);

	#undef TO_STRING_LITERAL_HELPER
	#undef TO_STRING_LITERAL
}


static void
register_signal_handler_function(const char* functionName, int32 commpageIndex,
	const char* commpageSymbolName, addr_t expectedAddress)
{
	// look up the x86_signal_frame_function() symbol -- we have its address,
	// but also need its size
	elf_symbol_info symbolInfo;
	if (elf_lookup_kernel_symbol(functionName, &symbolInfo)
			!= B_OK) {
		panic("x86_initialize_commpage_signal_handler(): Failed to find "
			"signal frame function \"%s\"!", functionName);
	}

	ASSERT(expectedAddress == symbolInfo.address);

	// fill in the commpage table entry
	addr_t position = fill_commpage_entry(commpageIndex,
		(void*)symbolInfo.address, symbolInfo.size);

	// add symbol to the commpage image
	image_id image = get_commpage_image();
	elf_add_memory_image_symbol(image, commpageSymbolName, position,
		symbolInfo.size, B_SYMBOL_TYPE_TEXT);
}


void
x86_initialize_commpage_signal_handler()
{
	// standard handler
	register_signal_handler_function("x86_signal_frame_function",
		COMMPAGE_ENTRY_X86_SIGNAL_HANDLER, "commpage_signal_handler",
		(addr_t)&x86_signal_frame_function);

	// handler for BeOS backwards compatibility
	register_signal_handler_function("x86_signal_frame_function_beos",
		COMMPAGE_ENTRY_X86_SIGNAL_HANDLER_BEOS, "commpage_signal_handler_beos",
		(addr_t)&x86_signal_frame_function_beos);
}


addr_t
x86_get_user_signal_handler_wrapper(bool beosHandler, void* commPageAdddress)
{
	int32 index = beosHandler
		? COMMPAGE_ENTRY_X86_SIGNAL_HANDLER_BEOS
		: COMMPAGE_ENTRY_X86_SIGNAL_HANDLER;
	return ((addr_t*)commPageAdddress)[index] + (addr_t)commPageAdddress;
}