initial stuff

Author: bindsdev

.cargo/config.toml

@@ -0,0 +1,6 @@
+[build]
+target = "x86_64-unknown-none"
+
+# [unstable]
+# build-std = ["core", "compiler_builtins"]
+# build-std-features = ["compiler-builtins-mem"]

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "daily"

.gitignore

@@ -0,0 +1,2 @@
+/target
+/build

Cargo.lock

@@ -0,0 +1,17 @@
+[package]
+name = "monoOS"
+version = "0.1.0"
+edition = "2021"
+description = "A hobbyist monolithic operating system, targeting x86-64."
+readme = "README.md"
+license = "MIT"
+authors = ["binds <[email protected]>"]
+
+[dependencies]
+limine = "0.1.11"
+spin = { version = "0.9.8", default-features = false, features = ["spin_mutex", "once"] }
+x86 = "0.52.0"
+
+[[bin]]
+name = "monoos"
+path = "src/main.rs"

Cargo.toml

@@ -0,0 +1,77 @@
+# Configuration options
+FEATURES ?=
+PROFILE  ?= release
+
+# Command arguments
+override CARGO_ARGS = --bin monoos --no-default-features
+override QEMU_ARGS  = -no-reboot -no-shutdown -M smm=off -machine q35 -drive file=$(ISO),format=raw -bios $(BUILD_ROOT)/OVMF.fd
+
+# Checks
+ifneq ($(PROFILE),$(filter $(PROFILE),debug release))
+$(error Error: unsupported cargo profile "$(PROFILE)". supported options are "debug" and "release")
+endif
+
+ifneq ($(FEATURES),)
+	override CARGO_ARGS += --features $(FEATURES)
+endif
+
+ifeq ($(PROFILE), release)
+	override CARGO_ARGS += --release
+endif
+
+ifeq ($(PROFILE),debug)
+	override QEMU_ARGS += -s -S
+endif
+
+ifneq ($(findstring la57,$(FEATURES)),)
+	override QEMU_ARGS += -cpu qemu64,+la57
+endif
+
+# Environment variables
+export MHOS_VERSION = v0.1.0
+
+# Overrides
+override BUILD_DIR  := build
+override BUILD_ROOT := $(BUILD_DIR)/root
+override ISO        := $(BUILD_ROOT)/monoos.iso
+override LIMINE_DIR := $(BUILD_DIR)/limine
+override ESP        := $(BUILD_ROOT)/EFI/BOOT
+override KERNEL_BIN := $(BUILD_ROOT)/monoos.elf
+
+# Targets
+.PHONY: all iso run miri clean
+all: iso
+
+gen_build_dirs:
+	@# recursively create from the deepest directory
+	@mkdir -p $(ESP) 
+
+limine: gen_build_dirs
+	@git clone --depth 1 --branch v5.x-branch-binary https://github.com/limine-bootloader/limine.git $(LIMINE_DIR)
+	@$(MAKE) -C $(LIMINE_DIR)
+
+ovmf:
+	@wget https://efi.akeo.ie/OVMF/OVMF-X64.zip -P $(BUILD_ROOT)
+	@unzip $(BUILD_ROOT)/OVMF-X64.zip -d $(BUILD_ROOT) -x *.txt
+	
+kernel_build:
+	@cargo build $(CARGO_ARGS)
+
+$(ISO): limine ovmf kernel_build
+	@cp target/x86_64-unknown-none/$(PROFILE)/monoos $(KERNEL_BIN)
+	@cp limine.cfg $(LIMINE_DIR)/limine-uefi-cd.bin $(BUILD_ROOT)
+	@cp $(LIMINE_DIR)/BOOTX64.EFI $(ESP)
+	@xorriso -as mkisofs --efi-boot limine-uefi-cd.bin -efi-boot-part --efi-boot-image --protective-msdos-label $(BUILD_ROOT) -o $(ISO)
+
+# Convenience target for $(ISO)
+iso: $(ISO)
+
+run: iso
+	@qemu-system-x86_64 $(QEMU_ARGS)	
+
+miri:
+	@MIRI_NO_STD=1 cargo miri run --target x86_64-unknown-none
+
+clean:
+	@cargo clean
+	@rm -rf build

Makefile

@@ -0,0 +1,5 @@
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed=linker.ld");
+    println!("cargo:rustc-link-arg=-Tlinker.ld");
+}

build.rs

@@ -0,0 +1,7 @@
+TIMEOUT=0
+VERBOSE=yes
+
+: monoOS
+PROTOCOL=limine
+KASLR=yes
+KERNEL_PATH=boot:///monoos.elf

limine.cfg

