Kshell: load executable command

Reviewed-on: #18

Makefile

@@ -16,11 +16,15 @@ endif
 OBJFILES := $(patsubst $(SRC)/%.c, $(BUILDDIR)/%.o, $(SOURCES))
 
 CC := x86_64-elf-gcc
-CC_FLAGS=-Wall -Wextra -std=gnu99 -nostdlib -ffreestanding -fstack-protector -fno-omit-frame-pointer -fno-stack-check -fno-PIC -ffunction-sections -fdata-sections -mcmodel=kernel
+CC_FLAGS=-Wall -Wextra -std=gnu99 -nostdlib -ffreestanding -fstack-protector -fno-omit-frame-pointer -fno-stack-check -fno-PIC -ffunction-sections -fdata-sections -mcmodel=kernel -mno-red-zone
 
 LD := x86_64-elf-ld
 
 $(ELFFILE): $(BUILDDIR) $(OBJFILES)
+	nasm -f bin user/hello.S -o $(BUILDDIR)/hello
+	nasm -f bin user/pedicel.S -o $(BUILDDIR)/pedicel
+	tar cvf $(BUILDDIR)/initfs.tar -C $(BUILDDIR) hello pedicel
+
 	nasm -f elf64 src/arch/x86/idt.S -o $(BUILDDIR)/idt_stub.o
 	$(LD) -o $(ELFFILE) -T linker.ld $(OBJFILES) $(BUILDDIR)/idt_stub.o
 	# Get the symbols for debugging
@@ -41,12 +45,15 @@ limine/limine:
 	git clone https://github.com/limine-bootloader/limine.git --branch=v9.x-binary --depth=1
 	$(MAKE) -C limine
 
+initfs:
+
 build-iso: limine/limine $(ELFFILE)
 	rm -rf iso_root
 	mkdir -p iso_root/boot
 	cp -v $(ELFFILE) iso_root/boot
 	mkdir -p iso_root/boot/limine
 	cp -v limine.conf iso_root/boot/limine
+	cp $(BUILDDIR)/initfs.tar iso_root/boot/
 	mkdir -p iso_root/EFI/BOOT
 	cp -v limine/limine-bios.sys limine/limine-bios-cd.bin limine/limine-uefi-cd.bin iso_root/boot/limine/
 	cp -v limine/BOOTX64.EFI iso_root/EFI/BOOT/

docs/MANUAL.md

@@ -25,6 +25,9 @@ The recommended hardware to run PepperOS is the following:
 
 ## b. Features
 
+- Round robin preemptive scheduling
+- Coexistence of ring 0 and ring 3 processes
+
 ## II. Kernel architecture
 
 ### a. Boot process
@@ -37,4 +40,9 @@ The recommended hardware to run PepperOS is the following:
 
 ## III. Syscall table
 
-Not yet implemented.
+The syscall interface in the Pepper kernel uses the System V ABI convention for argument order.
+
+Name | Number (%rax) | arg0 (%rdi) | arg1 (%rsi) | arg2 (%rdx) |
+|---|---|---|---|---|
+| sys_write | 1 | unsigned int fd | const char* buf | size_t count | | 
+| sys_exit | 60 | int error_code | | | |

include/arch/x86.h

@@ -10,7 +10,6 @@ void wrmsr(uint32_t msr, uint64_t value);
 bool x86_has_msr();
 void x86_arch_init();
 
-
 void x86_cpu_identification();
 int cpuid_get_vendor_string(char* str);
 

include/config.h

@@ -9,8 +9,8 @@
 
 /* version */
 #define PEPPEROS_VERSION_MAJOR "0"
-#define PEPPEROS_VERSION_MINOR "0"
+#define PEPPEROS_VERSION_MINOR "1"
-#define PEPPEROS_VERSION_PATCH "109"
+#define PEPPEROS_VERSION_PATCH "121"
 #define PEPPEROS_SPLASH \
 "\x1b[38;5;196m                                      \x1b[38;5;231m____  _____\r\n\x1b[0m"\
 "\x1b[38;5;196m    ____  ___  ____  ____  ___  _____\x1b[38;5;231m/ __ \\/ ___/\r\n\x1b[0m"\
@@ -40,6 +40,11 @@
 #define KERNEL_STACK_SIZE 65536
 #define KERNEL_IDT_ENTRIES 33
 
