Created student weenix repository

7 files changed, 606 insertions, 0 deletions

diff --git a/kernel/include/proc/context.h b/kernel/include/proc/context.h
new file mode 100644
index 0000000..63c692e
--- /dev/null
+++ b/kernel/include/proc/context.h
@@ -0,0 +1,62 @@
+#pragma once
+
+#include "types.h"
+
+#include "mm/pagetable.h"
+
+/*
+ * The function pointer to be implemented by functions which are entry
+ * points for new threads.
+ */
+typedef void *(*context_func_t)(long, void *);
+
+typedef struct context
+{
+    uintptr_t c_rip; /* instruction pointer (RIP) */
+    uintptr_t c_rsp; /* stack pointer (RSP) */
+    uintptr_t c_rbp; /* frame pointer (RBP) */
+
+    pml4_t
+        *c_pml4; /* pointer to the top level page table (PML4) for this proc. 
+                It's the 'root' of the page table where virtual address -> physical address
+                lookup starts. */
+
+    uintptr_t c_kstack;
+    size_t c_kstacksz;
+} context_t;
+
+/**
+ * Initialize the given context such that when it begins execution it
+ * will execute func(arg1,arg2). A kernel stack and page directory 
+ * exclusive to this context must also be provided.
+ *
+ * @param c the context to initialize
+ * @param func the function which will begin executing when this
+ * context is first made active
+ * @param arg1 the first argument to func
+ * @param arg2 the second argument to func
+ * @param kstack a pointer to the kernel stack this context will use
+ * @param kstacksz the size of the kernel stack
+ * @param pdptr the pagetable this context will use
+ */
+void context_setup(context_t *c, context_func_t func, long arg1, void *arg2,
+                   void *kstack, size_t kstacksz, pml4_t *pml4);
+
+void context_setup_raw(context_t *c, void (*func)(), void *kstack,
+                       size_t kstacksz, pml4_t *pml4);
+/**
+ * Makes the given context the one currently running on the CPU. Use
+ * this mainly for the initial context.
+ *
+ * @param c the context to make active
+ */
+void context_make_active(context_t *c);
+
+/**
+ * Save the current state of the machine into the old context, and begin
+ * executing the new context. Used primarily by the scheduler.
+ *
+ * @param oldc the context to switch from
+ * @param newc the context to switch to
+ */
+void context_switch(context_t *oldc, context_t *newc);
diff --git a/kernel/include/proc/core.h b/kernel/include/proc/core.h
new file mode 100644
index 0000000..9d6eb16
--- /dev/null
+++ b/kernel/include/proc/core.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "proc/context.h"
+#include "proc/sched.h"
+#include "proc/spinlock.h"
+
+typedef struct core
+{
+    long kc_id;
+    context_t kc_ctx;
+
+    ktqueue_t *kc_queue;
+
+    uintptr_t kc_csdpaddr;
+} core_t;
diff --git a/kernel/include/proc/kmutex.h b/kernel/include/proc/kmutex.h
new file mode 100644
index 0000000..37d8ece
--- /dev/null
+++ b/kernel/include/proc/kmutex.h
@@ -0,0 +1,60 @@
+#pragma once
+
+#include "proc/sched.h"
+#include "proc/spinlock.h"
+
+/*===========
+ * Structures
+ *==========*/
+
+typedef struct kmutex
+{
+    ktqueue_t km_waitq;        /* wait queue */
+    struct kthread *km_holder; /* current holder */
+    list_link_t km_link;
+} kmutex_t;
+
+#define KMUTEX_INITIALIZER(mtx)                                             \
+    {                                                                       \
+        .km_waitq = KTQUEUE_INITIALIZER((mtx).km_waitq), .km_holder = NULL, \
+        .km_link = LIST_LINK_INITIALIZER((mtx).km_link),                    \
+    }
+
+/*==========
+ * Functions
+ *=========*/
+
+/**
+ * Initializes a mutex.
+ *
+ * @param mtx the mutex
+ */
+void kmutex_init(kmutex_t *mtx);
+
+/**
+ * Locks the specified mutex.
+ *
+ * Note: This function may block.
+ *
+ * Note: These locks are not re-entrant
+ *
+ * @param mtx the mutex to lock
+ */
+void kmutex_lock(kmutex_t *mtx);
+
+/**
+ * Unlocks the specified mutex.
+ *
+ * @param mtx the mutex to unlock
+ */
+void kmutex_unlock(kmutex_t *mtx);
+
+/**
+ * Indicates if a mutex has waiters.
+ */
+long kmutex_has_waiters(kmutex_t *mtx);
+
+/**
+ * Indicates if curthr owns a mutex.
+ */
+long kmutex_owns_mutex(kmutex_t *mtx);
diff --git a/kernel/include/proc/kthread.h b/kernel/include/proc/kthread.h
new file mode 100644
index 0000000..6bc66be
--- /dev/null
+++ b/kernel/include/proc/kthread.h
@@ -0,0 +1,106 @@
+#pragma once
+
+#include <proc/context.h>
+#include <proc/sched.h>
+#include <proc/spinlock.h>
+#include <util/list.h>
+
+/*=====================
+ * Types and structures
+ *====================*/
+
+/*
+ * Alias for an entry point function of a new thread.
+ */
+typedef context_func_t kthread_func_t;
+
+/*
+ * Thread states.
+ */
+typedef enum
+{
+    KT_NO_STATE,          /* Illegal state */
+    KT_ON_CPU,            /* Currently running */
+    KT_RUNNABLE,          /* On the run queue */
+    KT_SLEEP,             /* Blocked indefinitely */
+    KT_SLEEP_CANCELLABLE, /* Blocked, but can be interrupted */
+    KT_EXITED             /* Exited, waiting to be joined */
+} kthread_state_t;
+
+/*
+ * Thread descriptor.
+ */
+typedef struct kthread
+{
+    context_t kt_ctx;     /* Thread context */
+    char *kt_kstack;      /* Kernel stack */
+    void *kt_retval;      /* Return value */
+    long kt_errno;        /* Errno of most recent syscall */
+    struct proc *kt_proc; /* Corresponding process */
+
+    long kt_cancelled;   /* Set if the thread has been cancelled */
+    ktqueue_t *kt_wchan; /* If blocking, the queue this thread is blocked on */
+    kthread_state_t kt_state;
+
+    list_link_t kt_plink; /* Link on the process's thread list, p_threads */
+    list_link_t
+        kt_qlink; /* Link on some ktqueue if the thread is not running */
+
+    list_t kt_mutexes;   /* List of owned mutexes, for use in debugging */
+    long kt_recent_core; /* For SMP */
+
+    uint64_t kt_preemption_count;
+} kthread_t;
+
+/*==========
+ * Functions
+ *=========*/
+
+/**
+ * Initializes the kthread subsystem at system startup.
+ */
+void kthread_init(void);
+
+/**
+ * Allocates and initializes a kernel thread.
+ *
+ * @param proc the process in which the thread will run
+ * @param func the function that will be called when the newly created
+ * thread starts executing
+ * @param arg1 the first argument to func
+ * @param arg2 the second argument to func
+ * @return the newly created thread
+ *
+ */
+kthread_t *kthread_create(struct proc *proc, kthread_func_t func, long arg1,
+                          void *arg2);
+
+/**
+ * Creates a clone of the specified thread
+ *
+ * @param thr the thread to clone
+ * @return a clone of thr
+ */
+kthread_t *kthread_clone(kthread_t *thr);
+
+/**
+ * Frees resources associated with a thread.
+ *
+ * @param thr the thread to free
+ */
+void kthread_destroy(kthread_t *thr);
+
+/**
+ * Cancels a thread.
+ *
+ * @param kthr the thread to be cancelled
+ * @param retval the return value for the thread
+ */
+void kthread_cancel(kthread_t *kthr, void *retval);
+
+/**
+ * Exits the current thread.
+ *
+ * @param retval the return value for the thread
+ */
+void kthread_exit(void *retval);
diff --git a/kernel/include/proc/proc.h b/kernel/include/proc/proc.h
new file mode 100644
index 0000000..bc608a0
--- /dev/null
+++ b/kernel/include/proc/proc.h
@@ -0,0 +1,200 @@
+#pragma once
+
+#include "config.h"
+#include "mm/pagetable.h"
+#include "proc/kthread.h"
+#include "types.h"
+#include "vm/vmmap.h"
+
+/*===========
+ * Structures
+ *==========*/
+
+/*
+ * Process resource information
+ */
+#define PROC_MAX_COUNT 65536
+#define PROC_NAME_LEN 256
+
+/* Process states */
+typedef enum
+{
+    PROC_RUNNING, /* Has running threads */
+    PROC_DEAD     /* Exited, but not yet wait'ed */
+} proc_state_t;
+
+/* Process descriptor */
+typedef struct proc
+{
+    pid_t p_pid;                /* Process ID */
+    char p_name[PROC_NAME_LEN]; /* Process name */
+
+    list_t p_threads;  /* Threads list */
+    list_t p_children; /* Children list */
+    struct proc *p_pproc; /* Parent process */
+
+    list_link_t p_list_link;  /* Link of list of all processes */
+    list_link_t p_child_link; /* Link on parent's list of children */
+
+    long p_status;        /* Exit status */
+    proc_state_t p_state; /* Process state */
+
+    pml4_t *p_pml4; /* Page table. */
+
+    /*
+     * If a parent is waiting on a child, the parent puts itself on its own
+     * p_wait queue. When a child terminates, it broadcasts on its parent's
+     * p_wait to wake it up.
+     */
+    ktqueue_t p_wait;
+
+    /* VFS related */
+    struct file *p_files[NFILES]; /* Open files */
+    struct vnode *p_cwd;          /* Current working directory */
+
+    /* VM related */
+    /*
+     * The current value of a process's break is maintained in the 'p_brk'.
+     *
+     * The 'p_brk' and 'p_start_brk' members of a proc_t struct are initialized
+     * by the loader. 'p_start_brk' is subsequently never modified; it always
+     * holds the initial value of the break.
+     *
+     * The loader sets 'p_start_brk' to be the end of the bss section (search
+     * online for memory layout diagrams of a running process for more
+     * details).
+     * 
+     * These are both addresses. 
+     */
+    void *p_brk;           /* Process break; see brk(2) */
+    void *p_start_brk;     /* Initial value of process break */
+    struct vmmap *p_vmmap; /* List of areas mapped into process's
+                              user address space. */
+} proc_t;
+
+/*==========
+ * Functions
+ *=========*/
+
+/**
+ * Initializes the proc subsystem at system startup.
+ */
+void proc_init(void);
+
+/**
+ * Initializes the special idleproc at system startup.
+ */
+void proc_idleproc_init();
+
+/**
+ * Shuts down certain subsystems at system shutdown.
+ */
+void initproc_finish();
+
+/**
+ * Allocates and initializes a new process.
+ *
+ * @param name the name to give the newly created process
+ * @return the newly created process
+ */
+proc_t *proc_create(const char *name);
+
+/**
+ * Frees all the resources associated with a process.
+ *
+ * @param proc process to destroy
+ */
+void proc_destroy(proc_t *proc);
+
+/**
+ * Handles exiting the current process.
+ *
+ * @param retval exit code for the thread and process
+ */
+void proc_thread_exiting(void *retval);
+
+/**
+ * Stops another process from running again by cancelling all its
+ * threads.
+ *
+ * @param proc the process to kill
+ * @param status the status the process should exit with
+ */
+void proc_kill(proc_t *proc, long status);
+
+/**
+ * Kills every process except for the idle process and direct children
+ * of the idle process.
+ */
+void proc_kill_all(void);
+
+/*========================
+ * Functions: System calls
+ *=======================*/
+
+/**
+ * Implements the _exit(2) system call.
+ *
+ * @param status the exit status of the process
+ */
+void do_exit(long status);
+
+/**
+ * Implements the waitpid(2) system call.
+ *
+ * @param pid the pid to wait on, or -1 to wait on any child
+ * @param status used to return the exit status of the child
+ * @param options only 0 is supported (no options)
+ *
+ * @return the pid of the child process which was cleaned up, or
+ *  - ENOTSUP invalid input
+ *  - ECHILD valid child could not be found
+ */
+pid_t do_waitpid(pid_t pid, int *status, int options);
+
+/**
+ * This function implements the fork(2) system call.
+ *
+ * @param regs the register state at the time of the system call
+ */
+struct regs;
+long do_fork(struct regs *regs);
+
+/*===========
+ * Miscellany
+ *==========*/
+
+/*
+ * Special PIDs reserved for specific processes
+ */
+#define PID_IDLE 0
+#define PID_INIT 1
+
+/*
+ * Enable global use of idleproc
+ */
+extern proc_t idleproc;
+
+/*=====================
+ * Functions: Debugging
+ *====================*/
+
+/**
+ * Provides detailed debug information about a given process.
+ *
+ * @param arg a pointer to the process
+ * @param buf buffer to write to
+ * @param osize size of the buffer
+ * @return the remaining size of the buffer
+ */
+size_t proc_info(const void *arg, char *buf, size_t osize);
+
+/**
+ * Provides debug information overview of all processes.
+ *
+ * @param arg must be NULL
+ * @param buf buffer to write to
+ * @param osize size of the buffer
+ * @return the remaining size of the buffer
+ */
+size_t proc_list_info(const void *arg, char *buf, size_t osize);
\ No newline at end of file
diff --git a/kernel/include/proc/sched.h b/kernel/include/proc/sched.h
new file mode 100644
index 0000000..343e8d5
--- /dev/null
+++ b/kernel/include/proc/sched.h
@@ -0,0 +1,126 @@
+#pragma once
+
+#include "proc/spinlock.h"
+#include "util/list.h"
+
+/*===========
+ * Structures
+ *==========*/
+
+/*
+ * Queue structure for kthreads
+ * Note that ktqueue functions are private - managing the queue
+ *  should be done within sched.c, or using public functions
+ */
+typedef struct ktqueue
+{
+    list_t tq_list;
+    size_t tq_size;
+} ktqueue_t;
+
+/*
+ * Macro to initialize a ktqueue. See sched_queue_init for how the 
+ * queue should be initialized in your code. 
+ */
+#define KTQUEUE_INITIALIZER(ktqueue)                                \
+    {                                                               \
+        .tq_list = LIST_INITIALIZER((ktqueue).tq_list),             \
+    }
+
+/*
+ * kthread declaration to make function signatures happy
+ */
+struct kthread;
+
+/*==========
+ * Functions
+ *=========*/
+
+/**
+ * Runs a new thread from the run queue.
+ *
+ * @param queue the queue to place curthr on
+ */
+void sched_switch(ktqueue_t *queue);
+
+/**
+ * Helps with context switching.
+ */
+void core_switch();
+
+/**
+ * Yields the CPU to another runnable thread.
+ */
+void sched_yield();
+
+/**
+ * Enables a thread to be selected by the scheduler to run.
+ *
+ * @param thr the thread to make runnable
+ */
+void sched_make_runnable(struct kthread *thr);
+
+/**
+ * Causes the current thread to enter into an uncancellable sleep on
+ * the given queue.
+ *
+ * @param q the queue to sleep on
+ * @param lock optional lock for release in another context
+ */
+void sched_sleep_on(ktqueue_t *q);
+
+/**
+ * Causes the current thread to enter into a cancellable sleep on the
+ * given queue.
+ *
+ * @param queue the queue to sleep on
+ * @param lock optional lock for release in another context
+ * @return -EINTR if the thread was cancelled and 0 otherwise
+ */
+long sched_cancellable_sleep_on(ktqueue_t *queue);
+
+/**
+ * Wakes up a thread from q.
+ *
+ * @param q queue
+ * @param thrp if an address is provided, *thrp is set to the woken up thread
+ *
+ */
+void sched_wakeup_on(ktqueue_t *q, struct kthread **thrp);
+
+/**
+ * Wake up all threads running on the queue.
+ *
+ * @param q the queue to wake up threads from
+ */
+void sched_broadcast_on(ktqueue_t *q);
+
+/**
+ * Cancel the given thread from the queue it sleeps on.
+ *
+ * @param the thread to cancel sleep from
+ */
+void sched_cancel(struct kthread *thr);
+
+/**
+ * Initializes a queue.
+ *
+ * @param queue the queue
+ */
+void sched_queue_init(ktqueue_t *queue);
+
+/**
+ * Returns true if the queue is empty.
+ *
+ * @param queue the queue
+ * @return true if the queue is empty
+ */
+long sched_queue_empty(ktqueue_t *queue);
+
+/**
+ * Functions for managing the current thread's preemption status.
+ */
+void preemption_disable();
+void preemption_enable();
+void preemption_reset();
+long preemption_enabled();
\ No newline at end of file
diff --git a/kernel/include/proc/spinlock.h b/kernel/include/proc/spinlock.h
new file mode 100644
index 0000000..4ce57c8
--- /dev/null
+++ b/kernel/include/proc/spinlock.h
@@ -0,0 +1,37 @@
+#pragma once
+
+typedef struct spinlock
+{
+    volatile char s_locked;
+} spinlock_t;
+
+#define SPINLOCK_INITIALIZER(lock) \
+    {                              \
+        .s_locked = 0              \
+    }
+
+/**
+ * Initializes the fields of the specified spinlock_t
+ * @param lock the spinlock to initialize
+ */
+void spinlock_init(spinlock_t *lock);
+
+/**
+ * Locks the specified spinlock.
+ *
+ * Note: this function may spin on the current core.
+ *
+ * Note: these locks are not re-entrant
+ *
+ * @param lock the spinlock to lock
+ */
+void spinlock_lock(spinlock_t *lock);
+
+/**
+ * Unlocks the specified spinlock.
+ *
+ * @param lock the spinlock to unlock
+ */
+void spinlock_unlock(spinlock_t *lock);
+
+long spinlock_ownslock(spinlock_t *lock);