Add a scheduler which just keeps of processes for now, and a

with_process to interact with them. User space now has it's own address
space and mapper which means we will be able to allocate memory for it.
I added a bunch of functions as stubs into libxunil which are required
for doomgeneric.

user/libxunil/.cargo/config.toml

@@ -0,0 +1,4 @@
+[unstable]
+    json-target-spec = true
+    build-std-features = ["compiler-builtins-mem"]
+    build-std = ["core", "compiler_builtins", "alloc"]

user/libxunil/Cargo.lock

@@ -2,6 +2,52 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "bit_field"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e4b40c7323adcfc0a41c4b88143ed58346ff65a288fc144329c5c45e05d70c6"
+
+[[package]]
+name = "bitflags"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+
+[[package]]
+name = "const_fn"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413d67b29ef1021b4d60f4aa1e925ca031751e213832b4b1d588fae623c05c60"
+
 [[package]]
 name = "libxunil"
 version = "0.1.0"
+dependencies = [
+ "x86_64",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "volatile"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "442887c63f2c839b346c192d047a7c87e73d0689c9157b00b53dcc27dd5ea793"
+
+[[package]]
+name = "x86_64"
+version = "0.15.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7841fa0098ceb15c567d93d3fae292c49e10a7662b4936d5f6a9728594555ba"
+dependencies = [
+ "bit_field",
+ "bitflags",
+ "const_fn",
+ "rustversion",
+ "volatile",
+]

user/libxunil/Cargo.toml

@@ -10,3 +10,9 @@ crate-type = ["staticlib"]
 [profile.release]
 panic = "abort"
 opt-level = "s"
+
+[target.'cfg(target_arch = "x86_64")'.dependencies]
+x86_64 = "0.15.4"
+
+[profile.dev]
+panic = "abort"

user/libxunil/rust-toolchain.toml

@@ -0,0 +1,8 @@
+[toolchain]
+channel = "nightly"
+targets = [
+    "x86_64-unknown-none",
+    # "aarch64-unknown-none",
+    # "riscv64gc-unknown-none-elf",
+    # "loongarch64-unknown-none",
+]

user/libxunil/src/file.rs

@@ -0,0 +1,66 @@
+use core::ptr::null_mut;
+
+#[unsafe(no_mangle)]
+extern "C" fn fopen(path: *const u8, mode: *const u8) -> *mut u8 {
+    null_mut()
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn fclose(file_ptr: *mut u8) -> i32 {
+    0
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn fprintf(file_ptr: *mut u8, s: *const u8) -> i32 {
+    0
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn fread(ptr: *mut u8, size: i32, nmemb: *const u8, fp: *const u8) -> i32 {
+    0
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn fwrite(ptr: *mut u8, size: i32, nmemb: *const u8, fp: *const u8) -> i32 {
+    0
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn fseek(s: *const u8, size: i32, fp: *const u8) -> i32 {
+    0
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn ftell(fp: *const u8) -> i64 {
+    0
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn fflush(file_ptr: *mut u8) -> i32 {
+    0
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn mkdir(path: *const u8, mode: *const u8) -> i32 {
+    0
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn remove(path: *const u8) -> i32 {
+    0
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn rename(path: *const u8, new_path: *const u8) -> i32 {
+    0
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn vfprintf(stream: *const u8, format: *const u8, args: ...) -> i32 {
+    0
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn vsnprintf(s: *mut u8, n: i32, format: *const u8, args: ...) -> i32 {
+    0
+}

user/libxunil/src/include/stdio.h

@@ -2,7 +2,17 @@
 #include <stddef.h>
 #include <stdarg.h>
 
-typedef struct FILE FILE;
+typedef struct _iobuf
+{
+    char*   _ptr;
+    int _cnt;
+    char*   _base;
+    int _flag;
+    int _file;
+    int _charbuf;
+    int _bufsiz;
+    char*   _tmpfname;
+} FILE;
 
 extern FILE *stdin;
 extern FILE *stdout;

user/libxunil/src/lib.rs

@@ -1,20 +1,24 @@
 #![no_std]
-#![no_main]
+#![feature(c_variadic)]
+
+use core::ptr::null;
 
 use crate::syscall::syscall3;
 
+pub mod file;
+pub mod mem;
 pub mod syscall;
 
 const SYS_EXIT: usize = 1;
 const SYS_WRITE: usize = 60;
 
 #[unsafe(no_mangle)]
-extern "C" fn write(fd: i32, buf: *const u8, count: usize) -> isize {
+extern "C" fn write(fd: i64, buf: *const u8, count: usize) -> isize {
     unsafe { syscall3(SYS_WRITE, fd as usize, buf as usize, count) }
 }
 
 #[unsafe(no_mangle)]
-extern "C" fn exit(code: i32) -> ! {
+extern "C" fn exit(code: i64) -> ! {
     unsafe { syscall3(SYS_EXIT, code as usize, 0, 0) };
     loop {}
 }
@@ -36,14 +40,26 @@ extern "C" fn puts(s: *const u8) -> isize {
 }
 
 #[unsafe(no_mangle)]
-extern "C" fn abs(n: i32) -> i32 {
+extern "C" fn putchar(s: i32) -> isize {
+    write(1, (s as u8 + b'0') as *const u8, 1);
+
+    0
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn abs(n: i64) -> i64 {
     n.abs()
 }
 
 #[unsafe(no_mangle)]
-extern "C" fn atoi(mut c: *const u8) -> i32 {
-    let mut value: i32 = 0;
-    let mut sign: i32 = 1;
+unsafe extern "C" fn printf(format: *const u8, args: ...) {
+    unsafe { syscall3(SYS_WRITE, 1, format as usize, strlen(format)) };
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn atoi(mut c: *const u8) -> i64 {
+    let mut value: i64 = 0;
+    let mut sign: i64 = 1;
     unsafe {
         if (*c) == b'+' || (*c) == b'-' {
             if *c == b'-' {
@@ -53,7 +69,7 @@ extern "C" fn atoi(mut c: *const u8) -> i32 {
         }
         while (*c).is_ascii_digit() {
             value *= 10;
-            value += ((*c) - b'0') as i32;
+            value += ((*c) - b'0') as i64;
             c = c.add(1);
         }
     }
@@ -61,6 +77,115 @@ extern "C" fn atoi(mut c: *const u8) -> i32 {
     value * sign
 }
 
+#[unsafe(no_mangle)]
+extern "C" fn atof(mut c: *const u8) -> f64 {
+    0.0
+}
+
+pub fn compare_str(str_1: *const u8, str_2: *const u8, case: bool, n: usize) -> i32 {
+    let mut len = 0;
+
+    while len < n {
+        let mut c_1 = unsafe { *str_1.add(len) };
+        let mut c_2 = unsafe { *str_2.add(len) };
+
+        if case {
+            c_1 = c_1.to_ascii_lowercase();
+            c_2 = c_2.to_ascii_lowercase();
+        }
+
+        if c_1 != c_2 {
+            return (c_1 - c_2) as i32;
+        }
+
+        if c_1 == 0 {
+            return 0;
+        }
+
+        len += 1;
+    }
+
+    0
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn strcasecmp(str_1: *const u8, str_2: *const u8) -> i32 {
+    compare_str(str_1, str_2, true, 999999999999999)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn strcmp(str_1: *const u8, str_2: *const u8) -> i32 {
+    compare_str(str_1, str_2, false, 999999999999999)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn strncasecmp(str_1: *const u8, str_2: *const u8, n: i32) -> i32 {
+    compare_str(str_1, str_2, true, n as usize)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn strncmp(str_1: *const u8, str_2: *const u8, n: i32) -> i32 {
+    compare_str(str_1, str_2, false, n as usize)
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn strncopy(s: *const u8, n: i32) -> *const u8 {
+    null()
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn strdup(s: *const u8) -> *const u8 {
+    null()
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn strstr(s: *const u8) -> *const u8 {
+    null()
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn strchr(s: *const u8, ch: u8) -> *const u8 {
+    null()
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn strrchr(s: *const u8, ch: u8) -> *const u8 {
+    let mut n = 0;
+    let mut last: *const u8 = null();
+
+    if ch == 0 {
+        while unsafe { *s.add(n) } != 0 {
+            n += 1;
+        }
+        unsafe { s.add(n + 1) }
+    } else {
+        while unsafe { *s.add(n) } != 0 {
+            let cur_ch = unsafe { s.add(n) };
+            if unsafe { *cur_ch == ch } {
+                last = cur_ch;
+            }
+            n += 1;
+        }
+
+        last
+    }
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn toupper(char: u8) -> u8 {
+    char.to_ascii_uppercase()
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn tolower(char: u8) -> u8 {
+    char.to_ascii_lowercase()
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn system(cmd: *const u8) -> i32 {
+    0
+}
+
 #[panic_handler]
 fn panic(_: &core::panic::PanicInfo) -> ! {
     loop {}

user/libxunil/src/mem.rs

@@ -0,0 +1,27 @@
+use core::ptr::null_mut;
+
+#[unsafe(no_mangle)]
+extern "C" fn calloc(nitems: u64, size: u64) -> *mut u8 {
+    null_mut()
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn free(ptr: *mut u8) {}
+
+#[unsafe(no_mangle)]
+extern "C" fn malloc(size: u64) -> *mut u8 {
+    null_mut()
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn memcpy(dest_str: *mut u8, src_str: *const u8, n: u64) {}
+
+#[unsafe(no_mangle)]
+extern "C" fn memset(str: *mut u8, c: i64, n: u64) -> *mut u8 {
+    null_mut()
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn realloc(ptr: *mut u8, size: u64) -> *mut u8 {
+    null_mut()
+}

user/libxunil/to_implement.txt

@@ -1,17 +1,36 @@
 abs
+atof
 atoi
 calloc
 __ctype_toupper_loc
+__errno_location
+exit
+fclose
+fflush
+fopen
 fprintf
+fread
 free
+fseek
+ftell
+fwrite
+__isoc23_sscanf
 malloc
 memcpy
 memset
+mkdir
 printf
+putchar
+puts
 realloc
+remove
+rename
+snprintf
 __stack_chk_fail
 stderr
+stdout
 strcasecmp
+strchr
 strcmp
 strdup
 strlen
@@ -19,4 +38,8 @@ strncasecmp
 strncmp
 strncpy
 strrchr
+strstr
+system
 toupper
+vfprintf // this
+vsnprintf // also this