+/* user */
+#define USER_STACK_TOP 0x80000000
+#define USER_STACK_PAGES 16 // 16*4096 = 64kb
+#define USER_CODE_START 0x400000 // like linux
+
 /* paging */
 #define PAGING_MAX_PHYS 0x200000000
 

include/fs/initfs.h

@@ -0,0 +1,15 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   PS/2 Keyboard driver
+ * @license GPL-3.0-only
+ */
+
+#ifndef INITFS_H
+#define INITFS_H
+
+#include <limine.h>
+
+int initfs_init(struct limine_file* tar_file);
+int tar_lookup(unsigned char* archive, char* filename, char** out);
+
+#endif

include/kernel.h

@@ -10,7 +10,8 @@
 #include "limine.h"
 enum ErrorCodes {
 	ENOMEM,
-	EIO
+	EIO,
+	ENOENT
 };
 
 #define CLEAR_INTERRUPTS __asm__ volatile("cli")
@@ -46,6 +47,8 @@ void debug_stack_trace(unsigned int max_frames);
 const char* debug_find_symbol(uintptr_t rip, uintptr_t* offset);
 void boot_mem_display(void);
 
+int loader_load_raw();
+
 #define assert(check) do { if(!(check)) hcf(); } while(0)
 
 struct boot_context {
@@ -54,6 +57,7 @@ struct boot_context {
 	struct limine_hhdm_response* hhdm;
 	struct limine_kernel_address_response* kaddr;
 	struct limine_boot_time_response* bootdate;
+	struct limine_module_response* module;
 };
 
 // Are these modules initialized yet?

include/mem/vmm.h

@@ -22,6 +22,8 @@ void vmm_unmap(uint64_t* pml4, uint64_t virt);
 void* vmm_map(uint64_t* pml4, uint64_t virt, uint64_t flags);
 uint64_t* vmm_create_address_space();
 uint64_t vmm_virt_to_phys(uint64_t* pml4, uint64_t virt);
+uintptr_t vmm_alloc_user_stack(uint64_t* pml4);
+uintptr_t vmm_alloc_user_code(uint64_t* pml4, void* code_addr, uint64_t code_size);
 
 #define VMM_USER_SPACE_START 0x0000000000001000 
 #define VMM_USER_SPACE_END   0x00007FFFFFFFF000

include/sched/process.h

@@ -10,6 +10,7 @@
 #include <stddef.h>
 #include <config.h>
 #include <stdint.h>
+#include <limine.h>
 
 typedef enum {
     READY,
@@ -24,6 +25,7 @@ struct process {
     status_t status;
     struct cpu_status* context;
 	void* root_page_table; // Process PML4 (should contain kernel PML4 in higher half [256-511]
+    void* kernel_stack; // Used for interrupts (syscall: int 0x80), defines the TSS RSP0
     struct process* next;
 };
 
@@ -36,4 +38,7 @@ void process_exit(void);
 
 void process_display_list(struct process* processes_list);
 
+void process_create_user(struct limine_file* file, char* name);
+void process_create_user_raw(char* file, int size, char* name);
+
 #endif

include/string/string.h

@@ -13,5 +13,6 @@ char *strcpy(char *dest, const char *src);
 char *strcat(char *dest, const char *src);
 void strncpy(char* dst, const char* src, size_t n);
 int strncmp(const char* s1, const char* s2, size_t n);
+size_t strlen(const char* str);
 
 #endif

limine.conf

@@ -6,3 +6,4 @@ interface_branding: Welcome to the PepperOS disk!
 	
 	comment: Default configuration (warning: spicy)
 	path: boot():/boot/pepperk
+	module_path: boot():/boot/initfs.tar

src/arch/x86/idt.c

@@ -77,7 +77,7 @@ void idt_init()
         idt_set_entry(i, vector_0_handler + (i*16), 0);
     }
 
-    idt_set_entry(0x80, vector_128_handler, 0);
+    idt_set_entry(0x80, vector_128_handler, 3);
 
     idt_load(&idt);
     DEBUG("IDT initialized");

src/arch/x86/init.c

@@ -45,7 +45,7 @@ static void x86_enable_fpu()
 	__asm__ volatile("mov %%cr4, %0" : "=r"(cr4));
 	cr4 |= 0x200;
 	__asm__ volatile("mov %0, %%cr4" :: "r"(cr4));
-    uint16_t cw = 0x37F;
+    uint16_t cw = 0x37F; // control word
     asm volatile("fldcw %0" :: "m"(cw));
 }
 

