New repo setup

include/sys/syscall.h

@@ -0,0 +1,222 @@
+#ifndef KERNEL_SYSCALL_H
+#define KERNEL_SYSCALL_H
+
+#include "types/syscallid.h"
+#include "types/pid.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    int do_syscall(long id, unsigned long arg1, unsigned long arg2, unsigned long arg3, unsigned long arg4);
+
+    /**
+     * @brief Prints `str` on the kernel log.
+     * @param str
+     * @return 0
+     */
+    static inline int printk(const char *str)
+    {
+        return do_syscall(SYS_PRINTK, (unsigned long)str, 0, 0, 0);
+    }
+
+    /**
+     * @brief Map a region in memory to newly allocated page frames
+     * @param ptr Pointer to the start of the region to map
+     * @param size Size in bytes of the region to map
+     * @param flags Access flags for the pages to map
+     * @return
+     */
+    static inline int mmap(void *ptr, unsigned long size, int flags)
+    {
+        return do_syscall(SYS_MMAP, (unsigned long)ptr, size, (unsigned long)flags, 0);
+    }
+
+    /**
+     * @brief Free the memory in a particular region
+     * @param ptr Pointer to the start of the region to unmap
+     * @param size Size in bytes of the region to unmap
+     * @return
+     */
+    static inline int munmap(void *ptr, unsigned long size)
+    {
+        return do_syscall(SYS_MUNMAP, (unsigned long)ptr, size, 0, 0);
+    }
+
+    /**
+     * @brief Create a new process which shares the current process's address space,
+     * but has a separate context and is scheduled separately.
+     *
+     * @param fn Function pointer to start executing the new process at
+     * @param stack Stack pointer for the new process
+     * @param flags
+     * @return
+     */
+    static inline int clone(int (*fn)(void *), void *stack, void *userdata, int flags)
+    {
+        return do_syscall(SYS_CLONE, (unsigned long)fn, (unsigned long)stack, (unsigned long)userdata, (unsigned long)flags);
+    }
+
+    /**
+     * @brief Completely terminate the current process, freeing all resources that
+     * belong to it.
+     *
+     * @return
+     */
+    static inline int terminate()
+    {
+        return do_syscall(SYS_TERMINATE, 0, 0, 0, 0);
+    }
+
+    /**
+     * @brief Replace the current process's address space with a fresh one, then
+     * load a new program image from the executable specified by `path`.
+     *
+     * @param path Path to the executable to load
+     * @param argv Program arguments to pass to the new program
+     * @param envp Environment variables to pass to the new program
+     * @return
+     */
+    static inline int exec(const char *path, char *const argv[], char *const envp[])
+    {
+        return do_syscall(SYS_EXEC, (unsigned long)path, (unsigned long)argv, (unsigned long)envp, 0);
+    }
+
+    /**
+     * @brief Put current process at the end of the scheduler queue, then switch to
+     * next process.
+     *
+     * @return
+     */
+    static inline int yield()
+    {
+        return do_syscall(SYS_YIELD, 0, 0, 0, 0);
+    }
+
+    /**
+     * @brief Call the specified signal handler on the process with id `pid`.
+     * @param pid Process to call a signal handler on
+     * @param signal Signal handler to call
+     * @return
+     */
+    static inline int sigraise(pid_t pid, int signal)
+    {
+        return do_syscall(SYS_SIGRAISE, (unsigned long)pid, (unsigned long)signal, 0, 0);
+    }
+
+    /**
+     * @brief Return from a signal handler, putting the stack and process context
+     * back to the state they were in just before the signal was triggered.
+     * @return
+     */
+    static inline int sigret()
+    {
+        return do_syscall(SYS_SIGRET, 0, 0, 0, 0);
+    }
+
+    /**
+     * @brief Stop scheduling process until a signal occurs.
+     * @return
+     */
+    static inline int sigwait()
+    {
+        return do_syscall(SYS_SIGWAIT, 0, 0, 0, 0);
+    }
+
+    /**
+     * @brief Sets the handler function to call when a particular signal occurs.
+     * Kernel will pass the pointer `userdata` to the handler function when it is
+     * called.
+     * @param signal Signal to specify handler for
+     * @param handler Function pointer to signal handler
+     * @param trampoline Function pointer to trampoline function called when handler returns.
+     * @param userdata Userdata to pass to handler function (can be NULL)
+     * @return
+     */
+    static inline int sigaction(int signal, void (*handler)(void *), void (*trampoline)(void), void *userdata)
+    {
+        return do_syscall(SYS_SIGACTION, (unsigned long)signal, (unsigned long)handler, (unsigned long)trampoline, (unsigned long)userdata);
+    }
+
+    /**
+     * @brief Open the file specified by `path`
+     * @param path Path of the file to open
+     * @param flags
+     * @return The file descriptor for the file just opened
+     */
+    static inline int openf(const char *path, int flags)
+    {
+        return do_syscall(SYS_OPEN, (unsigned long)path, (unsigned long)flags, 0, 0);
+    }
+
+    /**
+     * @brief Close a proviously open file
+     * @param fd File descriptor of the open file to close
+     * @return
+     */
+    static inline int closef(int fd)
+    {
+        return do_syscall(SYS_CLOSE, (unsigned long)fd, 0, 0, 0);
+    }
+
+    /**
+     * @brief Create a new file at the given path
+     * @param path Path of the file to create
+     * @param flags Mode for the new file
+     * @return
+     */
+    static inline int create(const char *path, int flags)
+    {
+        return do_syscall(SYS_CREATE, (unsigned long)path, (unsigned long)flags, 0, 0);
+    }
+
+    /**
+     * @brief
+     * @param fd
+     * @return
+     */
+    static inline int unlink(int fd)
+    {
+        return do_syscall(SYS_UNLINK, (unsigned long)fd, 0, 0, 0);
+    }
+
+    /**
+     * @brief
+     * @param fd
+     * @param buffer
+     * @param size
+     * @return
+     */
+    static inline int read(int fd, void *buffer, unsigned long size)
+    {
+        return do_syscall(SYS_READ, (unsigned long)fd, (unsigned long)buffer, size, 0);
+    }
+
+    /**
+     * @brief
+     * @param fd
+     * @param buffer
+     * @param size
+     * @return
+     */
+    static inline int write(int fd, const void *buffer, unsigned long size)
+    {
+        return do_syscall(SYS_WRITE, (unsigned long)fd, (unsigned long)buffer, size, 0);
+    }
+
+    static inline int fddup(int oldfd, int newfd)
+    {
+        return do_syscall(SYS_FDDUP, (unsigned long)oldfd, (unsigned long)newfd, 0, 0);
+    }
+
+    static inline int create_pipe(int pipefd[2])
+    {
+        return do_syscall(SYS_CREATE_PIPE, (unsigned long)pipefd, 0, 0, 0);
+    }
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/types/physaddr.h

