ゼロからのOS自作入門をRustで

brew install --cask xquartz

xhost + 127.0.0.1 

127.0.0.1 being added to access control list

docker run --privileged --user vscode -v /path/to/local:/home/vscode/workspace -it ghcr.io/sarisia/mikanos  /bin/bash

git clone https://github.com/uchan-nos/mikanos.git
git checkout osbook_day04d

cd ~/edk2
source edksetup.sh
ln -s ~/workspace/mikanos/MikanLoaderPkg/ ./
sudo apt-get update
sudo apt-get install -y vim
vim Conf/target.txt

build

- Done - 
Build end time: 05:59:12, Jun.22 2022
Build total time: 00:00:01

source ~/osbook/devenv/buildenv.sh
cd ~/workspace/mikanos/kernel
make

~/osbook/devenv/run_qemu.sh ~/edk2/Build/MikanLoaderX64/DEBUG_CLANG38/X64/Loader.efi ~/workspace/mikanos/kernel/kernel.elf

docker ps

CONTAINER ID   IMAGE          COMMAND       CREATED        STATUS        PORTS     NAMES
48d399085107   e2aa4ef2666c   "/bin/bash"   18 hours ago   Up 18 hours             frosty_khorana          

docker commit 48d399085107 local_mikanos

docker run --privileged --user vscode -v /path/to/local:/home/vscode/workspace -it local_mikanos  /bin/bash

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env
# 日付を指定して、Rust の nightly をインストールする (nightly だけでも良いが、後々の変更が入ることを見込み、2022-06-20 時点では動くということを明示する)
rustup install nightly-2022-06-20
# rust-src も必要になるので用意しておく
rustup component add rust-src --toolchain nightly-2022-06-20-x86_64-unknown-linux-gnu

mkdir kernel_rust
cd kernel_rust
echo "nightly-2022-06-20" > rust-toolchain
cargo init

#![no_std]
#![no_main]

use core::arch::asm;
use core::panic::PanicInfo;

#[no_mangle]
extern "C" fn kernel_main() {
    unsafe {
        loop {
            asm!("hlt");
        }
    }
}

#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    loop {}
}

[build]
target = "./x86_64-unknown-none-mikankernel.json"

[unstable]
build-std = ["core", "compiler_builtins"]
build-std-features = ["compiler-builtins-mem"]

{
    "arch": "x86_64",
    "code-model": "kernel",
    "cpu": "x86-64",
    "data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128",
    "disable-redzone": true,
    "executables": true,
    "features": "-mmx,-sse,-sse2,-sse3,-ssse3,-sse4.1,-sse4.2,-3dnow,-3dnowa,-avx,-avx2,+soft-float",
    "linker": "ld.lld",
    "linker-flavor": "ld",
    "llvm-target": "x86_64-unknown-none-elf",
    "max-atomic-width": 64,
    "os": "none",
    "panic-strategy": "abort",
    "relro-level": "off",
    "position-independent-executables": false,
    "post-link-args": {
      "ld": [
        "--entry=kernel_main",
        "--image-base=0x100000",
        "--static",
        "--nostdlib"
      ]
    },
    "target-pointer-width": "64"
}

cargo build --release

cp target/x86_64-unknown-none-mikankernel/release/kernel_rust kernel.elf

~/osbook/devenv/run_qemu.sh ~/edk2/Build/MikanLoaderX64/DEBUG_CLANG38/X64/Loader.efi ~/workspace/kernel_rust/kernel.elf

#[derive(Debug, Copy, Clone)]
#[repr(u32)]
pub enum PixelFormat {
    Rgb = 0,
    Bgr,
}

#[derive(Debug, Copy, Clone)]
#[repr(C)]
pub struct FrameBuffer {
    pub frame_buffer: *mut u8,
    pub pixels_per_scan_line: u32,
    pub horizotanal_resolution: u32,
    pub vertical_resolution: u32,
    pub format: PixelFormat
}

impl FrameBuffer {
    pub unsafe fn write_byte(&mut self, index: usize, val: u8) {
        self.frame_buffer.add(index).write_volatile(val)
    }

    pub unsafe fn write_value(&mut self, index: usize, value: [u8; 3]) {
        (self.frame_buffer.add(index) as *mut [u8; 3]).write_volatile(value)
    }
}

pub struct PixelColor(pub u8, pub u8, pub u8);

pub struct Graphics {
    fb: FrameBuffer,
    pixel_writer: unsafe fn(&mut FrameBuffer, usize, &PixelColor),
}

impl Graphics {
    pub fn new(fb: FrameBuffer) -> Self {
        unsafe fn write_pixel_rgb(fb: &mut FrameBuffer, index: usize, rgb: &PixelColor) {
            fb.write_value(index, [rgb.0, rgb.1, rgb.2]);
        }
        unsafe fn write_pixel_bgr(fb: &mut FrameBuffer, index: usize, rgb: &PixelColor) {
            fb.write_value(index, [rgb.2, rgb.1, rgb.0]);
        }
        let pixel_writer = match fb.format {
            PixelFormat::Rgb => write_pixel_rgb,
            PixelFormat::Bgr => write_pixel_bgr,
            _ => {
                panic!("This pixel format is not supported by the drawing demo");
            }
        };


        Graphics {fb, pixel_writer}
    }

    pub fn write_pixel(&mut self, x: usize, y: usize, color: &PixelColor) {
        if x > self.fb.horizotanal_resolution as usize {
            panic!("bad x coord");
        }
        if y > self.fb.vertical_resolution as usize {
            panic!("bad y coord");
        }
        let pixel_index = y * (self.fb.pixels_per_scan_line as usize) + x;
        let base = 4 * pixel_index;
        unsafe {
            (self.pixel_writer)(&mut self.fb, base, &color);
        }
    }
}

#![no_std]
#![no_main]

pub mod graphics;

use core::panic::PanicInfo;
use core::arch::asm;
use graphics::{Graphics, FrameBuffer, PixelColor};

#[no_mangle]
extern "C" fn kernel_main(fb: *mut FrameBuffer) {
    let fb_a = unsafe {*fb};
    let mut graphics = Graphics::new(fb_a);

    for x in 0..fb_a.horizotanal_resolution as usize {
        for y in 0..fb_a.vertical_resolution as usize {
            graphics.write_pixel(x, y, &PixelColor(255, 255, 255));
        }
    }

    for x in 0..200 {
        for y in 0..100 {
            graphics.write_pixel(x, y, &PixelColor(0, 255, 0))
        }
    }

    unsafe {
        loop {
            asm!("hlt");
        }
    }
}

#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    loop {}
}

cargo build --release
cp target/x86_64-unknown-none-mikankernel/release/kernel_rust kernel.elf
~/osbook/devenv/run_qemu.sh ~/edk2/Build/MikanLoaderX64/DEBUG_CLANG38/X64/Loader.efi ~/workspace/kernel_rust/kernel.elf