src/arch/x86/syscall.c

@@ -4,21 +4,72 @@
  * @license GPL-3.0-only
  */
 
+#include "sched/scheduler.h"
 #include <arch/x86.h>
 #include <kernel.h>
+#include <stddef.h>
+#include <io/term/term.h>
+#include <sched/process.h>
 
+extern struct process* current_process;
+
+void sys_write(unsigned int fd, const char* buf, size_t count)
+{
+    switch (fd) {
+        case 1: //stdout
+            for (size_t i=0; i<count; i++) {
+                internal_putc(buf[i], NULL);
+            }
+            break;
+
+        case 2: //stderr
+            for (size_t i=0; i<count; i++) {
+                internal_putc(buf[i], NULL);
+            }
+            break;
+    }
+}
+
+void sys_exit(int error_code)
+{
+    current_process->status = DEAD;
+    DEBUG("exiting process PID=%u name=%s", current_process->pid, current_process->name);
+}
+
+/*
+ * syscall_handler - System call dispatcher
+ * @regs: CPU state
+ *
+ * This function is called from the interrupt dispatcher,
+ * when an interrupt 0x80 is emitted from userland.
+ *
+ * It switches control to the syscall number provided
+ * in %rax. 
+ *
+ * We try to follow the System V convention here:
+ * - syscall number in %rax
+ * - args in %rdi, %rsi, %rdx, %r10, %r8, %r9
+ * - return value (if any) in %rax
+ *
+ * Return:
+ * <regs> - CPU state after system call
+ */
 struct cpu_status* syscall_handler(struct cpu_status* regs)
 {
-    DEBUG("Syscall %lx with argument %lx", regs->rdi, regs->rsi);
+    DEBUG("Syscall %lx with (arg0=%lx arg1=%lx)", regs->rax, regs->rdi, regs->rsi);
 
-    switch (regs->rdi)
+    switch (regs->rax)
     {
-        case 0:
+        case 0: //sys_read
             break;
-        case 1:
+        case 1: //sys_write
+            sys_write(regs->rdi, (char*)regs->rsi, regs->rdx);
+            break;
+        case 60: //sys_exit
+            sys_exit(regs->rdi);
             break;
         default:
-            regs->rsi = 0xdeadbeef;
+            regs->rax = 0xbad515ca11;
             break;
     }
 

src/boot/boot.c

@@ -13,6 +13,9 @@
 #include <limine.h>
 #include <stddef.h>
 
+__attribute__((used, section(".limine_requests_start")))
+volatile LIMINE_REQUESTS_START_MARKER;
+
 __attribute__((used, section(".limine_requests")))
 volatile struct limine_framebuffer_request framebuffer_request = {
 	.id = LIMINE_FRAMEBUFFER_REQUEST,
@@ -43,8 +46,11 @@ volatile struct limine_boot_time_request date_request = {
 	.revision = 0
 };
 
-__attribute__((used, section(".limine_requests_start")))
+__attribute__((used, section(".limine_requests")))
-volatile LIMINE_REQUESTS_START_MARKER;
+volatile struct limine_module_request module_request = {
+	.id = LIMINE_MODULE_REQUEST,
+	.revision = 0
+};
 
 __attribute__((used, section(".limine_requests_end")))
 volatile LIMINE_REQUESTS_END_MARKER;
@@ -58,4 +64,5 @@ void populate_boot_context(struct boot_context* ctx)
 	ctx->hhdm = hhdm_request.response ? hhdm_request.response : NULL;
 	ctx->kaddr = kerneladdr_request.response ? kerneladdr_request.response : NULL;
 	ctx->bootdate = date_request.response ? date_request.response : NULL;
+	ctx->module = module_request.response ? module_request.response : NULL;
 }

src/debug/panic.c

@@ -18,7 +18,7 @@ extern int panic_count;
  */
 void read_rflags(uint64_t rflags)
 {
-	DEBUG("\x1b[38;5;226m%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\x1b[38;5;231m",
+	printf("\x1b[38;5;226m%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\x1b[38;5;231m",
 		CHECK_BIT(rflags, 0) ? "CF " : "", /*carry flag*/
 		CHECK_BIT(rflags, 2) ? "PF " : "", /*parity flag*/
 		CHECK_BIT(rflags, 4) ? "AF " : "", /*auxiliary carry flag*/

src/fs/initfs.c

@@ -0,0 +1,76 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Initial TAR filesystem (read-only)
+ * @license GPL-3.0-only
+ */
+
+#include <sched/process.h>
+#include <limine.h>
+#include <fs/initfs.h>
+#include <kernel.h>
+#include <mem/utils.h>
+#include <string/string.h>
+
+void* archive_start_addr;
+uint64_t archive_size;
+
+/*
+ * tar_oct2bin - convert octal size string to an integer 
+ * @str:  octal size string
+ * @size: size of string
+ *
+ * Return:
+ * $n - file size as an integer
+ */
+int tar_oct2bin(unsigned char* str, int size)
+{
+    int n = 0;
+    unsigned char* c = str;
+    while (size-- > 0) {
+        n *= 8;
+        n += *c - '0';
+        c++;
+    }
+    return n;
+}
+
+/*
+ * tar_lookup - lookup a file in the TAR file
+ * @archive:  pointer to beginning of the archive
+ * @filename: file to lookup (absolute path)
+ * @out:      where to store file data if found
+ *
+ * Return:
+ * $filesize - size of the file, if found 
+ * $0        - file not found
+ */
+int tar_lookup(unsigned char* archive, char* filename, char** out)
+{
+    unsigned char *ptr = archive;
+
+    while (!memcmp(ptr + 257, "ustar", 5)) {
+        int filesize = tar_oct2bin(ptr + 0x7c, 11);
+        if (!memcmp(ptr, filename, strlen(filename) + 1)) {
+            *out = (char*)(ptr + 512);
+            return filesize;
+        }
+        ptr += (((filesize + 511) / 512) + 1) * 512;
+    }
+    return 0;
+}
+
+/*
+ * initfs_init - initialize the TAR initial filesystem
+ * @tar_file: pointer to the Limine-loaded archive
+ *
+ * Return:
+ * $0       - on success
+ */
+int initfs_init(struct limine_file* tar_file)
+{
+    archive_start_addr = tar_file->address;
+    archive_size = tar_file->size;
+
+    DEBUG("Loaded TAR initial filesystem (initfs.tar)");
+    return 0;
+}

src/kapps/kshell.c

@@ -51,7 +51,8 @@ void pedicel_main(void* arg)
                             "pf      - trigger a page fault\r\n"
                             "now     - get current date\r\n"
                             "smash   - smash the stack\r\n"
-                            "mem     - get used heap info\r\n");
+                            "mem     - get used heap info\r\n"
+                            "load    - load an user executable\r\n");
             continue;
         }
 
@@ -96,6 +97,11 @@ void pedicel_main(void* arg)
             continue;
         }
 
