# ディスクイメージを作成、なお実際に200MB確保するわけではない
qemu-img create -f raw disk.img 200M
mkfs.fat -n 'MIKAN OS' -s 2 -f 2 -R 32 -F 32 disk.img

# FATでフォーマット、各引数の詳細はTODO
mkfs.fat -n 'MIKAN OS' -s 2 -f 2 -R 32 -F 32 disk.img

# ./mnt に disk.img をマウント -o loop はループバック・デバイスのためのオプション
# UEFIの形式に従って /EFI/BOOT/BOOTX64.EFI を配置
mkdir -p mnt
sudo mount -o loop disk.img mnt
sudo mkdir -p mnt/EFI/BOOT
sudo cp BOOTX64.EFI mnt/EFI/BOOT/BOOTX64.EFI
sudo umount mnt

# COFF形式でオブジェクトを出力
clang -target x86_64-pc-win32-coff -mno-red-zone -fno-stack-protector -fshort-wchar -Wall -c hello.c
# UEFI用のPEファイルを生成
lld-link /subsystem:efi_application /entry:EfiMain /out:hello.efi hello.o

...
[dependencies]
# 必須ではないが、uefiがloggerサポートしてるのでついでに使うことにする
log = {version = "0.4", default-features = false}
# featuresはとりあえず全部有効にする
uefi = {version = "0.11", features = ["alloc", "logger", "exts"]}
# Rustがno_stdで要求するpanic_handlerの提供、およびinitユーティリティ
uefi-services = "0.8"

#![no_std]
#![no_main]
#![feature(asm)]
#![feature(abi_efiapi)]

// まだ未使用
#[macro_use]
extern crate alloc;

use core::fmt::Write;
use uefi::prelude::*;
use uefi::table::runtime::ResetType;

#[entry]
fn efi_main(_image: Handle, mut st: SystemTable<Boot>) -> Status {
    // logging, memory allocationの初期化
    uefi_services::init(&mut st).unwrap_success();

    st.stdout().reset(false).unwrap_success();

    // log::info!("Hello, World!"); とロギングもできる
    writeln!(st.stdout(), "Hello, World!").unwrap();

    st.boot_services().stall(3_000_000);

    st.stdout().reset(false).unwrap_success();

    st.runtime_services()
        .reset(ResetType::Shutdown, Status::SUCCESS, None);
}

cargo build -Zbuild-std -Zbuild-std-features=compiler-builtins-mem --target x86_64-unknown-uefi
../run_qemu.sh target/x86_64-unknown-uefi/bootloader.efi

#![no_std]
#![no_main]
#![feature(asm)]
#![feature(abi_efiapi)]

#[macro_use]
extern crate alloc;

use core::mem;
use log::info;
use uefi::prelude::*;
use uefi::proto::media::file::{File, FileAttribute, FileMode, FileType};
use uefi::table::boot::MemoryDescriptor;
use uefi::table::runtime::ResetType;

#[entry]
fn efi_main(image: Handle, mut st: SystemTable<Boot>) -> Status {
    uefi_services::init(&mut st).unwrap_success();
    st.stdout().reset(false).unwrap_success();

    info!("Get memory map");
    // 余分にアロケートするのはmemory_map_sizeの推測が厳密でないため
    let size = st.boot_services().memory_map_size() + 8 * mem::size_of::<MemoryDescriptor>();
    let mut buffer = vec![0; size];
    let (_, descriptors) = st.boot_services().memory_map(&mut buffer).unwrap_success();

    // gBS->OpenProtocol周りのコードはどう対応付いているのか以前にUEFIでどういう枠組みなのかも不明
    // とりあえずSimple File Systemはuefi-rsではAPIとして提供されており、本書のCコードより高抽象である
    info!("Write memory map to /memmap");
    let mut root_dir = {
        let sfs = st
            .boot_services()
            .get_image_file_system(image)
            .unwrap_success();
        unsafe { &mut *sfs.get() }.open_volume().unwrap_success()
    };
    let mut file = match root_dir
        .open("memmap", FileMode::CreateReadWrite, FileAttribute::empty())
        .unwrap_success()
        .into_type()
        .unwrap_success()
    {
        FileType::Regular(file) => file,
        FileType::Dir(_) => panic!(),
    };

    file.write("Index, Type, Type(name), PhysicalStart, NumberOfPages, Attribute\n".as_bytes())
        .unwrap_success();
    // 本書のCコードでやってるプリミティブなイテレート等はuefi-rsでは不要だった
    for (i, d) in descriptors.enumerate() {
        let line = format!(
            "{}, {:x}, {:?}, {:08x}, {:x}, {:x}\n",
            i,
            d.ty.0,
            d.ty,
            d.phys_start,
            d.page_count,
            d.att.bits() & 0xfffff
        );
        file.write(line.as_bytes()).unwrap_success();
    }
    drop(file);

    info!("done.");

    st.boot_services().stall(3_000_000);
    st.stdout().reset(false).unwrap_success();
    st.runtime_services()
        .reset(ResetType::Shutdown, Status::SUCCESS, None);
}

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

