#![allow(unused)]
fn main() {
// src/main.rs：myrcore 批处理内核（阶段 2）
#![no_std]
#![no_main]

use core::arch::{asm, global_asm};
use core::fmt::{self, Write};
use core::panic::PanicInfo;

global_asm!(include_str!("entry.asm"));
global_asm!(include_str!("trap.asm"));

const APP_BASE: usize = 0x8040_0000;
const SBI_PUTCHAR: usize = 0x01;
const SBI_SRST: usize = 0x5352_5354;

// 应用机器码：addi a7, zero, 2; ecall
static APP: [u8; 8] = [
    0x93, 0x08, 0x20, 0x00, // addi a7, zero, 2
    0x73, 0x00, 0x00, 0x00, // ecall
];

extern "C" {
    fn __s_trap_entry();
}

#[inline(always)]
fn sbi_call(eid: usize, fid: usize, a0: usize, a1: usize) -> (isize, usize) {
    let (err, val): (isize, usize);
    unsafe {
        asm!("ecall", in("a7") eid, in("a6") fid,
             inlateout("a0") a0 => err, inlateout("a1") a1 => val,
             options(nostack));
    }
    (err, val)
}

struct Console;
impl Write for Console {
    fn write_str(&mut self, s: &str) -> fmt::Result {
        for b in s.bytes() { let _ = sbi_call(SBI_PUTCHAR, 0, b as usize, 0); }
        Ok(())
    }
}
pub fn print_fmt(args: fmt::Arguments) {
    let mut c = Console;
    c.write_fmt(args).unwrap();
}
#[macro_export]
macro_rules! print {
    ($($arg:tt)*) => { $crate::print_fmt(format_args!($($arg)*)) };
}
#[macro_export]
macro_rules! println {
    () => { $crate::print!("\n") };
    ($($arg:tt)*) => { $crate::print!("{}\n", format_args!($($arg)*)) };
}

fn shutdown(failure: bool) -> ! {
    let _ = sbi_call(SBI_SRST, 0, 0, failure as usize);
    loop { core::hint::spin_loop(); }
}

#[repr(C)]
pub struct TrapFrame { pub x: [usize; 32], pub sepc: usize, pub sstatus: usize }

#[no_mangle]
pub extern "C" fn rust_main() -> ! {
    println!("batch: load app at {:#x}", APP_BASE);
    unsafe {
        // 1) 复制应用
        core::ptr::copy_nonoverlapping(APP.as_ptr(), APP_BASE as *mut u8, APP.len());
        // 2) 装 trap 入口
        asm!("csrw stvec, {}", in(reg) __s_trap_entry as usize);
        // 3) 保存内核栈顶，trap 时与用户 sp 交换
        asm!("csrw sscratch, sp");
        // 4) sstatus: SPP=U, SPIE=1, SIE=0
        let mut ss: usize;
        asm!("csrr {}, sstatus", out(reg) ss);
        ss &= !(1 << 1);
        ss = (ss & !(1 << 8)) | (1 << 5);
        asm!("csrw sstatus, {}", in(reg) ss);
        // 5) 返回地址 = 应用入口
        asm!("csrw sepc, {}", in(reg) APP_BASE);
        // 6) 降级到 U
        asm!("sret", options(noreturn));
    }
}

#[no_mangle]
pub extern "C" fn s_trap_handler(tf: &mut TrapFrame) {
    let scause: usize;
    unsafe { asm!("csrr {}, scause", out(reg) scause) };
    if scause == 8 {
        match tf.x[17] { // a7
            1 => { let _ = sbi_call(SBI_PUTCHAR, 0, tf.x[10], 0); }
            2 => { println!("batch: app exit"); shutdown(false); }
            _ => println!("batch: unknown syscall {}", tf.x[17]),
        }
        tf.sepc += 4;
    } else {
        println!("batch: trap {:#x} at {:#x}", scause, tf.sepc);
        shutdown(true);
    }
}

#[panic_handler]
fn panic(_: &PanicInfo) -> ! { shutdown(true) }
}

cargo build --release
qemu-system-riscv64 -machine virt -nographic -bios default \
  -kernel target/riscv64gc-unknown-none-elf/release/myrcore