+        if (strncmp(input_buf, "load", 4) == 0) {
+            loader_load_raw();
+            continue;
+        }
+
         printf("%s: command not found\r\n", input_buf);
     }
 }

src/kapps/loader.c

@@ -0,0 +1,32 @@
+/*
+ * @author  xamidev <xamidev@riseup.net>
+ * @brief   Executable loader
+ * @license GPL-3.0-only
+ */         
+
+#include <stddef.h>
+#include <fs/initfs.h>
+#include <kernel.h>
+#include <sched/process.h>
+#include <io/kbd/ps2.h>
+#include <string/string.h>
+
+extern void* archive_start_addr;
+
+int loader_load_raw()
+{
+    char input_buf[PEDICEL_INPUT_SIZE] = {0};
+    do {
+        printf("file> ");
+        keyboard_getline(input_buf, PEDICEL_INPUT_SIZE);   
+    } while (strncmp(input_buf, "", 1) == 0);
+
+    char* data = NULL;
+    int sz = tar_lookup(archive_start_addr, input_buf,&data);
+    if (sz > 0) {
+        process_create_user_raw(data, sz, input_buf);
+        return 0; // TODO: should return something else on error
+    }
+    printf("Couldn't load file '%s'\r\n", input_buf);
+    return 1;
+}

