mop3/kernel/syscall/syscall.c

#include <aux/compiler.h>
#include <libk/std.h>
#include <limine/requests.h>
#include <m/status.h>
#include <m/syscall_defs.h>
#include <mm/pmm.h>
#include <proc/mem.h>
#include <proc/mutex.h>
#include <proc/proc.h>
#include <proc/resource.h>
#include <sync/spin_lock.h>
#include <sys/debug.h>
#include <sys/mm.h>
#include <sys/proc.h>
#include <syscall/syscall.h>

#define DEFINE_SYSCALL(name)                                                                       \
  int name (struct proc* proc, void* UNUSED regs, uintptr_t UNUSED a1, uintptr_t UNUSED a2,        \
            uintptr_t UNUSED a3, uintptr_t UNUSED a4, uintptr_t UNUSED a5, uintptr_t UNUSED a6)

/* int proc_quit (void) */
DEFINE_SYSCALL (sys_proc_quit) {
  proc_kill (proc, regs);
  return ST_OK;
}

/* int proc_test (void) */
DEFINE_SYSCALL (sys_proc_test) {
  char c = (char)a1;
  DEBUG ("test syscall from %d! %c\n", proc->pid, c);
  return ST_OK;
}

/* int proc_map (uintptr_t paddr, uintptr_t vaddr, size_t pages, uint32_t flags) */
DEFINE_SYSCALL (sys_proc_map) {
  uintptr_t paddr = a1;
  uintptr_t vaddr = a2;
  size_t pages = (size_t)a3;
  uint32_t flags = (uint32_t)a4;

  if (vaddr % PAGE_SIZE != 0)
    return -ST_UNALIGNED;

  if (paddr % PAGE_SIZE != 0)
    return -ST_UNALIGNED;

  bool ok = proc_map (proc, paddr, vaddr, pages, flags);
  return ok ? ST_OK : -ST_OOM_ERROR;
}

/* int proc_unmap (uintptr_t vaddr, size_t pages) */
DEFINE_SYSCALL (sys_proc_unmap) {
  uintptr_t vaddr = a1;
  size_t pages = (size_t)a2;

  if (vaddr % PAGE_SIZE != 0)
    return -ST_UNALIGNED;

  bool ok = proc_unmap (proc, vaddr, pages);
  return ok ? ST_OK : -ST_OOM_ERROR;
}

/* int proc_create_resource_mem (int rid, size_t pages, int vis, uintptr_t* out_paddr) */
DEFINE_SYSCALL (sys_proc_create_resource_mem) {
  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
  spin_lock_ctx_t ctxprpd;

  int rid = (int)a1;
  size_t pages = (size_t)a2;
  int vis = (int)a3;
  uintptr_t* out_paddr_buf = (uintptr_t*)a4;

  if (rid < 0)
    return -ST_BAD_RESOURCE;

  spin_lock (&proc->pd->lock, &ctxprpd);

  uintptr_t out_paddr_buf_paddr = mm_v2p (proc->pd, (uintptr_t)out_paddr_buf, 0);

  if (!mm_validate_buffer (proc->pd, (uintptr_t)out_paddr_buf, sizeof (uintptr_t), 0)) {
    spin_unlock (&proc->pd->lock, &ctxprpd);
    return -ST_BAD_ADDRESS_SPACE;
  }

  spin_unlock (&proc->pd->lock, &ctxprpd);

  uintptr_t* out_paddr_buf_vaddr = (uintptr_t*)((uintptr_t)hhdm->offset + out_paddr_buf_paddr);

  struct proc_resource_mem_init mem_init = {.pages = pages};
  struct proc_resource* r = proc_create_resource (proc, rid, PR_MEM, vis, &mem_init);

  if (r != NULL) {
    *out_paddr_buf_vaddr = r->u.mem.paddr;
    return r->rid;
  } else {
    return -ST_OOM_ERROR;
  }
}

/* int proc_create_resource_mutex (int rid, int vis) */
DEFINE_SYSCALL (sys_proc_create_resource_mutex) {
  int rid = (int)a1;
  int vis = (int)a2;

  if (rid < 0)
    return -ST_BAD_RESOURCE;

  struct proc_resource* r = proc_create_resource (proc, rid, PR_MUTEX, vis, NULL);
  if (r != NULL)
    return r->rid;
  else
    return -ST_OOM_ERROR;
}

/* int proc_mutex_lock (int mutex_rid) */
DEFINE_SYSCALL (sys_proc_mutex_lock) {
  spin_lock_ctx_t ctxpr;
  int rid = (int)a1;

  struct proc_resource* resource;
  spin_lock (&proc->lock, &ctxpr);
  rbtree_find (struct proc_resource, &proc->resource_tree, rid, resource, proc_resource_tree_link,
               rid);
  spin_unlock (&proc->lock, &ctxpr);

  if (resource == NULL)
    return -ST_NOT_FOUND;

  proc_mutex_lock (proc, &resource->u.mutex);

  return ST_OK;
}