# __switch(prev: *mut TaskContext, next: *const TaskContext)
# a0 = prev, a1 = next
.section .text
.globl __switch
__switch:
    sd      ra, 0(a0)
    sd      sp, 8(a0)
    sd      s0, 16(a0)
    sd      s1, 24(a0)
    sd      s2, 32(a0)
    sd      s3, 40(a0)
    sd      s4, 48(a0)
    sd      s5, 56(a0)
    sd      s6, 64(a0)
    sd      s7, 72(a0)
    sd      s8, 80(a0)
    sd      s9, 88(a0)
    sd      s10, 96(a0)
    sd      s11, 104(a0)

    ld      ra, 0(a1)
    ld      sp, 8(a1)
    ld      s0, 16(a1)
    ld      s1, 24(a1)
    ld      s2, 32(a1)
    ld      s3, 40(a1)
    ld      s4, 48(a1)
    ld      s5, 56(a1)
    ld      s6, 64(a1)
    ld      s7, 72(a1)
    ld      s8, 80(a1)
    ld      s9, 88(a1)
    ld      s10, 96(a1)
    ld      s11, 104(a1)
    ret

# __switch(prev: *mut TaskContext, next: *const TaskContext)
# rdi = prev, rsi = next；布局：rsp, rbx, rbp, r12..r15
__switch:
    movq    %rsp, 0(%rdi)
    movq    %rbx, 8(%rdi)
    movq    %rbp, 16(%rdi)
    movq    %r12, 24(%rdi)
    movq    %r13, 32(%rdi)
    movq    %r14, 40(%rdi)
    movq    %r15, 48(%rdi)

    movq    0(%rsi), %rsp
    movq    8(%rsi), %rbx
    movq    16(%rsi), %rbp
    movq    24(%rsi), %r12
    movq    32(%rsi), %r13
    movq    40(%rsi), %r14
    movq    48(%rsi), %r15
    ret