@@ -0,0 +1,83 @@
+/* output an x86-64 ELF file */
+OUTPUT_FORMAT(elf64-x86-64)
+
+/* make kmain symbol the entry point */
+ENTRY(kmain)
+
+/* define program headers to get desired MMU permissions */
+PHDRS
+{
+    text    PT_LOAD    FLAGS((1 << 0) | (1 << 2)) ; /* Execute + Read */
+    rodata  PT_LOAD    FLAGS((1 << 2)) ;            /* Read only */
+    data    PT_LOAD    FLAGS((1 << 1) | (1 << 2)) ; /* Write + Read */
+    dynamic PT_DYNAMIC FLAGS((1 << 1) | (1 << 2)) ; /* Write + Read */
+}
+
+SECTIONS
+{
+    /* We wanna be placed in the topmost 2GiB of the address space, for optimisations */
+    /* and because that is what the Limine spec mandates. */
+    /* Any address in this region will do, but often 0xffffffff80000000 is chosen as */
+    /* that is the beginning of the region. */
+    . = 0xffffffff80000000;
+
+    .text : {
+        *(.text .text.*)
+    } :text
+
+    /* Move to the next memory page for .rodata */
+    . += CONSTANT(MAXPAGESIZE);
+
+    /* The built-in `x86_64-unknown-none` target generates relocatable executables */
+    /* by default, so we need to include the relocation information (.dynstr, .dynsym, */
+    /* and .rela) for the bootloader too properly load the kernel at runtime. */
+    .dynsym : {
+        *(.dynsym)
+    } :rodata
+
+    .dynstr : {
+        *(.dynstr)
+    } :rodata
+
+    .rela : {
+        *(.rela*)
+    } :rodata
+
+    .rodata : {
+        *(.rodata .rodata.*)
+    } :rodata
+
+    /* Move to the next memory page for .data */
+    . += CONSTANT(MAXPAGESIZE);
+
+    /* The dynamic table is used to find the relocation info (declared above), so it */
+    /* must be included both in the :data and :dynamic segments. */
+    .dynamic : {
+        *(.dynamic)
+    } :data :dynamic
+
+    .got : {
+        *(.got)
+    } :data
+
+    .data : {
+        *(.data.rel.ro .data.rel.ro.*)
+        *(.data .data.*)
+    } :data
+
+    /* NOTE: .bss needs to be the last thing mapped to :data, otherwise lots of */
+    /* unnecessary zeros will be written to the binary. */
+    /* If you need, for example, .init_array and .fini_array, those should be placed */
+    /* above this. */
+    .bss : {
+        *(COMMON)
+        *(.dynbss)
+        *(.bss .bss.*)
+    } :data
+
+    /* Discard .note.* and .eh_frame since they may cause issues on some hosts. */
+    /DISCARD/ : {
+        *(.eh_frame)
+        *(.note .note.*)
+    }
+}

linker.ld

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "nightly"

rust-toolchain.toml

@@ -0,0 +1,4 @@
+//! Necessary CPU state setup for x86-64
+
+pub mod gdt;
+pub mod idt;

src/cpu.rs

@@ -0,0 +1,41 @@
+use limine::Framebuffer;
+use spin::{Mutex, Once};
+
+#[derive(Debug)]
+struct FramebufferInfo {
+    byte_len: usize,
+    pitch: u64,
+}
+
+impl FramebufferInfo {
+    fn new(byte_len: usize, pitch: u64) -> Self {
+        Self { byte_len, pitch }
+    }
+}
+
+#[derive(Debug)]
+struct Writer<'a> {
+    fb_slice: &'a mut [u8],
+    fb_info: FramebufferInfo,
+}
+
+impl<'a> Writer<'a> {
+    fn new(fb_slice: &'a mut [u8], fb_info: FramebufferInfo) -> Self {
+        Self { fb_slice, fb_info }
+    }
+}
+
+static WRITER: Once<Mutex<Writer>> = Once::new();
+
+pub fn init(fb: &Framebuffer) {
+    let fb_info = FramebufferInfo::new(fb.size(), fb.pitch);
+
+    // SAFETY: `as_ptr` will never return `None`
+    let fb_addr = unsafe { fb.address.as_ptr().unwrap_unchecked() };
+    // SAFETY: `fb_addr` is non-null and aligned
+    let fb_slice = unsafe { core::slice::from_raw_parts_mut(fb_addr, fb_info.byte_len) };
+
+    let writer = Writer::new(fb_slice, fb_info);
+
+    WRITER.call_once(|| Mutex::new(writer));
+}

src/cpu/gdt.rs

@@ -0,0 +1,30 @@
+#![no_std]
+#![no_main]
+#![allow(dead_code)]
+
+mod cpu;
+mod graphics;
+
+use core::panic::PanicInfo;
+use limine::FramebufferRequest;
+
+#[cfg(not(target_pointer_width = "64"))]
+compile_error!("monoOS is only designed for 64-bit architectures");
+
+#[cfg(not(target_arch = "x86_64"))]
+compile_error!("monoOS only supports the x86_64 architecture");
+
+static FRAMEBUFFER: FramebufferRequest = FramebufferRequest::new(0);
+
+fn kmain() -> ! {
+    // Obtain the framebuffer and setup graphics.
+    let framebuffer = &*FRAMEBUFFER.get_response().get().unwrap().framebuffers()[0];
+    graphics::init(framebuffer);
+
+    loop {}
+}
+
+#[panic_handler]
+fn panic(_: &PanicInfo) -> ! {
+    loop {}
+}