/* int proc_mutex_unlock (int mutex_rid) */
DEFINE_SYSCALL (sys_proc_mutex_unlock) {
  spin_lock_ctx_t ctxpr;
  int rid = (int)a1;

  struct proc_resource* resource;
  spin_lock (&proc->lock, &ctxpr);
  rbtree_find (struct proc_resource, &proc->resource_tree, rid, resource, proc_resource_tree_link,
               rid);
  spin_unlock (&proc->lock, &ctxpr);

  if (resource == NULL)
    return -ST_NOT_FOUND;

  int result = proc_mutex_unlock (proc, &resource->u.mutex) ? ST_OK : -ST_PERMISSION_ERROR;
  if (result < 0)
    return result;

  proc_sched (regs);

  return ST_OK;
}

/* int proc_drop_resource (int rid) */
DEFINE_SYSCALL (sys_proc_drop_resource) {
  spin_lock_ctx_t ctxpr;
  int rid = (int)a1;

  struct proc_resource* resource;
  spin_lock (&proc->lock, &ctxpr);
  rbtree_find (struct proc_resource, &proc->resource_tree, rid, resource, proc_resource_tree_link,
               rid);
  spin_unlock (&proc->lock, &ctxpr);

  if (resource == NULL)
    return -ST_NOT_FOUND;

  proc_drop_resource (proc, resource);

  return ST_OK;
}

/* int proc_spawn_thread (uintptr_t vstack_top, size_t stack_size, void* entry) */
DEFINE_SYSCALL (sys_proc_spawn_thread) {
  uintptr_t vstack_top = a1;
  size_t stack_size = (size_t)a2;
  uintptr_t entry = a3;

  struct cpu* cpu = proc->cpu;

  struct proc* new = proc_spawn_thread (proc, vstack_top, stack_size, entry);

  DEBUG ("new=%p\n", new);

  if (new == NULL) {
    return -ST_OOM_ERROR;
  }

  int pid = new->pid;

  proc_register (new, cpu);

  return pid;
}

/* int proc_sched (void) */
DEFINE_SYSCALL (sys_proc_sched) {
  proc_sched (regs);
  return ST_OK;
}

DEFINE_SYSCALL (sys_proc_translate_v2p) {
  struct limine_hhdm_response* hhdm = limine_hhdm_request.response;
  spin_lock_ctx_t ctxprpd;
  int result = ST_OK;

  uintptr_t vaddr = a1;
  uintptr_t* out_paddr_buf = (uintptr_t*)a2;

  spin_lock (&proc->pd->lock, &ctxprpd);

  uintptr_t out_paddr_buf_paddr = mm_v2p (proc->pd, (uintptr_t)out_paddr_buf, 0);

  if (!mm_validate_buffer (proc->pd, (uintptr_t)out_paddr_buf, sizeof (uintptr_t), 0)) {
    spin_unlock (&proc->pd->lock, &ctxprpd);
    return -ST_BAD_ADDRESS_SPACE;
  }

  uintptr_t* out_paddr_buf_vaddr = (uintptr_t*)((uintptr_t)hhdm->offset + out_paddr_buf_paddr);

  uintptr_t translated_addr = mm_v2p (proc->pd, vaddr, 0);
  if (translated_addr == 0) {
    result = -ST_BAD_ADDRESS_SPACE;
    goto done;
  }

  *out_paddr_buf_vaddr = translated_addr;

done:
  spin_unlock (&proc->pd->lock, &ctxprpd);
  return result;
}

/* int proc_resource_mem_unref (int mem_rid, size_t pages) */
DEFINE_SYSCALL (sys_proc_mem_unref) {
  spin_lock_ctx_t ctxpr;
  int rid = (int)a1;
  size_t pages = (size_t)a2;

  struct proc_resource* resource;
  spin_lock (&proc->lock, &ctxpr);
  rbtree_find (struct proc_resource, &proc->resource_tree, rid, resource, proc_resource_tree_link,
               rid);
  spin_unlock (&proc->lock, &ctxpr);

  if (resource == NULL)
    return -ST_NOT_FOUND;

  proc_mem_unref (proc, &resource->u.mem, pages);

  return ST_OK;
}

static syscall_handler_func_t handler_table[] = {
    [SYS_PROC_QUIT] = &sys_proc_quit,
    [SYS_PROC_TEST] = &sys_proc_test,
    [SYS_PROC_MAP] = &sys_proc_map,
    [SYS_PROC_UNMAP] = &sys_proc_unmap,
    [SYS_PROC_CREATE_RESOURCE_MEM] = &sys_proc_create_resource_mem,
    [SYS_PROC_DROP_RESOURCE] = &sys_proc_drop_resource,
    [SYS_PROC_CREATE_RESOURCE_MUTEX] = &sys_proc_create_resource_mutex,
    [SYS_PROC_MUTEX_LOCK] = &sys_proc_mutex_lock,
    [SYS_PROC_MUTEX_UNLOCK] = &sys_proc_mutex_unlock,
    [SYS_PROC_SPAWN_THREAD] = &sys_proc_spawn_thread,
    [SYS_PROC_SCHED] = &sys_proc_sched,
    [SYS_PROC_TRANSLATE_V2P] = &sys_proc_translate_v2p,
    [SYS_PROC_MEM_UNREF] = &sys_proc_mem_unref,
};

syscall_handler_func_t syscall_find_handler (int syscall_num) {
  if (!(syscall_num >= 0 &&
        syscall_num < (int)(sizeof (handler_table) / sizeof (handler_table[0])))) {
    return NULL;
  }

  return handler_table[syscall_num];
}