Added bootloader

bootloader/src/os/bios/disk.rs

@@ -0,0 +1,175 @@
+use core::{mem, ptr};
+use redoxfs::{Disk, BLOCK_SIZE};
+use syscall::error::{Error, Result, EIO};
+
+use super::{ThunkData, DISK_ADDRESS_PACKET_ADDR, DISK_BIOS_ADDR};
+
+const SECTOR_SIZE: u64 = 512;
+const BLOCKS_PER_SECTOR: u64 = BLOCK_SIZE / SECTOR_SIZE;
+// 128 sectors is the amount allocated for DISK_BIOS_ADDR
+// 127 sectors is the maximum for many BIOSes
+const MAX_SECTORS: u64 = 127;
+const MAX_BLOCKS: u64 = MAX_SECTORS * SECTOR_SIZE / BLOCK_SIZE;
+
+#[allow(dead_code)]
+#[derive(Clone, Copy)]
+#[repr(C, packed)]
+pub struct DiskAddressPacket {
+    size: u8,
+    reserved: u8,
+    sectors: u16,
+    buffer: u16,
+    segment: u16,
+    address: u64,
+}
+
+impl DiskAddressPacket {
+    pub fn from_block(block: u64, count: u64) -> DiskAddressPacket {
+        let address = block * BLOCKS_PER_SECTOR;
+        let sectors = count * BLOCKS_PER_SECTOR;
+        assert!(sectors <= MAX_SECTORS);
+        DiskAddressPacket {
+            size: mem::size_of::<DiskAddressPacket>() as u8,
+            reserved: 0,
+            sectors: sectors as u16,
+            buffer: (DISK_BIOS_ADDR & 0xF) as u16,
+            segment: (DISK_BIOS_ADDR >> 4) as u16,
+            address,
+        }
+    }
+}
+
+pub struct DiskBios {
+    boot_disk: u8,
+    thunk13: extern "C" fn(),
+    chs_opt: Option<(u32, u32, u32)>,
+}
+
+impl DiskBios {
+    pub fn new(boot_disk: u8, thunk13: extern "C" fn()) -> Self {
+        let chs_opt = unsafe {
+            let mut data = ThunkData::new();
+            data.eax = 0x4100;
+            data.ebx = 0x55AA;
+            data.edx = boot_disk as u32;
+
+            data.with(thunk13);
+
+            if (data.ebx & 0xFFFF) == 0xAA55 {
+                // Extensions are installed, do not use CHS
+                None
+            } else {
+                // Extensions are not installed, get CHS geometry
+                data = ThunkData::new();
+                data.eax = 0x0800;
+                data.edx = boot_disk as u32;
+                data.edi = 0;
+
+                data.with(thunk13);
+
+                //TODO: return result on error
+                let ah = ({ data.eax } >> 8) & 0xFF;
+                assert_eq!(ah, 0);
+
+                let c = (data.ecx >> 8) & 0xFF | ((data.ecx >> 6) & 0x3) << 8;
+                let h = ((data.edx >> 8) & 0xFF) + 1;
+                let s = data.ecx & 0x3F;
+
+                Some((c, h, s))
+            }
+        };
+
+        Self {
+            boot_disk,
+            thunk13,
+            chs_opt,
+        }
+    }
+}
+
+impl Disk for DiskBios {
+    unsafe fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize> {
+        // Optimization for live disks
+        if let Some(live) = crate::LIVE_OPT {
+            if block >= live.0 {
+                let start = ((block - live.0) * BLOCK_SIZE) as usize;
+                let end = start + buffer.len();
+                if end <= live.1.len() {
+                    buffer.copy_from_slice(&live.1[start..end]);
+                    return Ok(buffer.len());
+                }
+            }
+        }
+
+        for (i, chunk) in buffer
+            .chunks_mut((MAX_BLOCKS * BLOCK_SIZE) as usize)
+            .enumerate()
+        {
+            let dap = DiskAddressPacket::from_block(
+                block + i as u64 * MAX_BLOCKS,
+                chunk.len() as u64 / BLOCK_SIZE,
+            );
+
+            if let Some((_, h_max, s_max)) = self.chs_opt {
+                let s = (dap.address % s_max as u64) + 1;
+                assert!(s <= 63, "invalid sector {}", s);
+
+                let tmp = dap.address / s_max as u64;
+                let h = tmp % h_max as u64;
+                assert!(h <= 255, "invalid head {}", h);
+
+                let c = tmp / h_max as u64;
+                assert!(c <= 1023, "invalid cylinder {}", c);
+
+                let mut data = ThunkData::new();
+                data.eax = 0x0200 | (dap.sectors as u32);
+                data.ebx = dap.buffer as u32;
+                data.ecx =
+                    (s as u32) | (((c as u32) & 0xFF) << 8) | ((((c as u32) >> 8) & 0x3) << 6);
+                data.edx = (self.boot_disk as u32) | ((h as u32) << 8);
+                data.es = dap.segment;
+
+                data.with(self.thunk13);
+
+                //TODO: return result on error
+                let ah = ({ data.eax } >> 8) & 0xFF;
+                assert_eq!(ah, 0);
+            } else {
+                ptr::write(DISK_ADDRESS_PACKET_ADDR as *mut DiskAddressPacket, dap);
+
+                let mut data = ThunkData::new();
+                data.eax = 0x4200;
+                data.edx = self.boot_disk as u32;
+                data.esi = DISK_ADDRESS_PACKET_ADDR as u32;
+
+                data.with(self.thunk13);
+
+                //TODO: return result on error
+                let ah = ({ data.eax } >> 8) & 0xFF;
+                assert_eq!(ah, 0);
+
+                //TODO: check blocks transferred
+                // dap = ptr::read(DISK_ADDRESS_PACKET_ADDR as *mut DiskAddressPacket);
+            }
+
+            ptr::copy(DISK_BIOS_ADDR as *const u8, chunk.as_mut_ptr(), chunk.len());
+        }
+
+        Ok(buffer.len())
+    }
+
+    unsafe fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize> {
+        log::error!(
+            "DiskBios::write_at(0x{:X}, 0x{:X}:0x{:X}) not allowed",
+            block,
+            buffer.as_ptr() as usize,
+            buffer.len()
+        );
+        Err(Error::new(EIO))
+    }
+
+    fn size(&mut self) -> Result<u64> {
+        log::error!("DiskBios::size not implemented");
+        Err(Error::new(EIO))
+    }
+}