// __switch(prev: *mut TaskContext, next: *const TaskContext)
// x0 = prev, x1 = next；布局：sp, lr, x19..x28, x29
__switch:
    mov     x9, sp
    str     x9, [x0, #0]
    str     x30, [x0, #8]
    stp     x19, x20, [x0, #16]
    stp     x21, x22, [x0, #32]
    stp     x23, x24, [x0, #48]
    stp     x25, x26, [x0, #64]
    stp     x27, x28, [x0, #80]
    str     x29, [x0, #96]

    ldr     x9, [x1, #0]
    mov     sp, x9
    ldr     x30, [x1, #8]
    ldp     x19, x20, [x1, #16]
    ldp     x21, x22, [x1, #32]
    ldp     x23, x24, [x1, #48]
    ldp     x25, x26, [x1, #64]
    ldp     x27, x28, [x1, #80]
    ldr     x29, [x1, #96]
    ret

#![allow(unused)]
fn main() {
use core::sync::atomic::{AtomicUsize, Ordering};
use alloc::sync::Arc;
use spin::Mutex;

#[repr(C)]
#[derive(Clone, Copy, Default)]
pub struct TaskContext {
    pub ra: usize,
    pub sp: usize,
    pub s: [usize; 12], // s0..s11
}

pub enum TaskState { Ready, Running, Zombie }

pub struct Task {
    pub pid: usize,
    pub state: TaskState,
    pub ctx: TaskContext,
    pub kstack: usize,
    pub trap_cx: usize, // 用户 trap frame 的内核地址
}

pub struct Scheduler {
    pub current: Option<Arc<Mutex<Task>>>,
    pub ready: alloc::collections::VecDeque<Arc<Mutex<Task>>>,
    pub next_pid: AtomicUsize,
}

impl Scheduler {
    pub fn push(&mut self, task: Arc<Mutex<Task>>) {
        self.ready.push_back(task);
    }

    /// 取出下一个任务；调用者负责在合适的时候 __switch
    pub fn pick(&mut self) -> Option<Arc<Mutex<Task>>> {
        self.ready.pop_front()
    }
}
}

#![allow(unused)]
fn main() {
use core::ptr::NonNull;

pub struct PageTable {
    root: NonNull<PageTableEntry>, // 指向 512 项的根页
    frames: alloc::vec::Vec<NonNull<PageTableEntry>>, // 拥有所有子页
}

impl Drop for PageTable {
    fn drop(&mut self) {
        // 先释放子页，再释放根页；顺序反了会 use-after-free
        for frame in self.frames.drain(..) {
            unsafe { frame.drop_in_place() };
        }
    }
}

#[repr(C)]
#[derive(Clone, Copy)]
pub struct PageTableEntry(pub usize);

impl PageTableEntry {
    pub fn is_valid(&self) -> bool { self.0 & 1 != 0 }
    pub fn is_leaf(&self) -> bool { self.0 & 0b1110 != 0 }
    pub fn ppn(&self) -> usize { (self.0 >> 10) & ((1 << 44) - 1) }
}
}

// sv39.rs：主机上的 Sv39 页表构造/遍历器
const PTE_V: u64 = 1 << 0;
const PTE_R: u64 = 1 << 1;
const PTE_W: u64 = 1 << 2;
const PTE_X: u64 = 1 << 3;
const PTE_U: u64 = 1 << 4;

struct Sv39 {
    frames: Vec<[u64; 512]>, // 每个元素是一个 4 KiB 页表页
    root: usize,
}

impl Sv39 {
    fn new() -> Self {
        let mut frames = Vec::new();
        frames.push([0u64; 512]);
        Self { frames, root: 0 }
    }

    fn alloc(&mut self) -> usize {
        self.frames.push([0u64; 512]);
        self.frames.len() - 1
    }

    fn index(va: usize, level: usize) -> usize {
        (va >> (12 + 9 * level)) & 0x1ff
    }

    /// 确保 va 在 level 上有一个子页表，返回子页在 frames 中的下标
    fn ensure(&mut self, va: usize, level: usize) -> usize {
        let mut frame = self.root;
        for l in (level + 1..=2).rev() {
            let i = Self::index(va, l);
            let pte = self.frames[frame][i];
            if pte & PTE_V == 0 {
                let child = self.alloc();
                self.frames[frame][i] = ((child as u64) << 10) | PTE_V;
                frame = child;
            } else {
                frame = (pte >> 10) as usize;
            }
        }
        frame
    }

    /// 映射 4 KiB 页（level 0）
    fn map4k(&mut self, va: usize, pa: usize, flags: u64) {
        let frame = self.ensure(va, 0);
        let i = Self::index(va, 0);
        self.frames[frame][i] = ((pa as u64 >> 12) << 10) | flags | PTE_V;
    }

    /// 映射 2 MiB 大页（level 1）
    fn map2m(&mut self, va: usize, pa: usize, flags: u64) {
        let frame = self.ensure(va, 1);
        let i = Self::index(va, 1);
        self.frames[frame][i] = ((pa as u64 >> 12) << 10) | flags | PTE_V;
    }

    /// 返回 (物理地址, 命中的 PTE, 页大小)
    fn translate(&self, va: usize) -> Option<(usize, u64, usize)> {
        let mut frame = self.root;
        for level in (0..=2).rev() {
            let i = Self::index(va, level);
            let pte = self.frames[frame][i];
            if pte & PTE_V == 0 {
                return None;
            }
            if pte & (PTE_R | PTE_W | PTE_X) != 0 {
                // 叶子：大页要保留低位的偏移
                let mask = (1usize << (12 + 9 * level)) - 1;
                let pa = (((pte >> 10) as usize) << 12) | (va & mask);
                return Some((pa, pte, 1 << (12 + 9 * level)));
            }
            frame = (pte >> 10) as usize;
        }
        None
    }
}

fn main() {
    let mut pt = Sv39::new();
    // 4 KiB 页：VA 0x1000 -> PA 0x8000_1000，可读写
    pt.map4k(0x1000, 0x8000_1000, PTE_R | PTE_W);
    // 2 MiB 大页：VA 0x4000_0000 -> PA 0x8000_0000，可读写执行
    pt.map2m(0x4000_0000, 0x8000_0000, PTE_R | PTE_W | PTE_X);

    for va in [0x1000usize, 0x1abc, 0x4000_0000, 0x4012_3456, 0x5000] {
        match pt.translate(va) {
            Some((pa, pte, size)) => println!(
                "VA {:#010x} -> PA {:#010x}  PTE {:#x}  page {} KiB",
                va, pa, pte, size / 1024
            ),
            None => println!("VA {:#010x} -> unmapped", va),
        }
    }
    println!("root frame = {}, frames = {}", pt.root, pt.frames.len());
}

rustc -O sv39.rs -o sv39 && ./sv39

#![allow(unused)]
fn main() {
pub fn sys_fork(parent: &Arc<Mutex<Process>>) -> Result<usize, SysError> {
    let mut parent = parent.lock();
    let child = Process::new_child(&parent)?;      // 分配 PCB/pid
    let child = Arc::new(Mutex::new(child));

    // 复制地址空间；失败时 child 的 Drop 会释放已分配页
    child.lock().memory_set = parent.memory_set.fork()?;
    // 复制 fd 表：Arc 克隆，共享 file offset
    child.lock().fd_table = parent.fd_table.clone();
    // 子进程从 fork 返回 0
    child.lock().trap_cx.x[10] = 0;
    // 父进程返回子 pid
    parent.trap_cx.x[10] = child.lock().pid;
    parent.children.push(child.clone());

    Ok(child.lock().pid)
}

pub fn sys_exec(proc: &Arc<Mutex<Process>>, path: &str) -> Result<(), SysError> {
    let elf = load_elf(path)?;                     // 先在用户内存里解析
    let mut new_set = MemorySet::from_elf(&elf)?;  // 新页表，失败不影响旧地址空间
    let entry = elf.entry;
    let mut p = proc.lock();
    p.memory_set = new_set;                        // 原子替换；旧 MemorySet 在这里 Drop
    p.trap_cx.sepc = entry;
    p.trap_cx.sstatus = (p.trap_cx.sstatus & !(1 << 8)) | (1 << 5);
    Ok(())
}
}

#![allow(unused)]
fn main() {
pub trait File: Send + Sync {
    fn read(&self, buf: &mut [u8]) -> Result<usize, SysError>;
    fn write(&self, buf: &[u8]) -> Result<usize, SysError>;
    fn seek(&self, pos: SeekFrom) -> Result<usize, SysError>;
}

pub struct FdTable {
    pub fds: Vec<Option<Arc<dyn File>>>,
}

impl FdTable {
    pub fn alloc(&mut self, file: Arc<dyn File>) -> usize {
        if let Some(fd) = self.fds.iter().position(|f| f.is_none()) {
            self.fds[fd] = Some(file);
            return fd;
        }
        self.fds.push(Some(file));
        self.fds.len() - 1
    }
}
}

// myfs.rs：最小文件系统镜像的构造与解析
use std::convert::TryInto;

const BLOCK: usize = 512;
const MAGIC: u32 = 0x4d59_4653; // "MYFS"
const INODE_SIZE: usize = 32;
const DIRENT_SIZE: usize = 32;

#[derive(Clone, Copy)]
struct Inode {
    mode: u16,          // 1=file, 2=dir
    size: u32,
    direct: [u32; 4],
}

#[derive(Clone, Copy)]
struct DirEntry {
    inode: u32,
    name: [u8; 28],
}

fn put_u32(buf: &mut [u8], off: usize, v: u32) {
    buf[off..off + 4].copy_from_slice(&v.to_le_bytes());
}
fn get_u32(buf: &[u8], off: usize) -> u32 {
    u32::from_le_bytes(buf[off..off + 4].try_into().unwrap())
}

fn write_inode(img: &mut [u8], idx: usize, ino: &Inode) {
    let off = 3 * BLOCK + idx * INODE_SIZE;
    img[off..off + 2].copy_from_slice(&ino.mode.to_le_bytes());
    put_u32(img, off + 4, ino.size);
    for (i, b) in ino.direct.iter().enumerate() {
        put_u32(img, off + 8 + i * 4, *b);
    }
}

fn read_inode(img: &[u8], idx: usize) -> Inode {
    let off = 3 * BLOCK + idx * INODE_SIZE;
    let mut direct = [0u32; 4];
    for i in 0..4 {
        direct[i] = get_u32(img, off + 8 + i * 4);
    }
    Inode {
        mode: u16::from_le_bytes(img[off..off + 2].try_into().unwrap()),
        size: get_u32(img, off + 4),
        direct,
    }
}

fn write_dirent(img: &mut [u8], block: usize, slot: usize, e: &DirEntry) {
    let off = block * BLOCK + slot * DIRENT_SIZE;
    put_u32(img, off, e.inode);
    img[off + 4..off + 32].copy_from_slice(&e.name);
}

fn main() {
    let data_start = 4u32;
    let mut img = vec![0u8; 8 * BLOCK];

    // 超级块
    put_u32(&mut img, 0, MAGIC);
    put_u32(&mut img, 4, 2);          // inode 数
    put_u32(&mut img, 8, data_start); // 数据区起始块

    // inode 0 = 根目录，inode 1 = hello.txt
    write_inode(&mut img, 0, &Inode { mode: 2, size: 64, direct: [data_start, 0, 0, 0] });
    write_inode(&mut img, 1, &Inode { mode: 1, size: 13, direct: [data_start + 1, 0, 0, 0] });

    // 根目录的两个目录项
    let mut dot = DirEntry { inode: 0, name: [0; 28] };
    dot.name[0] = b'.';
    write_dirent(&mut img, data_start as usize, 0, &dot);

    let mut hello = DirEntry { inode: 1, name: [0; 28] };
    hello.name[..9].copy_from_slice(b"hello.txt");
    write_dirent(&mut img, data_start as usize, 1, &hello);

    // 文件内容
    let content = b"hello, myfs!\n";
    let off = (data_start as usize + 1) * BLOCK;
    img[off..off + content.len()].copy_from_slice(content);

    // 解析回来
    assert_eq!(get_u32(&img, 0), MAGIC);
    let root = read_inode(&img, 0);
    println!("root: mode={} size={} direct={:?}", root.mode, root.size, root.direct);
    for slot in 0..2 {
        let eoff = root.direct[0] as usize * BLOCK + slot * DIRENT_SIZE;
        let ino = get_u32(&img, eoff);
        let name = &img[eoff + 4..eoff + 32];
        let end = name.iter().position(|&b| b == 0).unwrap_or(28);
        println!("dir[{}]: inode={} name={}", slot, ino, String::from_utf8_lossy(&name[..end]));
    }
    let file = read_inode(&img, 1);
    let foff = file.direct[0] as usize * BLOCK;
    println!("hello.txt: {}", String::from_utf8_lossy(&img[foff..foff + file.size as usize]));
    println!("image bytes = {}", img.len());
}

rustc -O myfs.rs -o myfs && ./myfs

#![allow(unused)]
fn main() {
pub struct Pipe {
    buf: [u8; 4096],
    read: usize,
    write: usize,
    len: usize,
    readers: usize,
    writers: usize,
}

impl Pipe {
    pub fn read(&mut self, out: &mut [u8]) -> usize {
        let n = out.len().min(self.len);
        for i in 0..n {
            out[i] = self.buf[(self.read + i) % self.buf.len()];
        }
        self.read = (self.read + n) % self.buf.len();
        self.len -= n;
        n
    }

    pub fn write(&mut self, data: &[u8]) -> usize {
        let n = data.len().min(self.buf.len() - self.len);
        for i in 0..n {
            self.buf[(self.write + i) % self.buf.len()] = data[i];
        }
        self.write = (self.write + n) % self.buf.len();
        self.len += n;
        n
    }
}
}

/* 内核自旋锁：单 hart 下的最小实现；多 hart 需要 amoswap 或 lr/sc */
#include <stdatomic.h>

typedef struct { atomic_flag flag; } spinlock_t;

static inline void spin_lock(spinlock_t *lk)
{
    while (atomic_flag_test_and_set_explicit(&lk->flag, memory_order_acquire))
        __asm__ volatile("pause");
}

static inline void spin_unlock(spinlock_t *lk)
{
    atomic_flag_clear_explicit(&lk->flag, memory_order_release);
}

gdb-multiarch target/riscv64gc-unknown-none-elf/release/myrcore \
  -ex 'target remote :1234' \
  -ex 'b sys_read' -ex 'b myfs::Inode::read_at' \
  -ex 'b virtio_blk::read_block' \
  -ex 'c'
# 命中后：
#   p/x $a0        fd
#   p/x $a1        用户 buf
#   p/x $a2        len
#   bt             看调用链
#   info registers satp scause sepc

cargo build --release
qemu-system-riscv64 -machine virt -nographic -bios default \
  -kernel target/riscv64gc-unknown-none-elf/release/myrcore -s -S
# 另一个终端
gdb-multiarch target/riscv64gc-unknown-none-elf/release/myrcore \
  -ex 'target remote :1234' \
  -ex 'b rust_main' -ex 'b s_trap_handler' -ex 'c'

gdb-multiarch ... -ex 'b MemorySet::activate' -ex 'c'
# 命中后
p/x $satp          # 应为 0x8000000000000000 | root_pa >> 12
p/x *(unsigned long*)$satp  # 根页表第一项
x/8gx root_page_table

rustc -O myfs.rs -o myfs && ./myfs
# 把输出写到文件后检查
./myfs > /tmp/myfs.txt
hexdump -C /tmp/myfs.img 2>/dev/null | head
# 如果没有生成镜像文件，可在程序里加 fs::write("myfs.img", &img)