src/kmain.c

@@ -25,6 +25,7 @@
 #include <io/term/flanterm_backends/fb.h>
 #include <arch/x86.h>
 #include <boot/boot.h>
+#include <fs/initfs.h>
 
 // Limine version used
 __attribute__((used, section(".limine_requests")))
@@ -62,6 +63,9 @@ extern volatile struct limine_memmap_request memmap_request;
 extern volatile struct limine_hhdm_request hhdm_request;
 extern volatile struct limine_kernel_address_request kerneladdr_request;
 extern volatile struct limine_boot_time_request date_request;
+extern volatile struct limine_module_request module_request;
+
+struct limine_file* file;
 
 extern struct process* processes_list;
 extern struct process* current_process;
@@ -115,8 +119,15 @@ void kmain()
 	
 	process_init();
 	idle_proc = process_create("idle", (void*)idle_main, 0);
-	process_create("pedicel", (void*)pedicel_main, 0);
 
+	if (!boot_ctx.module) {
+		panic(NULL, "could not load initfs.tar :(");
+	}
+	if (boot_ctx.module->module_count == 1) {
+		initfs_init(boot_ctx.module->modules[0]);
+	}
+	
+	process_create("kshell", (void*)pedicel_main, 0);
 	scheduler_init();
 
 	printf(PEPPEROS_SPLASH);

src/mem/paging.c

@@ -99,30 +99,46 @@ void paging_map_page(uint64_t* root_table, uint64_t virt, uint64_t phys, uint64_
 
     uint64_t *pdpt, *pd, *pt;
 
+    // Any parent entry on a userspace mapping must also carry PTE_USER,
+    // otherwise CPL3 accesses fault even if the final PTE is user.
+    uint64_t parent_flags = PTE_PRESENT | PTE_WRITABLE;
+    if (flags & PTE_USER) {
+        parent_flags |= PTE_USER;
+    }
+
     // PML4
     // If the entry at index is not present, allocate enough space for it
     // then populate the entry with correct addr + flags
     if (!(root_table[pml4_i] & PTE_PRESENT)) {
         pdpt = alloc_page_table();
-        root_table[pml4_i] = VIRT_TO_PHYS(pdpt) | PTE_PRESENT | PTE_WRITABLE;
+        root_table[pml4_i] = VIRT_TO_PHYS(pdpt) | parent_flags;
     } else {
         pdpt = (uint64_t *)PHYS_TO_VIRT(root_table[pml4_i] & PTE_ADDR_MASK);
+        if (flags & PTE_USER) {
+            root_table[pml4_i] |= PTE_USER;
+        }
     }
 
     // PDPT: same here
     if (!(pdpt[pdpt_i] & PTE_PRESENT)) {
         pd = alloc_page_table();
-        pdpt[pdpt_i] = VIRT_TO_PHYS(pd) | PTE_PRESENT | PTE_WRITABLE;
+        pdpt[pdpt_i] = VIRT_TO_PHYS(pd) | parent_flags;
     } else {
         pd = (uint64_t *)PHYS_TO_VIRT(pdpt[pdpt_i] & PTE_ADDR_MASK);
+        if (flags & PTE_USER) {
+            pdpt[pdpt_i] |= PTE_USER;
+        }
     }
 
     // PD: and here
     if (!(pd[pd_i] & PTE_PRESENT)) {
         pt = alloc_page_table();
-        pd[pd_i] = VIRT_TO_PHYS(pt) | PTE_PRESENT | PTE_WRITABLE;
+        pd[pd_i] = VIRT_TO_PHYS(pt) | parent_flags;
     } else {
         pt = (uint64_t *)PHYS_TO_VIRT(pd[pd_i] & PTE_ADDR_MASK);
+        if (flags & PTE_USER) {
+            pd[pd_i] |= PTE_USER;
+        }
     }
 
     // PT: finally, populate the page table entry

src/mem/vmm.c

@@ -13,6 +13,7 @@ in a specified virtual space
 compared to the PMM which allocs/frees 4kb frames ("physical pages").
 */
 
+#include "config.h"
 #include <mem/vmm.h>
 #include <mem/paging.h>
 #include <stddef.h>
@@ -225,6 +226,43 @@ void* vmm_alloc_region(uint64_t* pml4, size_t pages, uint64_t flags)
     return NULL;
 }
 
