StarryOS 宏内核启动流程分析

#[unsafe(no_mangle)]
fn main() {
    starry_api::init();  // ← 初始化所有子系统

    let args = CMDLINE
        .iter()
        .copied()
        .map(str::to_owned)
        .collect::<Vec<_>>();
    let envs = [];
    let exit_code = entry::run_initproc(&args, &envs);
    info!("Init process exited with code: {exit_code:?}");

    // 系统关闭时清理
    let cx = FS_CONTEXT.lock();
    cx.root_dir()
        .unmount_all()
        .expect("Failed to unmount all filesystems");
    cx.root_dir()
        .filesystem()
        .flush()
        .expect("Failed to flush rootfs");
}

pub const CMDLINE: &[&str] = &["/bin/sh", "-c", include_str!("init.sh")];

pub fn init() {
    info!("Initialize VFS...");
    vfs::mount_all().expect("Failed to mount vfs");
    // ...
}

pub fn mount_all() -> LinuxResult<()> {
    let fs = FS_CONTEXT.lock();
    
    // 1. 设备文件系统 - /dev
    mount_at(&fs, "/dev", dev::new_devfs())?;
    
    // 2. 共享内存文件系统 - /dev/shm
    mount_at(&fs, "/dev/shm", tmp::MemoryFs::new())?;
    
    // 3. 临时文件系统 - /tmp
    mount_at(&fs, "/tmp", tmp::MemoryFs::new())?;
    
    // 4. proc 文件系统 - /proc
    mount_at(&fs, "/proc", proc::new_procfs())?;
    
    // 5. sys 文件系统 - /sys
    mount_at(&fs, "/sys", tmp::MemoryFs::new())?;
    
    // 6. 创建符号链接 /sys/class/graphics/fb0/device/subsystem
    // ...
    
    // 7. 可选: /dev/log 设备日志绑定
    #[cfg(feature = "dev-log")]
    dev::bind_dev_log().expect("Failed to bind /dev/log");

    Ok(())
}

info!("Initialize /proc/interrupts...");
axtask::register_timer_callback(|_| {
    time::inc_irq_cnt();
});

info!("Initialize alarm...");
starry_core::time::spawn_alarm_task();

let mut uspace = new_user_aspace_empty()
    .and_then(|mut it| {
        copy_from_kernel(&mut it)?;
        Ok(it)
    })
    .expect("Failed to create user address space");

let loc = FS_CONTEXT
    .lock()
    .resolve(&args[0])  // "/bin/sh"
    .expect("Failed to resolve executable path");
let path = loc
    .absolute_path()
    .expect("Failed to get executable absolute path");
let name = loc.name();

let (entry_vaddr, ustack_top) = load_user_app(&mut uspace, None, args, envs)
    .unwrap_or_else(|e| panic!("Failed to load user app: {}", e));

let uctx = UserContext::new(entry_vaddr.into(), ustack_top, 0);

let mut task = new_user_task(name, uctx, 0);
task.ctx_mut().set_page_table_root(uspace.page_table_root());

TaskInner::new(
    move || {
        let curr = axtask::current();
        
        // 设置 set_child_tid（CLONE_CHILD_SETTID）
        if let Some(tid) = (set_child_tid as *mut Pid).nullable() {
            tid.vm_write(curr.id().as_u64() as Pid).ok();
        }

        info!("Enter user space: ip={:#x}, sp={:#x}", uctx.ip(), uctx.sp());

        let thr = curr.as_thread();
        while !thr.pending_exit() {
            let reason = uctx.run();  // ← 运行用户代码
            
            set_timer_state(&curr, TimerState::Kernel);

            match reason {
                // 系统调用处理
                ReturnReason::Syscall => handle_syscall(&mut uctx),
                
                // 缺页故障处理
                ReturnReason::PageFault(addr, flags) => {
                    if !thr.proc_data.aspace.lock().handle_page_fault(addr, flags) {
                        info!("{:?}: segmentation fault at {:#x} {:?}", ...);
                        raise_signal_fatal(SignalInfo::new_kernel(Signo::SIGSEGV))
                    }
                }
                
                // 中断处理
                ReturnReason::Interrupt => {}
                
                // 异常处理
                ReturnReason::Exception(exc_info) => {
                    // 处理对齐、断点、非法指令等异常
                }
                
                r => {
                    warn!("Unexpected return reason: {r:?}");
                    raise_signal_fatal(SignalInfo::new_kernel(Signo::SIGSEGV))
                }
            }

            // 解除阻塞的信号并处理
            if !unblock_next_signal() {
                while check_signals(thr, &mut uctx, None) {}
            }

            set_timer_state(&curr, TimerState::User);
            curr.clear_interrupt();
        }
    },
    name.into(),
    starry_core::config::KERNEL_STACK_SIZE,
)

let pid = task.id().as_u64() as Pid;
let proc = Process::new_init(pid);  // 创建 PID=1 的进程
proc.add_thread(pid);                // 添加主线程

N_TTY.bind_to(&proc).expect("Failed to bind ntty");  // 绑定终端

let proc_data = ProcessData::new(
    proc,
    path.to_string(),
    Arc::new(args.to_vec()),
    Arc::new(Mutex::new(uspace)),  // 地址空间
    Arc::default(),                 // 共享内存段
    None,                           // 父进程
);

{
    let mut scope = proc_data.scope.write();
    starry_api::file::add_stdio(&mut FD_TABLE.scope_mut(&mut scope).write())
        .expect("Failed to add stdio");  // 添加标准输入/输出/错误
}

let thr = Thread::new(pid, proc_data);

*task.task_ext_mut() = Some(unsafe { AxTaskExt::from_impl(thr) });

let task = spawn_task(task);     // 将任务添加到调度器
add_task_to_table(&task);        // 添加到全局任务表

// 等待进程完成
task.join()

pub struct ProcessData {
    pub proc: Process,                              // 进程对象
    pub path: String,                               // 程序路径
    pub args: Arc<Vec<String>>,                     // 命令行参数
    pub aspace: Arc<Mutex<UserAddressSpace>>,       // 用户地址空间
    pub shared_mems: Arc<SharedMemSegmentMap>,      // 共享内存段
    pub parent: Option<Pid>,                        // 父进程 PID
    pub scope: RwLock<FdTableScope>,                // 文件描述符表作用域
}

pub struct Thread {
    pub proc_data: Arc<ProcessData>,                // 进程数据
    pub pending_exit: Arc<AtomicBool>,              // 退出标志
    pub waiting_tasks: Arc<Vec<TaskId>>,            // 等待的子任务
    pub robust_list: Option<RobustList>,            // 健壮互斥体列表
    pub tls: *mut u8,                               // 线程本地存储
}