pepperOS/src/sched/process.c

/*
 * @author  xamidev <xamidev@riseup.net>
 * @brief   Process linked list implementation
 * @license GPL-3.0-only
 */

#include <stddef.h>
#include <sched/process.h>
#include <mem/kheap.h>
#include <kernel.h>
#include <string/string.h>
#include <mem/gdt.h>
#include <config.h>
#include <io/serial/serial.h>

#include <io/term/flanterm.h>
extern struct flanterm_context* ft_ctx;

struct process_t* processes_list;
struct process_t* current_process;

extern uint64_t *kernel_pml4;

size_t next_free_pid = 0;

/*
 * process_init - Initializes process list
 */
void process_init()
{
    processes_list = NULL;
    current_process = NULL;
}

/*
 * process_display_list - Debug function to display processes
 * @processes_list: head of the process linked list
 *
 * This function prints the linked list of processes
 * to the DEBUG output.
 */
void process_display_list(struct process_t* processes_list)
{
    int process_view_id = 0;
    struct process_t* tmp = processes_list;
    while (tmp != NULL) {
        DEBUG("{%d: %p} -> ", process_view_id, tmp);
        tmp = tmp->next;
        process_view_id++;
    }
    DEBUG("NULL");
}

/*
 * process_create - Create a process
 * @name:     name of the process
 * @function: beginning of process executable code
 * @arg:      (optional) argument provided to process
 *
 * This function creates a process, gives it all
 * necessary context and a stack, and adds the
 * process to the linked list.
 *
 * Return:
 * <proc> - pointer to created process
 */
struct process_t* process_create(char* name, void(*function)(void*), void* arg)
{
    CLEAR_INTERRUPTS;
    struct process_t* proc = (struct process_t*)kmalloc(sizeof(struct process_t));
    struct cpu_status_t* ctx = (struct cpu_status_t*)kmalloc(sizeof(struct cpu_status_t));

    // No more memory?
    if (!proc) return NULL;
    if (!ctx) return NULL;

    strncpy(proc->name, name, PROCESS_NAME_MAX);
    proc->pid = next_free_pid++;
    proc->status = READY;

    uint64_t* stack_top = (uint64_t*)kalloc_stack();
    // push return address to the stack so when "ret" hits we jmp to exit instead of idk what
    // stack grows DOWNWARDS!!
    *(--stack_top) = (uint64_t)process_exit;

    proc->context = ctx;
    proc->context->iret_ss = KERNEL_DATA_SEGMENT; // process will live in kernel mode
    proc->context->iret_rsp = (uint64_t)stack_top;
    proc->context->iret_flags = 0x202; //bit 2 and 9 set (Interrupt Flag)
    proc->context->iret_cs = KERNEL_CODE_SEGMENT;
    proc->context->iret_rip = (uint64_t)function; // beginning of executable code
    proc->context->rdi = (uint64_t)arg; // 1st arg is in rdi (as per x64 calling convention)
    proc->context->rbp = 0; 

    // Kernel PML4 as it already maps code/stack (when switching to userland we'll have to change that)
    proc->root_page_table = kernel_pml4;

    proc->next = 0;

    process_add(&processes_list, proc);

    SET_INTERRUPTS;
    return proc;
}

/*
 * process_add - Add a process to the end of the linked list
 * @processes_list: pointer to the head of the linked list
 * @process:        process to add at the end of the linked list
 */
void process_add(struct process_t** processes_list, struct process_t* process)
{
    if (!process) return;
    process->next = NULL;

    if (*processes_list == NULL) {
        // List is empty
        *processes_list = process;
        return;
    }

    struct process_t* tmp = *processes_list;
    while (tmp->next != NULL) {
        tmp = tmp->next;
    }
    // We're at last process before NULL
    tmp->next = process;
}

/*
 * process_delete - Delete a process from the linked list
 * @processes_list: pointer to head of linked list
 * @process:        the process to delete from the list
 */
void process_delete(struct process_t** processes_list, struct process_t* process)
{
    if (!processes_list || !*processes_list || !process) return;

    if (*processes_list == process) {
        // process to delete is at head
        *processes_list = process->next;
        process->next = NULL;
        kfree(process);
        return;
    }

    struct process_t* tmp = *processes_list;
    while (tmp->next && tmp->next != process) {
        tmp = tmp->next;
    }

    if (tmp->next == NULL) {
        // Didn't find the process
        return;
    }

    // We're at process before the one we want to delete
    tmp->next = process->next;
    process->next = NULL;
    kfree(process);
}

/*
 * process_get_next - Get the next process (unused)
 * @process: pointer to process
 *
 * Return:
 * <process->next> - process right after the one specified
 */
struct process_t* process_get_next(struct process_t* process)
{
    if (!process) return NULL;
    return process->next;
}

/*
 * process_exit - Exit from a process
 *
 * This function is pushed to all process stacks, as a last
 * return address. Once the process is done executing, it 
 * ends up here.
 *
 * Process is marked as DEAD, and then execution loops.
 * Next time the scheduler sees the process, it will
 * automatically delete it from the linked list.
 */
void process_exit()
{
    DEBUG("Exiting from process '%s'", current_process->name);
    CLEAR_INTERRUPTS;
    if (current_process) {
        current_process->status = DEAD;
    }
    SET_INTERRUPTS;
    
    for (;;) {
        asm("hlt");
    }
}