mango/include/kernel/syscall.h

#ifndef KERNEL_SYSCALL_H_
#define KERNEL_SYSCALL_H_

#include <kernel/handle.h>
#include <kernel/sched.h>
#include <kernel/vm-region.h>
#include <kernel/vm.h>
#include <mango/status.h>
#include <mango/syscall.h>

#define validate_access(task, ptr, len, flags)                                 \
	__validate_access(task, (const void *)ptr, len, flags)
#define validate_access_r(task, ptr, len)                                      \
	validate_access(task, ptr, len, VM_PROT_READ | VM_PROT_USER)
#define validate_access_w(task, ptr, len)                                      \
	validate_access(task, ptr, len, VM_PROT_WRITE | VM_PROT_USER)
#define validate_access_rw(task, ptr, len)                                     \
	validate_access(                                                       \
		task,                                                          \
		ptr,                                                           \
		len,                                                           \
		VM_PROT_READ | VM_PROT_WRITE | VM_PROT_USER)

static inline bool __validate_access(
	struct task *task,
	const void *ptr,
	size_t len,
	vm_prot_t flags)
{
	unsigned long irq_flags;
	vm_region_lock_irqsave(task->t_address_space, &irq_flags);
	bool result = vm_region_validate_access(
		task->t_address_space,
		(virt_addr_t)ptr,
		len,
		flags | VM_PROT_USER);
	vm_region_unlock_irqrestore(task->t_address_space, irq_flags);
	return result;
}

extern kern_status_t sys_task_exit(int status);
extern kern_status_t sys_task_self(kern_handle_t *out);
extern kern_status_t sys_task_create(
	kern_handle_t parent_handle,
	const char *name,
	size_t name_len,
	kern_handle_t *out_task,
	kern_handle_t *out_address_space);
extern kern_status_t sys_task_create_thread(
	kern_handle_t task,
	virt_addr_t ip,
	virt_addr_t sp,
	uintptr_t *args,
	size_t nr_args,
	kern_handle_t *out_thread);
extern kern_status_t sys_task_get_address_space(
	kern_handle_t task,
	kern_handle_t *out);

extern kern_status_t sys_thread_start(kern_handle_t thread);

extern kern_status_t sys_vm_object_create(
	const char *name,
	size_t name_len,
	size_t data_len,
	vm_prot_t prot,
	kern_handle_t *out);
extern kern_status_t sys_vm_object_read(
	kern_handle_t object,
	void *dst,
	off_t offset,
	size_t count,
	size_t *nr_read);
extern kern_status_t sys_vm_object_write(
	kern_handle_t object,
	const void *src,
	off_t offset,
	size_t count,
	size_t *nr_written);
extern kern_status_t sys_vm_object_copy(
	kern_handle_t dst,
	off_t dst_offset,
	kern_handle_t src,
	off_t src_offset,
	size_t count,
	size_t *nr_copied);

extern kern_status_t sys_vm_region_create(
	kern_handle_t parent,
	const char *name,
	size_t name_len,
	off_t offset,
	size_t region_len,
	vm_prot_t prot,
	kern_handle_t *out,
	virt_addr_t *out_base_address);
extern kern_status_t sys_vm_region_kill(kern_handle_t region);
extern kern_status_t sys_vm_region_read(
	kern_handle_t region,
	void *dst,
	off_t offset,
	size_t count,
	size_t *nr_read);
extern kern_status_t sys_vm_region_write(
	kern_handle_t region,
	const void *src,
	off_t offset,
	size_t count,
	size_t *nr_read);
extern kern_status_t sys_vm_region_map_absolute(
	kern_handle_t region,
	virt_addr_t map_address,
	kern_handle_t object,
	off_t object_offset,
	size_t length,
	vm_prot_t prot,
	virt_addr_t *out_base_address);
extern kern_status_t sys_vm_region_map_relative(
	kern_handle_t region,
	off_t region_offset,
	kern_handle_t object,
	off_t object_offset,
	size_t length,
	vm_prot_t prot,
	virt_addr_t *out_base_address);
extern kern_status_t sys_vm_region_unmap_absolute(
	kern_handle_t region,
	virt_addr_t address,
	size_t length);
extern kern_status_t sys_vm_region_unmap_relative(
	kern_handle_t region,
	off_t offset,
	size_t length);

extern kern_status_t sys_kern_log(const char *s);
extern kern_status_t sys_kern_handle_close(kern_handle_t handle);
extern kern_status_t sys_kern_config_get(
	kern_config_key_t key,
	void *ptr,
	size_t len);
extern kern_status_t sys_kern_config_set(
	kern_config_key_t key,
	const void *ptr,
	size_t len);

extern kern_status_t sys_channel_create(unsigned int id, kern_handle_t *out);
extern kern_status_t sys_port_create(kern_handle_t *out);
extern kern_status_t sys_port_connect(
	kern_handle_t port,
	tid_t task_id,
	unsigned int channel_id);
extern kern_status_t sys_port_disconnect(kern_handle_t port);

extern kern_status_t sys_msg_send(
	kern_handle_t port,
	const kern_msg_t *msg,
	kern_msg_t *out_reply);
extern kern_status_t sys_msg_recv(kern_handle_t channel, kern_msg_t *out_msg);

extern kern_status_t sys_msg_reply(
	kern_handle_t channel,
	msgid_t id,
	const kern_msg_t *msg);
extern kern_status_t sys_msg_read(
	kern_handle_t channel_handle,
	msgid_t id,
	size_t offset,
	const kern_iovec_t *iov,
	size_t iov_count,
	size_t *nr_read);
extern kern_status_t sys_msg_write(
	kern_handle_t channel,
	msgid_t id,
	size_t offset,
	const kern_iovec_t *in,
	size_t nr_in,
	size_t *nr_written);

extern virt_addr_t syscall_get_function(unsigned int sysid);

#endif