+/*
+ * vmm_map_user_stack - Map a user stack
+ * @pml4: the user process's PML4
+ *
+ * This function maps and allocates a userspace
+ * stack in the user @pml4 provided, according
+ * to constants USER_STACK_TOP and USER_STACK_PAGES.
+ *
+ * Return:
+ * <addr> - User stack top address
+ */
+
+uintptr_t vmm_alloc_user_stack(uint64_t* pml4)
+{
+    uintptr_t stack_top = USER_STACK_TOP;
+    size_t stack_size = USER_STACK_PAGES*PAGE_SIZE;
+
+    for (size_t i=stack_top; i>stack_top-stack_size; i-=PAGE_SIZE) {
+        vmm_map(pml4, i, PTE_PRESENT | PTE_WRITABLE | PTE_USER);
+    }
+    return stack_top;
+}
+
+uintptr_t vmm_alloc_user_code(uint64_t* pml4, void* code_addr, uint64_t code_size)
+{
+    uintptr_t code_start = USER_CODE_START;
+    
+    // Round code_size up to next page boundary
+    uint64_t code_size_aligned = (code_size + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
+    
+    for (uint64_t i=code_start; i<code_start+code_size_aligned; i+=PAGE_SIZE) {
+        vmm_map(pml4, i, PTE_PRESENT | PTE_WRITABLE | PTE_USER);
+    } 
+    
+    return code_start;
+}
+
 void vmm_init()
 {
     // NO U

src/sched/process.c

@@ -4,6 +4,8 @@
  * @license GPL-3.0-only
  */
 
+#include "mem/paging.h"
+#include "mem/vmm.h"
 #include <stddef.h>
 #include <sched/process.h>
 #include <mem/kheap.h>
@@ -13,6 +15,7 @@
 #include <config.h>
 #include <io/serial/serial.h>
 #include <io/term/flanterm.h>
+#include <mem/utils.h>
 
 extern struct flanterm_context* ft_ctx;
 
@@ -95,6 +98,8 @@ struct process* process_create(char* name, void(*function)(void*), void* arg)
     // 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->kernel_stack = kalloc_stack();
+
     proc->next = 0;
 
     process_add(&processes_list, proc);
@@ -197,3 +202,121 @@ void process_exit()
         asm("hlt");
     }
 }
+
+/*
+ * process_jump_to_user - Jump to userland
+ * @stack_top: Address of the top of the user stack
+ * @user_code: Address of the first instruction of user code
+ */
+void process_jump_to_user(uintptr_t stack_top, uintptr_t user_code)
+{
+    // 0x20 | 3 = 0x23 (user data segment | 3)
+    // 0x18 | 3 = 0x1B (user code segment | 3)
+    asm volatile(" \
+        push $0x23 \n\
+        push %0 \n\
+        push $0x202 \n\
+        push $0x1B \n\
+        push %1 \n\
+        iretq \n\
+        " :: "r"(stack_top), "r"(user_code));
+}
+
+extern struct tss tss;
+
+/*
+ * process_create_user - Create a new user process
+ * @file: pointer to Limine file structure
+ * @name: name for the new process
+ *
+ * This function takes a loaded Limine executable
+ * module, and maps its code, a user stack, sets the
+ * TSS RSP0 for interrupts, and finally jumps to the
+ * user code.
+ */
+void process_create_user(struct limine_file* file, char* name)
+{
+    CLEAR_INTERRUPTS;
+    struct process* proc = (struct process*)kmalloc(sizeof(struct process));
+    struct cpu_status* ctx = (struct cpu_status*)kmalloc(sizeof(struct cpu_status));
+
+    if (!proc || !ctx) panic(NULL, "out of memory while creating user process");
+
+    strncpy(proc->name, name, PROCESS_NAME_MAX);
+    memset(ctx, 0, sizeof(struct cpu_status)); // set GP registers to zero
+    proc->pid = next_free_pid++;
+    proc->status = READY;
+    proc->next = 0;
+    proc->context = ctx;
+    proc->context->iret_ss = USER_DATA_SEGMENT | 3;
+    proc->context->iret_cs = USER_CODE_SEGMENT | 3;
+    proc->context->iret_flags = 0x202; // Interrupt Flag set
+
+    void* exec_addr = file->address;
+    uint64_t exec_size = file->size;
+
+    uint64_t* user_pml4 = vmm_create_address_space();
+    if (!user_pml4) panic(NULL, "failed to create user address space");
+    proc->root_page_table = user_pml4;
+
+    uintptr_t stack_top = vmm_alloc_user_stack(user_pml4);
+    uint64_t code = vmm_alloc_user_code(user_pml4, exec_addr, exec_size);
+    
+    proc->context->iret_rsp = stack_top;
+    proc->context->iret_rip = code;
+    proc->kernel_stack = kalloc_stack();
+    if (!proc->kernel_stack) panic(NULL, "failed to allocate kernel stack");
+
+    // Copy code into user pages; for that we need to temporarily switch to the user pml4
+    load_cr3(VIRT_TO_PHYS((uint64_t)user_pml4));
+    memcpy((uint64_t*)code, exec_addr, exec_size);
+    load_cr3(VIRT_TO_PHYS((uint64_t)kernel_pml4));
+
+    process_add(&processes_list, proc);
+    DEBUG("user process '%s' (pid=%u) enqueued for scheduling", name, proc->pid);
+    SET_INTERRUPTS;
+}
+
+// Same as above but for a raw data pointer (pointing to raw binary, no ELF)
+void process_create_user_raw(char* file, int size, char* name)
+{
+    CLEAR_INTERRUPTS;
+    struct process* proc = (struct process*)kmalloc(sizeof(struct process));
+    struct cpu_status* ctx = (struct cpu_status*)kmalloc(sizeof(struct cpu_status));
+
+    if (!proc || !ctx) panic(NULL, "out of memory while creating user process");
+
+    strncpy(proc->name, name, PROCESS_NAME_MAX);
+    memset(ctx, 0, sizeof(struct cpu_status)); // set GP registers to zero
+    proc->pid = next_free_pid++;
+    proc->status = READY;
+    proc->next = 0;
+    proc->context = ctx;
+    proc->context->iret_ss = USER_DATA_SEGMENT | 3;
+    proc->context->iret_cs = USER_CODE_SEGMENT | 3;
+    proc->context->iret_flags = 0x202; // Interrupt Flag set
+
+    void* exec_addr = (void*)file;
+    uint64_t exec_size = size;
+
+    uint64_t* user_pml4 = vmm_create_address_space();
+    if (!user_pml4) panic(NULL, "failed to create user address space");
+    proc->root_page_table = user_pml4;
+
+    uintptr_t stack_top = vmm_alloc_user_stack(user_pml4);
+    uint64_t code = vmm_alloc_user_code(user_pml4, exec_addr, exec_size);
+    
+    proc->context->iret_rsp = stack_top;
+    proc->context->iret_rip = code;
+    proc->kernel_stack = kalloc_stack();
+    if (!proc->kernel_stack) panic(NULL, "failed to allocate kernel stack");
+
+    // Copy code into user pages; for that we need to temporarily switch to the user pml4
+    load_cr3(VIRT_TO_PHYS((uint64_t)user_pml4));
+    memcpy((uint64_t*)code, exec_addr, exec_size);
+    load_cr3(VIRT_TO_PHYS((uint64_t)kernel_pml4));
+
+    process_add(&processes_list, proc);
+    DEBUG("user process '%s' (pid=%u) enqueued for scheduling", name, proc->pid);
+    SET_INTERRUPTS;
+}

src/sched/scheduler.c

@@ -9,17 +9,21 @@
 #include <mem/paging.h>
 #include <stdint.h>
 #include <io/serial/serial.h>
+#include <arch/gdt.h>
 
 extern struct process* processes_list;
 extern struct process* current_process;
 extern struct process* idle_proc;
 
