gnumach4linux-libre/glue/mach_kernel.c

#include <glue/gnulinux.h>
#include <linux/printk.h>
#include <linux/uaccess.h>
#include <mach/kern_return.h>
#include <kern/ipc_host.h>
#include <kern/slab.h>
#include <vm/vm_map.h>
#include <vm/vm_kern.h>
#include <ipc/ipc_entry.h>
#include <ipc/ipc_space.h>
#include <ipc/ipc_object.h>
#include <ipc/ipc_port.h>
#include <ipc/ipc_pset.h>
#include <ipc/ipc_marequest.h>
#include <ipc/ipc_notify.h>
#include <ipc/ipc_kmsg.h>
#include <ipc/ipc_init.h>
#include <mach/mach_kernel.h>
#include <glue/mklinux.h>

#define COPYINARGS(type) \
	struct type args; \
	if (copy_from_user(&args, (struct atype*)arg, sizeof(args))) \
		return KERN_FAILURE;

int mach_kernel_init(void)
{	
	printk(KERN_ERR "mach_kernel_init TODO\n");
	return 0;
}

long gnu_mach_get_api_version(void* arg)
{
	printk(KERN_DEBUG "mach_get_api_version\n");
	return GNU_MACH_API_VERSION;
}

int mach_task_self(void);

long gnu_mach_task_self(void* arg)
{
	return (long)mach_task_self();; 
}

typedef long (*trap_handler)(void* arg);

struct trap_entry {
	trap_handler handler;
	const char* name;
};

#define TRAP(impl) [NR_##impl] = { (trap_handler) gnu_##impl, #impl }

static const struct trap_entry mach_traps[80] = {
	TRAP(mach_get_api_version),
	TRAP(mach_task_self),
	TRAP(mach_port_allocate),
	TRAP(mach_msg),
};

int mach_kernel_trap(int cmd,long arg)
{
	const unsigned int num_traps = sizeof(mach_traps) / sizeof(mach_traps[0]);
	const struct trap_entry* entry;
	if (cmd >= num_traps)
	{
		return KERN_FAILURE;
	}
	entry = &mach_traps[cmd];
	if (!entry->handler)
	{
		return KERN_FAILURE;
	}
    if(cmd>0) gnumach_thread_update();
	return entry->handler(arg);
}

//TODO -- move this to mach_api_internal.h
kern_return_t   mach_port_allocate
                (ipc_space_t                               task,
                 mach_port_right_t                        right,
                 mach_port_t                         *name);

long gnu_mach_port_allocate(void* arg)
{
	kern_return_t kr = 0;
	COPYINARGS(mach_port_allocate_args);
	
	mach_port_t name=0;
	task_t task= current_task();
	
	kr = mach_port_allocate(task->itk_space,args.right,&name);
	
	if(kr==KERN_SUCCESS)
	{
		if(copy_to_user(args.name,&name,sizeof(name))!=0) kr=KERN_FAILURE;
	}
	
	return kr;
}

mach_msg_return_t
mach_msg_trap(
	mach_msg_header_t 	*msg,
	mach_msg_option_t 	option,
	mach_msg_size_t 	send_size,
	mach_msg_size_t 	rcv_size,
	mach_port_t 		rcv_name,
	mach_msg_timeout_t 	time_out,
	mach_port_t 		notify);

long gnu_mach_msg(void* arg)
{
	kern_return_t kr = 0;
	COPYINARGS(mach_msg_args);
	return mach_msg_trap(args.msg,args.option,args.send_size,args.rcv_size,args.rcv_name,args.timeout,args.notify);
}