Organize system calls

* syscalls should all return j6_status_t now
* syscalls are grouped by category in name as well as in files

src/kernel/objects/event.h

@@ -8,8 +8,6 @@ class event :
 	public kobject
 {
 public:
-	static constexpr type type_id = type::event;
-
 	event() :
-		kobject(type_id) {}
+		kobject(type::event) {}
 };

src/kernel/syscall.cpp

@@ -14,10 +14,6 @@ extern "C" {
 
 namespace syscalls {
 
-
-void send() {}
-void receive() {}
-
 } // namespace syscalls
 
 uintptr_t syscall_registry[static_cast<unsigned>(syscall::MAX)];

src/kernel/syscall.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <stdint.h>
+#include "j6/types.h"
 
 struct cpu_state;
 
@@ -19,7 +20,7 @@ void syscall_enable();
 
 namespace syscalls
 {
-#define SYSCALL(id, name, result, ...) result name (__VA_ARGS__);
+#define SYSCALL(id, name, ...) j6_status_t name (__VA_ARGS__);
 #include "syscalls.inc"
 #undef SYSCALL
 }

src/kernel/syscalls.inc

@@ -1,12 +1,9 @@
-SYSCALL(0x00, noop,     void)
-SYSCALL(0x01, exit,     void, int64_t)
-SYSCALL(0x02, getpid,   pid_t)
-SYSCALL(0x03, fork,     pid_t)
+SYSCALL(0x00, object_noop,      void)
+SYSCALL(0x01, object_wait,      j6_handle_t, j6_signal_t, j6_signal_t *)
 
-SYSCALL(0x10, message,  void, const char *)
-
-SYSCALL(0x20, pause,    void)
-SYSCALL(0x21, sleep,    void, uint64_t)
-
-SYSCALL(0x30, send,     void)
-SYSCALL(0x31, receive,  void)
+SYSCALL(0x11, process_exit,     int64_t)
+SYSCALL(0x12, process_fork,     pid_t*)
+SYSCALL(0x13, process_getpid,   pid_t*)
+SYSCALL(0x14, process_log,      const char *)
+SYSCALL(0x15, process_pause,    void)
+SYSCALL(0x16, process_sleep,    uint64_t)

src/kernel/syscalls/exit.cpp

@@ -1,17 +0,0 @@
-#include "log.h"
-#include "scheduler.h"
-
-namespace syscalls {
-
-void
-exit(int64_t status)
-{
-	auto &s = scheduler::get();
-	auto *p = s.current();
-	log::debug(logs::syscall, "Process %d exiting with code %d", p->pid, status);
-
-	p->exit(status);
-	s.schedule();
-}
-
-} // namespace syscalls

src/kernel/syscalls/fork.cpp

@@ -1,24 +0,0 @@
-
-#include "log.h"
-#include "scheduler.h"
-
-namespace syscalls {
-
-pid_t
-fork()
-{
-	auto &s = scheduler::get();
-	auto *p = s.current();
-	pid_t ppid = p->pid;
-
-	log::debug(logs::syscall, "Process %d calling fork()", ppid);
-
-	pid_t pid = p->fork();
-
-	p = s.current();
-	log::debug(logs::syscall, "Process %d's fork: returning %d from process %d", ppid, pid, p->pid);
-
-	return pid;
-}
-
-} // namespace syscalls

src/kernel/syscalls/getpid.cpp

@@ -1,14 +0,0 @@
-#include "log.h"
-#include "scheduler.h"
-
-namespace syscalls {
-
-pid_t
-getpid()
-{
-	auto &s = scheduler::get();
-	auto *p = s.current();
-	return p->pid;
-}
-
-} // namespace syscalls

src/kernel/syscalls/message.cpp

@@ -1,14 +0,0 @@
-#include "log.h"
-#include "scheduler.h"
-
-namespace syscalls {
-
-void
-message(const char *message)
-{
-	auto &s = scheduler::get();
-	auto *p = s.current();
-	log::info(logs::syscall, "Message[%d]: %s", p->pid, message);
-}
-
-} // namespace syscalls

src/kernel/syscalls/object.cpp

@@ -1,14 +1,24 @@
+#include "j6/errors.h"
+#include "j6/types.h"
+
 #include "log.h"
 #include "scheduler.h"
 
 namespace syscalls {
 
-void
-noop()
+j6_status_t
+object_noop()
 {
 	auto &s = scheduler::get();
 	auto *p = s.current();
 	log::debug(logs::syscall, "Process %d called noop syscall.", p->pid);
+	return j6_status_ok;
+}
+
+j6_status_t
+object_wait(j6_handle_t, j6_signal_t, j6_signal_t*)
+{
+	return j6_err_nyi;
 }
 
 } // namespace syscalls

src/kernel/syscalls/pause.cpp

@@ -1,15 +0,0 @@
-#include "log.h"
-#include "scheduler.h"
-
-namespace syscalls {
-
-void
-pause()
-{
-	auto &s = scheduler::get();
-	auto *p = s.current();
-	p->wait_on_signal(-1ull);
-	s.schedule();
-}
-
-} // namespace syscalls

src/kernel/syscalls/process.cpp

@@ -0,0 +1,93 @@
+#include "j6/errors.h"
+#include "j6/types.h"
+
+#include "log.h"
+#include "scheduler.h"
+
+namespace syscalls {
+
+j6_status_t
+process_exit(int64_t status)
+{
+	auto &s = scheduler::get();
+	auto *p = s.current();
+	log::debug(logs::syscall, "Process %d exiting with code %d", p->pid, status);
+
+	p->exit(status);
+	s.schedule();
+
+	log::error(logs::syscall, "returned to exit syscall");
+	return j6_err_unexpected;
+}
+
+j6_status_t
+process_fork(pid_t *pid)
+{
+	if (pid == nullptr) {
+		return j6_err_invalid_arg;
+	}
+
+	auto &s = scheduler::get();
+	auto *p = s.current();
+	pid_t ppid = p->pid;
+
+	log::debug(logs::syscall, "Process %d calling fork(%016llx)", ppid, pid);
+
+	*pid = p->fork();
+
+	p = s.current();
+	log::debug(logs::syscall, "Process %d's fork: returning %d from process %d", ppid, *pid, p->pid);
+
+	return j6_status_ok;
+}
+
+j6_status_t
+process_getpid(pid_t *pid)
+{
+	if (pid == nullptr) {
+		return j6_err_invalid_arg;
+	}
+
+	auto &s = scheduler::get();
+	auto *p = s.current();
+
+	*pid = p->pid;
+	return j6_status_ok;
+}
+
+j6_status_t
+process_log(const char *message)
+{
+	if (message == nullptr) {
+		return j6_err_invalid_arg;
+	}
+
+	auto &s = scheduler::get();
+	auto *p = s.current();
+	log::info(logs::syscall, "Message[%d]: %s", p->pid, message);
+	return j6_status_ok;
+}
+
+j6_status_t
+process_pause()
+{
+	auto &s = scheduler::get();
+	auto *p = s.current();
+	p->wait_on_signal(-1ull);
+	s.schedule();
+	return j6_status_ok;
+}
+
+j6_status_t
+process_sleep(uint64_t til)
+{
+	auto &s = scheduler::get();
+	auto *p = s.current();
+	log::debug(logs::syscall, "Process %d sleeping until %d", p->pid, til);
+
+	p->wait_on_time(til);
+	s.schedule();
+	return j6_status_ok;
+}
+
+} // namespace syscalls

src/kernel/syscalls/sleep.cpp

@@ -1,17 +0,0 @@
-#include "log.h"
-#include "scheduler.h"
-
-namespace syscalls {
-
-void
-sleep(uint64_t til)
-{
-	auto &s = scheduler::get();
-	auto *p = s.current();
-	log::debug(logs::syscall, "Process %d sleeping until %d", p->pid, til);
-
-	p->wait_on_time(til);
-	s.schedule();
-}
-
-} // namespace syscalls