@@ -0,0 +1,6 @@
+#ifndef KERNEL_PHYSADDR_H
+#define KERNEL_PHYSADDR_H
+
+typedef unsigned long physaddr_t;
+
+#endif

include/types/pid.h

@@ -0,0 +1,6 @@
+#ifndef KERNEL_PID_H
+#define KERNEL_PID_H
+
+typedef unsigned int pid_t;
+
+#endif

include/types/status.h

@@ -0,0 +1,28 @@
+#ifndef KERNEL_STATUS_H
+#define KERNEL_STATUS_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    enum error_t
+    {
+        ENONE = 0,
+        EUNKNOWN = -1,
+        ENOSYS = -2,
+        EEOF = -3,
+        ENOFILE = -4,
+        ENOMEM = -5,
+        EINVAL = -6,
+        EIO = -7,
+        EEXISTS = -8,
+        EPIPE = -9,
+        EFULL = -10
+    };
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/types/syscallid.h

@@ -0,0 +1,36 @@
+#ifndef KERNEL_SYSCALLID_H
+#define KERNEL_SYSCALLID_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    typedef enum syscallid_t
+    {
+        SYS_PRINTK = 0,
+        SYS_MMAP,
+        SYS_MUNMAP,
+        SYS_CLONE,
+        SYS_TERMINATE,
+        SYS_EXEC,
+        SYS_YIELD,
+        SYS_SIGRAISE,
+        SYS_SIGRET,
+        SYS_SIGWAIT,
+        SYS_SIGACTION,
+        SYS_OPEN,
+        SYS_CLOSE,
+        SYS_CREATE,
+        SYS_UNLINK,
+        SYS_READ,
+        SYS_WRITE,
+        SYS_FDDUP,
+        SYS_CREATE_PIPE
+    } syscallid_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif