系统调用

_entry:
        # 设置一个内核栈
        # stack0 在 start.c 中声明, 每个内核栈的大小为 4096 byte
        # 以下的代码表示将 sp 指向某个 CPU 对应的内核栈的起始地址
        # 也就是说, 进行如下设置: sp = stack0 + (hartid + 1) * 4096
        la sp, stack0           # sp = stack0
        li a0, 1024*4           # a0 = 4096
        csrr a1, mhartid        # 从寄存器 mhartid 中读取出当前对应的 CPU 号
        # a1 = hartid
        addi a1, a1, 1          # 地址空间向下增长, 因此将起始地址设置为最大
        mul a0, a0, a1          # a0 = 4096 * (hartid + 1)
        add sp, sp, a0          # sp = stack0 + (hartid + 1) * 4096

        # 跳转到 kernel/start.c 执行内核代码
        call start

// set M Previous Privilege mode to Supervisor, for mret.

// 清除 mstatus 中的 MPP 位，并设置为 SPP（Supervisor Previous Privilege）
unsigned long x = r_mstatus(); // 读取当前的 mstatus 寄存器值

// 通过 ~MSTATUS_MPP_MASK 取反后，只有 MPP 字段对应的位为 0，其他位为 1。把 MPP 字段清零，而不影响其他位
// 这一步通常是为了后续设置新的特权级别做准备，确保不会保留之前的 MPP 状态。 
x &= ~MSTATUS_MPP_MASK; 
x |= MSTATUS_MPP_S; // 设置 MPP 字段为 SPP（Supervisor Previous Privilege），表示上一次的特权级别是监督者模式
w_mstatus(x); // 将修改后的值写回 mstatus 寄存器，更新 CPU 的特权级别状态 

// set M Exception Program Counter to main, for mret. requires gcc -mcmodel=medany 
// 确保生成的代码可以正确处理任意地址范围的函数指针（如 main 的地址），避免因地址超出默认范围而导致的跳转错误
// 这在操作系统或裸机开发中非常重要，因为内核代码可能被加载到高地址空间

// 设置 mepc（Machine Exception Program Counter）寄存器为 main 函数的地址，
// 这样当发生异常或中断时，CPU 可以从这里继续执行
w_mepc((uint64)main); 

// disable paging for now.
w_satp(0); // 暂时禁用分页机制

// delegate all interrupts and exceptions to supervisor mode.
w_medeleg(0xffff); // 将所有的机器异常委托给监督者模式处理，0xffff 表示将所有异常都委托给监督者模式
w_mideleg(0xffff); // 将所有的机器中断委托给监督者模式处理，0xffff 表示将所有中断都委托给监督者模式

// 设置 SIE（Supervisor Interrupt Enable）寄存器，允许监督者模式下的设备中断
// SIE_SEIE（Supervisor External Interrupt Enable）允许监督者模式下的外部中断
// SIE_STIE（Supervisor Timer Interrupt Enable）允许监督者模式 下的定时器中断
// SIE_SSIE（Supervisor Software Interrupt Enable）允许监督者模式下的软件中断
w_sie(r_sie() | SIE_SEIE | SIE_STIE | SIE_SSIE); 

// configure Physical Memory Protection to give supervisor mode
// access to all of physical memory.
// 将 0x3fffffffffffffull 这个较大的地址写入 PMP 地址寄存器 0（pmpaddr0）
// 这个值通常表示允许访问的物理地址范围的上限，几乎覆盖了整个物理地址空间 
w_pmpaddr0(0x3fffffffffffffull); 

// 将 pmpcfg0 寄存器配置为 0xf，这通常表示允许监督者模式访问所有物理内存
// 0xf 是一个二进制数，表示所有的四个 PMP 配置位都被设置为 1，
// 这意味着监督者模式可以访问所有物理内存区域
// 在 RISC-V 架构中，PMP（Physical Memory Protection）用于配置内存访问权限，
// 通过设置 pmpcfg0 寄存器，可以控制监督者模式对物理内存的访问权限
// 0xf 的二进制为 1111，通常表示该 PMP 区域允许读、写、执行权限
// 并采用 NAPOT（Naturally Aligned Power-Of-Two）地址匹配模式
w_pmpcfg0(0xf); 

// ask for clock interrupts.
timerinit(); // 初始化定时器中断，设置定时器中断使能和相关配置

// keep each CPU's hartid in its tp register, for cpuid().
int id = r_mhartid(); // 获得当前允许cpu id
w_tp(id); // 将当前 CPU 的 hartid（硬件线程编号）写入 tp（线程指针）寄存器，
// 这样可以在多核环境下区分和管理不同的 CPU 核心，实现高效的调度和资源分配

// switch to supervisor mode and jump to main().
asm volatile("mret"); // 执行 mret 指令，切换到监督者模式，并跳转到 main 函数开始执行

// kernel/main.c

// 1. 打开硬件支持的 paging 策略
// 但是对于内核而言, 使用的策略是虚拟地址直接映射到相同的物理地址
// 通过 w_satp(MAKE_SATP(kernel_pagetable))
kvminithart();
// 2. 装载中断处理函数指针, 内核态的中断处理程序设置为 kernelvec
trapinithart();
// 3. 打开对外部中断的响应
plicinithart();

consoleinit(); // 初始化串口终端
printfinit(); // 初始化打印
printf("\n");
printf("xv6 kernel is booting\n");
printf("\n");
kinit();         // physical page allocator 初始化物理内存分页
kvminit();       // create kernel page table 创建内核分页表
kvminithart();   // turn on paging 开启分页
procinit();      // process table 进程表
trapinit();      // trap vectors 内核级中断向量
trapinithart();  // install kernel trap vector 设置内核中断处理向量
plicinit();      // set up interrupt controller 设置中断控制器
plicinithart();  // ask PLIC for device interrupts 启用 PLIC 设备中断
binit();         // buffer cache 缓冲区缓存
iinit();         // inode table 索引节点表
fileinit();      // file table 文件表
virtio_disk_init(); // emulated hard disk 虚拟硬盘
userinit();      // first user process 第一个用户进程
__sync_synchronize(); // 设置内存屏障
started = 1;

// Set up first user process.
void
userinit(void)
{
                struct proc *p;

                p = allocproc(); // 创建第一个进程
                initproc = p;

                // allocate one user page and copy initcode's instructions
                // and data into it.
                // 分配一页用户内存，并将 initcode 的指令和数据复制到这页内存中
                uvmfirst(p->pagetable, initcode, sizeof(initcode));
                p->sz = PGSIZE; // 设置进程的内存大小为一页（PGSIZE）

                // prepare for the very first "return" from kernel to user.
                // 为进程的第一次从内核态“返回”到用户态做准备

                // 设置用户程序计数器（epc）为 0，表示用户程序将从虚拟地址 0 开始执行
                // 对于初始进程，这通常对应 initcode 的入口地址。
                p->trapframe->epc = 0;      // user program counter
                // 设置用户栈指针（sp）为一页的顶部（PGSIZE），即用户栈从虚拟地址 0 到 PGSIZE，栈顶在 PGSIZE 处
                p->trapframe->sp = PGSIZE;  // user stack pointer

                // 将字符串 "initcode" 安全地复制到进程结构体 p 的 name 字段中，最多复制 sizeof(p->name) 个字节
                safestrcpy(p->name, "initcode", sizeof(p->name)); 
                p->cwd = namei("/"); // 进程 p 设置当前工作目录（cwd）为根目录

                p->state = RUNNABLE; // 设置初始进程为可执行

                release(&p->lock); // 释放初始进程的锁
}

# Initial process that execs /init.
# This code runs in user space.

#include "syscall.h"

# exec(init, argv)
.globl start
start:
        la a0, init
        la a1, argv
        li a7, SYS_exec
        ecall

# for(;;) exit();
exit:
        li a7, SYS_exit
        ecall
        jal exit

# char init[] = "/init\0";
init:
  .string "/init\0"

# char *argv[] = { init, 0 };
.p2align 2
argv:
  .quad init
  .quad 0

// init: The initial user-level program

#include "kernel/types.h"
#include "kernel/stat.h"
#include "kernel/spinlock.h"
#include "kernel/sleeplock.h"
#include "kernel/fs.h"
#include "kernel/file.h"
#include "user/user.h"
#include "kernel/fcntl.h"

char *argv[] = { "sh", 0 };

int
main(void)
{
  int pid, wpid;

  if(open("console", O_RDWR) < 0){
    mknod("console", CONSOLE, 0);
    open("console", O_RDWR);
  }
  dup(0);  // stdout
  dup(0);  // stderr

  for(;;){
    printf("init: starting sh\n");
    pid = fork();
    if(pid < 0){
      printf("init: fork failed\n");
      exit(1);
    }
    if(pid == 0){
      exec("sh", argv);
      printf("init: exec sh failed\n");
      exit(1);
    }

    for(;;){
      // this call to wait() returns if the shell exits,
      // or if a parentless process exits.
      wpid = wait((int *) 0);
      if(wpid == pid){
        // the shell exited; restart it.
        break;
      } else if(wpid < 0){
        printf("init: wait returned an error\n");
        exit(1);
      } else {
        // it was a parentless process; do nothing.
      }
    }
  }
}