0x3e62f326:  eb fd                    jmp      0x3e62f325

0x3e62f325:  f4                       hlt
0x3e62f326:  eb fd                    jmp      0x3e62f325

[build]
target = "x86_64-unknown-uefi"

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

#![no_std]
#![no_main]
#![feature(asm)]

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

#[panic_handler]
fn panic(_info: &core::panic::PanicInfo) -> ! {
    loop {
        unsafe {
            asm!("hlt");
        }
    }
}

{
  "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-flavor": "ld.lld",
  "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.lld": [
      "--entry=kernel_main",
      "--image-base=0x100000",
      "-okernel.elf",
      "--static"
    ]
  },
  "target-pointer-width": "64"
}

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

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

    ...
    "rust-analyzer.checkOnSave.allTargets": false,
    ...

const KERNEL_BASE_ADDR: usize = 0x100000;
const EFI_PAGE_SIZE: usize = 0x1000;

fn load_kernel(image: Handle, st: &SystemTable<Boot>) {
    let mut root_dir = fs::open_root_dir(image, st.boot_services());
    let mut file = fs::open_file(&mut root_dir, "kernel.elf");
    let size = fs::file_info(&mut file).file_size() as usize;
    st.boot_services()
        .allocate_pages(
            AllocateType::Address(KERNEL_BASE_ADDR),
            MemoryType::LOADER_DATA,
            (size + EFI_PAGE_SIZE - 1) / EFI_PAGE_SIZE,
        )
        .unwrap_success();
    file.read(unsafe { core::slice::from_raw_parts_mut(KERNEL_BASE_ADDR as *mut u8, size) })
        .unwrap_success();
}

fn exit_boot_services(image: Handle, st: SystemTable<Boot>) -> SystemTable<Runtime> {
    let max_mmap_size =
        st.boot_services().memory_map_size() + 8 * mem::size_of::<MemoryDescriptor>();
    let mut mmap_buf = vec![0; max_mmap_size];
    let (st, _) = st
        .exit_boot_services(image, &mut mmap_buf[..])
        .unwrap_success();
    mem::forget(mmap_buf);
    st
}

let entry_point_addr = LittleEndian::read_u64(unsafe {
    core::slice::from_raw_parts((KERNEL_BASE_ADDR + 24) as *const u8, 8)
});
let entry_point: extern "sysv64" fn() = unsafe { mem::transmute(entry_point_addr as usize) };
entry_point();

fn load_kernel(image: Handle, st: &SystemTable<Boot>) -> usize {
    let mut root_dir = fs::open_root_dir(image, st.boot_services());
    let mut elf_file = fs::open_file(&mut root_dir, "kernel.elf");
    let elf_buf = fs::read_file(&mut elf_file);
    let elf = elf::Elf::parse(&elf_buf).expect("Failed to parse kernel.elf");

    let mut dest_first = usize::MAX;
    let mut dest_last = 0;
    for ph in elf.program_headers.iter() {
        if ph.p_type != elf::program_header::PT_LOAD {
            continue;
        }
        dest_first = dest_first.min(ph.p_vaddr as usize);
        dest_last = dest_last.max((ph.p_vaddr + ph.p_memsz) as usize);
    }

    st.boot_services()
        .allocate_pages(
            AllocateType::Address(dest_first),
            MemoryType::LOADER_DATA,
            (dest_last - dest_first + EFI_PAGE_SIZE - 1) / EFI_PAGE_SIZE,
        )
        .unwrap_success();

    for ph in elf.program_headers.iter() {
        if ph.p_type != elf::program_header::PT_LOAD {
            continue;
        }
        let ofs = ph.p_offset as usize;
        let fsize = ph.p_filesz as usize;
        let msize = ph.p_memsz as usize;
        let dest = unsafe { core::slice::from_raw_parts_mut(ph.p_vaddr as *mut u8, msize) };
        dest[..fsize].copy_from_slice(&elf_buf[ofs..ofs + fsize]);
        dest[fsize..].fill(0);
    }

    elf.entry as usize
}