+extern struct tss tss;
+
 /*
  * scheduler_init - Choose the first process
  */
 void scheduler_init()
 {
     current_process = processes_list;
+    DEBUG("scheduler starting with: pid=%u, name='%s', context=%p", current_process->pid, current_process->name, current_process->context);
 }
 
 /*
@@ -39,42 +43,56 @@ struct cpu_status* scheduler_schedule(struct cpu_status* context)
     }
 
     if (current_process == NULL) {
-        // If no more processes, then set IDLE as the current process, that's it.
+        panic(NULL, "current_process is NULL");
-        current_process = idle_proc;
     }
     
-    if (current_process == idle_proc && current_process->next == NULL)
+    if (current_process->context == NULL) {
-    {
+        panic(NULL, "current_process->context is NULL");
-        return idle_proc->context;
     }
 
     current_process->context = context;
 
-    for (;;) {
+    if (current_process->status == DEAD) {
-        struct process* prev_process = current_process;
+        struct process* dead_process = current_process;
-        if (current_process->next != NULL) {
+        struct process* next_process = (dead_process->next != NULL) ? dead_process->next : processes_list;
-            current_process = current_process->next;
+
-        } else {
+        process_delete(&processes_list, dead_process);
-            current_process = processes_list;
+
+        if (processes_list == NULL || next_process == dead_process) {
+            current_process = idle_proc;
+            return idle_proc->context;
         }
 
-        if (current_process != NULL && current_process->status == DEAD) {
+        current_process = next_process;
-            process_delete(&prev_process, current_process);
+    } else if (current_process->next != NULL) {
-            current_process = NULL;
+        current_process = current_process->next;
-            return idle_proc->context;
+    } else {
-        } else {
+        current_process = processes_list;
-            current_process->status = RUNNING;
-/*             if (prev_process != current_process) {
-                DEBUG("Changed from {pid=%u, name=%s} to {pid=%u, name=%s}", prev_process->pid, prev_process->name, current_process->pid, current_process->name);
-            } */
-            break;
-        }
     }
 
-    //DEBUG("current_process={pid=%u, name='%s', root_page_table[virt]=%p}", current_process->pid, current_process->name, current_process->root_page_table);
+    for (;;) {
+        if (current_process->status == DEAD) {
+            struct process* dead_process = current_process;
+            struct process* next_process = (current_process->next != NULL) ? current_process->next : processes_list;
 
+            process_delete(&processes_list, dead_process);
+
+            if (processes_list == NULL || next_process == dead_process) {
+                current_process = idle_proc;
+                return idle_proc->context;
+            }
+
+            current_process = next_process;
+            continue;
+        }
+
+        current_process->status = RUNNING;
+        break;
+    }
+
+    // Here, we chose next running process so we load its kernel stack & page tables
+    tss.rsp0 = (uint64_t)current_process->kernel_stack;
     load_cr3(VIRT_TO_PHYS((uint64_t)current_process->root_page_table));
-    //DEBUG("Loaded process PML4 into CR3");
 
     return current_process->context;
 }

src/string/string.c

@@ -99,3 +99,11 @@ int strncmp(const char* s1, const char* s2, size_t n)
         return ( *(unsigned char *)s1 - *(unsigned char *)s2 );
     }
 }
+
+// BSD implementation
+size_t strlen(const char* str)
+{
+        const char* s;
+        for (s = str; *s; ++s);
+        return (s - str);
+}

user/hello.S

@@ -0,0 +1,21 @@
+bits 64
+
+section .data
+    hi db "hi from userland :) we did it man", 0x0A, 0x0d, 0
+
+section .text
+
+hello:
+    mov rax, 0x1        ;sys_write
+    mov rdi, 0x1        ;stdout
+    lea rsi, [rel hi]   ;char* buf
+    mov rdx, 35         ;count
+    int 0x80
+
+.end:
+    mov rax, 0x3C       ;sys_exit
+    mov rdi, 0x0        ;error_code
+    int 0x80
+
+.loop:
+    jmp .loop

user/pedicel.S

@@ -0,0 +1,25 @@
+bits 64
+
+section .data
+hello db 0x0A, 0x0D, "User program 2 speaking", 0x0A, 0x0D, 0
+
+section .text
+
+_start:
+    mov rax, 0x1    ;sys_write
+    mov rdi, 0x1    ;stdout
+    lea rsi, [rel hello]
+    mov rdx, 27     ;count
+    int 0x80
+
+; when we are ready to have an os specific toolchain,
+; this bit (exit & loop) should be appended at the end of every
+; C program we compile.
+
+.end:
+    mov rax, 0x3C
+    mov rdi, 0x0
+    int 0x80
+
+.loop:
+    jmp .loop