bootloader/src/os/bios/macros.rs

@@ -0,0 +1,20 @@
+/// Print to console
+#[macro_export]
+macro_rules! print {
+    ($($arg:tt)*) => ({
+        use core::fmt::Write;
+        #[cfg(feature = "serial_debug")]
+        {
+            let _ = write!($crate::os::serial::COM1.lock(), $($arg)*);
+        }
+        let _ = write!($crate::os::VGA.lock(), $($arg)*);
+    });
+}
+
+/// Print with new line to console
+#[macro_export]
+macro_rules! println {
+    () => (print!("\n"));
+    ($fmt:expr) => (print!(concat!($fmt, "\n")));
+    ($fmt:expr, $($arg:tt)*) => (print!(concat!($fmt, "\n"), $($arg)*));
+}

bootloader/src/os/bios/memory_map.rs

@@ -0,0 +1,84 @@
+use core::{cmp, mem, ptr};
+
+use crate::area_add;
+use crate::os::{OsMemoryEntry, OsMemoryKind};
+
+use super::{thunk::ThunkData, MEMORY_MAP_ADDR};
+
+#[repr(C, packed)]
+struct MemoryMapEntry {
+    pub base: u64,
+    pub size: u64,
+    pub kind: u32,
+}
+
+pub struct MemoryMapIter {
+    thunk15: extern "C" fn(),
+    data: ThunkData,
+    first: bool,
+}
+
+impl MemoryMapIter {
+    pub fn new(thunk15: extern "C" fn()) -> Self {
+        Self {
+            thunk15,
+            data: ThunkData::new(),
+            first: true,
+        }
+    }
+}
+
+impl Iterator for MemoryMapIter {
+    type Item = OsMemoryEntry;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.first {
+            self.first = false;
+        } else if self.data.ebx == 0 {
+            return None;
+        }
+
+        self.data.eax = 0xE820;
+        self.data.ecx = mem::size_of::<MemoryMapEntry>() as u32;
+        self.data.edx = 0x534D4150;
+        self.data.edi = MEMORY_MAP_ADDR as u32;
+
+        unsafe {
+            self.data.with(self.thunk15);
+        }
+
+        //TODO: return error?
+        assert_eq!({ self.data.eax }, 0x534D4150);
+        assert_eq!({ self.data.ecx }, mem::size_of::<MemoryMapEntry>() as u32);
+
+        let entry = unsafe { ptr::read(MEMORY_MAP_ADDR as *const MemoryMapEntry) };
+        Some(Self::Item {
+            base: entry.base,
+            size: entry.size,
+            kind: match entry.kind {
+                0 => OsMemoryKind::Null,
+                1 => OsMemoryKind::Free,
+                3 => OsMemoryKind::Reclaim,
+                _ => OsMemoryKind::Reserved,
+            },
+        })
+    }
+}
+
+pub unsafe fn memory_map(thunk15: extern "C" fn()) -> Option<(usize, usize)> {
+    let mut heap_limits = None;
+    for entry in MemoryMapIter::new(thunk15) {
+        let heap_start = 1 * 1024 * 1024;
+        if { entry.kind } == OsMemoryKind::Free
+            && entry.base <= heap_start as u64
+            && (entry.base + entry.size) >= heap_start as u64
+        {
+            let heap_end = cmp::min(entry.base + entry.size, usize::MAX as u64) as usize;
+            if heap_end >= heap_start {
+                heap_limits = Some((heap_start, heap_end - heap_start));
+            }
+        }
+
+        area_add(entry);
+    }
+    heap_limits
+}

bootloader/src/os/bios/mod.rs

@@ -0,0 +1,310 @@
+use alloc::alloc::{alloc_zeroed, Layout};
+use core::{convert::TryFrom, mem, ptr, slice};
+use linked_list_allocator::LockedHeap;
+use spin::Mutex;
+
+use crate::logger::LOGGER;
+use crate::os::{Os, OsHwDesc, OsKey, OsVideoMode};
+use crate::KernelArgs;
+
+use self::disk::DiskBios;
+use self::memory_map::memory_map;
+use self::thunk::ThunkData;
+use self::vbe::VideoModeIter;
+use self::vga::{Vga, VgaTextColor};
+
+#[macro_use]
+mod macros;
+
+mod disk;
+mod memory_map;
+mod panic;
+pub(crate) mod serial;
+mod thunk;
+mod vbe;
+mod vga;
+
+// Real mode memory allocation, for use with thunk
+// 0x500 to 0x7BFF is free
+const DISK_BIOS_ADDR: usize = 0x70000; // 64 KiB at 448 KiB, ends at 512 KiB
+const VBE_CARD_INFO_ADDR: usize = 0x1000; // 512 bytes, ends at 0x11FF
+const VBE_MODE_INFO_ADDR: usize = 0x1200; // 256 bytes, ends at 0x12FF
+const VBE_EDID_ADDR: usize = 0x1300; // 128 bytes, ends at 0x137F
+const MEMORY_MAP_ADDR: usize = 0x1380; // 24 bytes, ends at 0x1397
+const DISK_ADDRESS_PACKET_ADDR: usize = 0x1398; // 16 bytes, ends at 0x13A7
+const THUNK_STACK_ADDR: usize = 0x7C00; // Grows downwards
+const VGA_ADDR: usize = 0xB8000;
+
+#[global_allocator]
+static ALLOCATOR: LockedHeap = LockedHeap::empty();
+
+pub(crate) static VGA: Mutex<Vga> = Mutex::new(unsafe { Vga::new(VGA_ADDR, 80, 25) });
+
+pub struct OsBios {
+    boot_disk: usize,
+    thunk10: extern "C" fn(),
+    thunk13: extern "C" fn(),
+    thunk15: extern "C" fn(),
+    thunk16: extern "C" fn(),
+}
+
+#[allow(dead_code)]
+#[derive(Copy, Clone, Debug)]
+#[repr(C, packed)]
+pub struct Rsdp {
+    signature: [u8; 8],
+    checksum: u8,
+    oemid: [u8; 6],
+    revision: u8,
+    rsdt_address: u32,
+}
+
+#[allow(dead_code)]
+#[derive(Copy, Clone, Debug)]
+#[repr(C, packed)]
+pub struct Xsdp {
+    rsdp: Rsdp,
+
+    length: u32,
+    xsdt_address: u64,
+    extended_checksum: u8,
+    reserved: [u8; 3],
+}
+
+unsafe fn search_rsdp(start: usize, end: usize) -> Option<(u64, u64)> {
+    // Align start up to 16 bytes
+    let mut addr = ((start + 15) / 16) * 16;
+    // Search until reading the end of the Rsdp would be past the end of the memory area
+    while addr + mem::size_of::<Rsdp>() <= end {
+        let rsdp = ptr::read(addr as *const Rsdp);
+        if &rsdp.signature == b"RSD PTR " {
+            //TODO: check checksum?
+            if rsdp.revision == 0 {
+                return Some((addr as u64, mem::size_of::<Rsdp>() as u64));
+            } else if rsdp.revision == 2 {
+                let xsdp = ptr::read(addr as *const Xsdp);
+                //TODO: check extended checksum?
+                return Some((addr as u64, xsdp.length as u64));
+            }
+        }
+
+        // Rsdp is always aligned to 16 bytes
+        addr += 16;
+    }
+    None
+}
+
+impl Os<DiskBios, VideoModeIter> for OsBios {
+    fn name(&self) -> &str {
+        "x86/BIOS"
+    }
+
+    fn alloc_zeroed_page_aligned(&self, size: usize) -> *mut u8 {
+        assert!(size != 0);
+
+        let page_size = self.page_size();
+        let pages = (size + page_size - 1) / page_size;
+
+        let ptr =
+            unsafe { alloc_zeroed(Layout::from_size_align(pages * page_size, page_size).unwrap()) };
+
+        assert!(!ptr.is_null());
+        ptr
+    }
+
+    fn page_size(&self) -> usize {
+        4096
+    }
+
+    fn filesystem(
+        &self,
+        password_opt: Option<&[u8]>,
+    ) -> syscall::Result<redoxfs::FileSystem<DiskBios>> {
+        let disk = DiskBios::new(u8::try_from(self.boot_disk).unwrap(), self.thunk13);
+
+        //TODO: get block from partition table
+        let block = 2 * crate::MIBI as u64 / redoxfs::BLOCK_SIZE;
+        redoxfs::FileSystem::open(disk, password_opt, Some(block), false)
+    }
+
+    fn hwdesc(&self) -> OsHwDesc {
+        // See ACPI specification - Finding the RSDP on IA-PC Systems
+        unsafe {
+            let ebda_segment = ptr::read(0x40E as *const u16);
+            let ebda_addr = (ebda_segment as usize) << 4;
+            if let Some((addr, size)) =
+                search_rsdp(ebda_addr, ebda_addr + 1024).or(search_rsdp(0xE0000, 0xFFFFF))
+            {
+                // Copy to a page
+                let page_aligned = self.alloc_zeroed_page_aligned(size as usize);
+                ptr::copy(addr as *const u8, page_aligned, size as usize);
+                return OsHwDesc::Acpi(page_aligned as u64, size);
+            }
+        }
+        OsHwDesc::NotFound
+    }
+
+    fn video_outputs(&self) -> usize {
+        //TODO: return 1 only if vbe supported?
+        1
+    }
+
+    fn video_modes(&self, _output_i: usize) -> VideoModeIter {
+        VideoModeIter::new(self.thunk10)
+    }
+
+    fn set_video_mode(&self, _output_i: usize, mode: &mut OsVideoMode) {
+        // Set video mode
+        let mut data = ThunkData::new();
+        data.eax = 0x4F02;
+        data.ebx = mode.id;
+        unsafe {
+            data.with(self.thunk10);
+        }
+        //TODO: check result
+    }
+
+    fn best_resolution(&self, _output_i: usize) -> Option<(u32, u32)> {
+        let mut data = ThunkData::new();
+        data.eax = 0x4F15;
+        data.ebx = 0x01;
+        data.ecx = 0;
+        data.edx = 0;
+        data.edi = VBE_EDID_ADDR as u32;
+        unsafe {
+            data.with(self.thunk10);
+        }
+
+        if data.eax == 0x4F {
+            let edid = unsafe { slice::from_raw_parts(VBE_EDID_ADDR as *const u8, 128) };
+
+            Some((
+                (edid[0x38] as u32) | (((edid[0x3A] as u32) & 0xF0) << 4),
+                (edid[0x3B] as u32) | (((edid[0x3D] as u32) & 0xF0) << 4),
+            ))
+        } else {
+            log::warn!("Failed to get VBE EDID: 0x{:X}", { data.eax });
+            None
+        }
+    }
+
+    fn get_key(&self) -> OsKey {
+        // Read keypress
+        let mut data = ThunkData::new();
+        unsafe {
+            data.with(self.thunk16);
+        }
+        match (data.eax >> 8) as u8 {
+            0x4B => OsKey::Left,
+            0x4D => OsKey::Right,
+            0x48 => OsKey::Up,
+            0x50 => OsKey::Down,
+            0x0E => OsKey::Backspace,
+            0x53 => OsKey::Delete,
+            0x1C => OsKey::Enter,
+            _ => match data.eax as u8 {
+                0 => OsKey::Other,
+                b => OsKey::Char(b as char),
+            },
+        }
+    }
+
+    fn clear_text(&self) {
+        //TODO: clear screen for VGA
+    }
+
+    fn get_text_position(&self) -> (usize, usize) {
+        let vga = VGA.lock();
+        (vga.x, vga.y)
+    }
+
+    fn set_text_position(&self, x: usize, y: usize) {
+        //TODO: ensure this is inside bounds!
+        let mut vga = VGA.lock();
+        vga.x = x;
+        vga.y = y;
+    }
+
+    fn set_text_highlight(&self, highlight: bool) {
+        let mut vga = VGA.lock();
+        if highlight {
+            vga.bg = VgaTextColor::Gray;
+            vga.fg = VgaTextColor::Black;
+        } else {
+            vga.bg = VgaTextColor::Black;
+            vga.fg = VgaTextColor::Gray;
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn start(
+    kernel_entry: extern "C" fn(
+        page_table: usize,
+        stack: u64,
+        func: u64,
+        args: *const KernelArgs,
+        long_mode: usize,
+    ) -> !,
+    boot_disk: usize,
+    thunk10: extern "C" fn(),
+    thunk13: extern "C" fn(),
+    thunk15: extern "C" fn(),
+    thunk16: extern "C" fn(),
+) -> ! {
+    #[cfg(feature = "serial_debug")]
+    {
+        let mut com1 = serial::COM1.lock();
+        com1.init();
+        com1.write(b"SERIAL\n");
+    }
+
+    {
+        // Make sure we are in mode 3 (80x25 text mode)
+        let mut data = ThunkData::new();
+        data.eax = 0x03;
+        data.with(thunk10);
+    }
+
+    {
+        // Disable cursor
+        let mut data = ThunkData::new();
+        data.eax = 0x0100;
+        data.ecx = 0x3F00;
+        data.with(thunk10);
+    }
+
+    // Clear screen
+    VGA.lock().clear();
+
+    // Set logger
+    LOGGER.init();
+
+    let mut os = OsBios {
+        boot_disk,
+        thunk10,
+        thunk13,
+        thunk15,
+        thunk16,
+    };
+
+    let (heap_start, heap_size) = memory_map(os.thunk15).expect("No memory for heap");
+
+    ALLOCATOR.lock().init(heap_start as *mut u8, heap_size);
+
+    let (page_phys, func, args) = crate::main(&mut os);
+
+    kernel_entry(
+        page_phys,
+        args.stack_base
+            + args.stack_size
+            + if crate::KERNEL_64BIT {
+                crate::arch::x64::PHYS_OFFSET as u64
+            } else {
+                crate::arch::x32::PHYS_OFFSET as u64
+            },
+        func,
+        &args,
+        if crate::KERNEL_64BIT { 1 } else { 0 },
+    );
+}

bootloader/src/os/bios/panic.rs

@@ -0,0 +1,39 @@
+//! Intrinsics for panic handling
+
+use core::alloc::Layout;
+use core::arch::asm;
+use core::panic::PanicInfo;
+
+#[lang = "eh_personality"]
+#[no_mangle]
+pub extern "C" fn rust_eh_personality() {}
+
+/// Required to handle panics
+#[panic_handler]
+#[no_mangle]
+pub fn rust_begin_unwind(info: &PanicInfo<'_>) -> ! {
+	unsafe {
+		println!("BOOTLOADER PANIC:\n{}", info);
+		loop {
+			asm!("hlt");
+		}
+	}
+}
+
+#[alloc_error_handler]
+#[no_mangle]
+#[allow(improper_ctypes_definitions)] // Layout is not repr(C)
+pub extern "C" fn rust_oom(_layout: Layout) -> ! {
+	panic!("memory allocation failed");
+}
+
+#[allow(non_snake_case)]
+#[no_mangle]
+/// Required to handle panics
+pub extern "C" fn _Unwind_Resume() -> ! {
+	loop {
+		unsafe {
+			asm!("hlt");
+		}
+	}
+}

bootloader/src/os/bios/serial.rs

@@ -0,0 +1,9 @@
+use spin::Mutex;
+use syscall::Pio;
+
+use crate::serial_16550::SerialPort;
+
+pub static COM1: Mutex<SerialPort<Pio<u8>>> = Mutex::new(SerialPort::<Pio<u8>>::new(0x3F8));
+pub static COM2: Mutex<SerialPort<Pio<u8>>> = Mutex::new(SerialPort::<Pio<u8>>::new(0x2F8));
+pub static COM3: Mutex<SerialPort<Pio<u8>>> = Mutex::new(SerialPort::<Pio<u8>>::new(0x3E8));
+pub static COM4: Mutex<SerialPort<Pio<u8>>> = Mutex::new(SerialPort::<Pio<u8>>::new(0x2E8));

bootloader/src/os/bios/thunk.rs

@@ -0,0 +1,46 @@
+use core::ptr;
+
+use super::THUNK_STACK_ADDR;
+
+#[allow(dead_code)]
+#[derive(Clone, Copy, Debug)]
+#[repr(C, packed)]
+pub struct ThunkData {
+    pub es: u16,
+    pub edi: u32,
+    pub esi: u32,
+    pub ebp: u32,
+    pub ebx: u32,
+    pub edx: u32,
+    pub ecx: u32,
+    pub eax: u32,
+}
+
+impl ThunkData {
+    pub fn new() -> Self {
+        Self {
+            es: 0,
+            edi: 0,
+            esi: 0,
+            ebp: 0,
+            ebx: 0,
+            edx: 0,
+            ecx: 0,
+            eax: 0,
+        }
+    }
+
+    pub unsafe fn save(&self) {
+        ptr::write((THUNK_STACK_ADDR - 64) as *mut ThunkData, *self);
+    }
+
+    pub unsafe fn load(&mut self) {
+        *self = ptr::read((THUNK_STACK_ADDR - 64) as *const ThunkData);
+    }
+
+    pub unsafe fn with(&mut self, f: extern "C" fn()) {
+        self.save();
+        f();
+        self.load();
+    }
+}

bootloader/src/os/bios/vbe.rs

@@ -0,0 +1,151 @@
+use core::ptr;
+use log::error;
+
+use crate::os::OsVideoMode;
+
+use super::{ThunkData, VBE_CARD_INFO_ADDR, VBE_MODE_INFO_ADDR};
+
+#[derive(Clone, Copy, Debug)]
+#[repr(C, packed)]
+pub struct VbeFarPtr {
+    pub offset: u16,
+    pub segment: u16,
+}
+
+impl VbeFarPtr {
+    pub unsafe fn as_ptr<T>(&self) -> *const T {
+        (((self.segment as usize) << 4) + (self.offset as usize)) as *const T
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+#[repr(C, packed)]
+pub struct VbeCardInfo {
+    pub signature: [u8; 4],
+    pub version: u16,
+    pub oemstring: VbeFarPtr,
+    pub capabilities: [u8; 4],
+    pub videomodeptr: VbeFarPtr,
+    pub totalmemory: u16,
+    pub oemsoftwarerev: u16,
+    pub oemvendornameptr: VbeFarPtr,
+    pub oemproductnameptr: VbeFarPtr,
+    pub oemproductrevptr: VbeFarPtr,
+    pub reserved: [u8; 222],
+    pub oemdata: [u8; 256],
+}
+
+#[derive(Clone, Copy, Debug)]
+#[repr(C, packed)]
+pub struct VbeModeInfo {
+    pub attributes: u16,
+    pub win_a: u8,
+    pub win_b: u8,
+    pub granularity: u16,
+    pub winsize: u16,
+    pub segment_a: u16,
+    pub segment_b: u16,
+    pub winfuncptr: u32,
+    pub bytesperscanline: u16,
+    pub xresolution: u16,
+    pub yresolution: u16,
+    pub xcharsize: u8,
+    pub ycharsize: u8,
+    pub numberofplanes: u8,
+    pub bitsperpixel: u8,
+    pub numberofbanks: u8,
+    pub memorymodel: u8,
+    pub banksize: u8,
+    pub numberofimagepages: u8,
+    pub unused: u8,
+    pub redmasksize: u8,
+    pub redfieldposition: u8,
+    pub greenmasksize: u8,
+    pub greenfieldposition: u8,
+    pub bluemasksize: u8,
+    pub bluefieldposition: u8,
+    pub rsvdmasksize: u8,
+    pub rsvdfieldposition: u8,
+    pub directcolormodeinfo: u8,
+    pub physbaseptr: u32,
+    pub offscreenmemoryoffset: u32,
+    pub offscreenmemsize: u16,
+    pub reserved: [u8; 206],
+}
+
+pub struct VideoModeIter {
+    thunk10: extern "C" fn(),
+    mode_ptr: *const u16,
+}
+
+impl VideoModeIter {
+    pub fn new(thunk10: extern "C" fn()) -> Self {
+        // Get card info
+        let mut data = ThunkData::new();
+        data.eax = 0x4F00;
+        data.edi = VBE_CARD_INFO_ADDR as u32;
+        unsafe {
+            data.with(thunk10);
+        }
+        let mode_ptr = if data.eax == 0x004F {
+            let card_info = unsafe { ptr::read(VBE_CARD_INFO_ADDR as *const VbeCardInfo) };
+            unsafe { card_info.videomodeptr.as_ptr::<u16>() }
+        } else {
+            error!("Failed to read VBE card info: 0x{:04X}", { data.eax });
+            ptr::null()
+        };
+        Self { thunk10, mode_ptr }
+    }
+}
+
+impl Iterator for VideoModeIter {
+    type Item = OsVideoMode;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.mode_ptr.is_null() {
+            return None;
+        }
+
+        loop {
+            // Set bit 14 to get linear frame buffer
+            let mode = unsafe { *self.mode_ptr } | (1 << 14);
+            if mode == 0xFFFF {
+                return None;
+            }
+            self.mode_ptr = unsafe { self.mode_ptr.add(1) };
+
+            // Get mode info
+            let mut data = ThunkData::new();
+            data.eax = 0x4F01;
+            data.ecx = mode as u32;
+            data.edi = VBE_MODE_INFO_ADDR as u32;
+            unsafe {
+                data.with(self.thunk10);
+            }
+            if data.eax == 0x004F {
+                let mode_info = unsafe { ptr::read(VBE_MODE_INFO_ADDR as *const VbeModeInfo) };
+
+                // We only support 32-bits per pixel modes
+                if mode_info.bitsperpixel != 32 {
+                    continue;
+                }
+
+                let width = mode_info.xresolution as u32;
+                let height = mode_info.yresolution as u32;
+                //TODO: support stride that is not a multiple of 4
+                let stride = mode_info.bytesperscanline as u32 / 4;
+
+                return Some(OsVideoMode {
+                    id: mode as u32,
+                    width,
+                    height,
+                    stride,
+                    base: mode_info.physbaseptr as u64,
+                });
+            } else {
+                error!("Failed to read VBE mode 0x{:04X} info: 0x{:04X}", mode, {
+                    data.eax
+                });
+            }
+        }
+    }
+}

bootloader/src/os/bios/vga.rs

@@ -0,0 +1,119 @@
+use core::{fmt, slice};
+
+#[derive(Clone, Copy)]
+#[repr(C, packed)]
+pub struct VgaTextBlock {
+    pub char: u8,
+    pub color: u8,
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Copy)]
+#[repr(u8)]
+pub enum VgaTextColor {
+    Black = 0,
+    Blue = 1,
+    Green = 2,
+    Cyan = 3,
+    Red = 4,
+    Purple = 5,
+    Brown = 6,
+    Gray = 7,
+    DarkGray = 8,
+    LightBlue = 9,
+    LightGreen = 10,
+    LightCyan = 11,
+    LightRed = 12,
+    LightPurple = 13,
+    Yellow = 14,
+    White = 15,
+}
+
+pub struct Vga {
+    pub base: usize,
+    pub width: usize,
+    pub height: usize,
+    pub x: usize,
+    pub y: usize,
+    pub bg: VgaTextColor,
+    pub fg: VgaTextColor,
+}
+
+impl Vga {
+    pub const unsafe fn new(base: usize, width: usize, height: usize) -> Self {
+        Self {
+            base,
+            width,
+            height,
+            x: 0,
+            y: 0,
+            bg: VgaTextColor::Black,
+            fg: VgaTextColor::Gray,
+        }
+    }
+
+    pub unsafe fn blocks(&mut self) -> &'static mut [VgaTextBlock] {
+        slice::from_raw_parts_mut(self.base as *mut VgaTextBlock, self.width * self.height)
+    }
+
+    pub fn clear(&mut self) {
+        self.x = 0;
+        self.y = 0;
+        let blocks = unsafe { self.blocks() };
+        for i in 0..blocks.len() {
+            blocks[i] = VgaTextBlock {
+                char: 0,
+                color: ((self.bg as u8) << 4) | (self.fg as u8),
+            };
+        }
+    }
+}
+
+impl fmt::Write for Vga {
+    fn write_str(&mut self, s: &str) -> Result<(), fmt::Error> {
+        let blocks = unsafe { self.blocks() };
+        for c in s.chars() {
+            if self.x >= self.width {
+                self.x = 0;
+                self.y += 1;
+            }
+            while self.y >= self.height {
+                for y in 1..self.height {
+                    for x in 0..self.width {
+                        let i = y * self.width + x;
+                        let j = i - self.width;
+                        blocks[j] = blocks[i];
+                        if y + 1 == self.height {
+                            blocks[i].char = 0;
+                        }
+                    }
+                }
+                self.y -= 1;
+            }
+            match c {
+                '\x08' => {
+                    if self.x > 0 {
+                        self.x -= 1;
+                    }
+                }
+                '\r' => {
+                    self.x = 0;
+                }
+                '\n' => {
+                    self.x = 0;
+                    self.y += 1;
+                }
+                _ => {
+                    let i = self.y * self.width + self.x;
+                    if let Some(block) = blocks.get_mut(i) {
+                        block.char = c as u8;
+                        block.color = ((self.bg as u8) << 4) | (self.fg as u8);
+                    }
+                    self.x += 1;
+                }
+            }
+        }
+
+        Ok(())
+    }
+}

bootloader/src/os/mod.rs

@@ -0,0 +1,81 @@
+use redoxfs::Disk;
+
+#[cfg(all(target_arch = "x86", target_os = "none"))]
+pub use self::bios::*;
+
+#[cfg(all(target_arch = "x86", target_os = "none"))]
+#[macro_use]
+mod bios;
+
+#[derive(Clone, Copy, Debug)]
+pub enum OsHwDesc {
+	Acpi(u64, u64),
+	DeviceTree(u64, u64),
+	NotFound,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum OsKey {
+	Left,
+	Right,
+	Up,
+	Down,
+	Backspace,
+	Delete,
+	Enter,
+	Char(char),
+	Other,
+}
+
+// Keep synced with BootloaderMemoryKind in kernel
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u64)]
+pub enum OsMemoryKind {
+	Null = 0,
+	Free = 1,
+	Reclaim = 2,
+	Reserved = 3,
+}
+
+// Keep synced with BootloaderMemoryEntry in kernel
+#[derive(Clone, Copy, Debug)]
+#[repr(C, packed(8))]
+pub struct OsMemoryEntry {
+	pub base: u64,
+	pub size: u64,
+	pub kind: OsMemoryKind,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct OsVideoMode {
+	pub id: u32,
+	pub width: u32,
+	pub height: u32,
+	pub stride: u32,
+	pub base: u64,
+}
+
+pub trait Os<D: Disk, V: Iterator<Item = OsVideoMode>> {
+	fn name(&self) -> &str;
+
+	fn alloc_zeroed_page_aligned(&self, size: usize) -> *mut u8;
+
+	#[allow(dead_code)]
+	fn page_size(&self) -> usize;
+
+	fn filesystem(&self, password_opt: Option<&[u8]>) -> syscall::Result<redoxfs::FileSystem<D>>;
+
+	fn hwdesc(&self) -> OsHwDesc;
+
+	fn video_outputs(&self) -> usize;
+	fn video_modes(&self, output_i: usize) -> V;
+	fn set_video_mode(&self, output_i: usize, mode: &mut OsVideoMode);
+	fn best_resolution(&self, output_i: usize) -> Option<(u32, u32)>;
+
+	fn get_key(&self) -> OsKey;
+
+	fn clear_text(&self);
+	fn get_text_position(&self) -> (usize, usize);
+	fn set_text_position(&self, x: usize, y: usize);
+	fn set_text_highlight(&self, highlight: bool);
+}