task_struct 核心字段（简化）：

进程身份：
  pid_t pid;           // 进程 ID，唯一标识
  pid_t ppid;          // 父进程 ID
  char name[16];       // 进程名

状态：
  volatile long state; // 进程状态（R/T/S/Z）
  unsigned int flags; // 进程标志

调度相关：
  int static_prio;    // 静态优先级
  int dynamic_prio;   // 动态优先级
  unsigned int weight;// 调度权重（cfs_rq 用）
  struct sched_entity se;  // 调度实体（红黑树节点）

内存：
  struct mm_struct *mm;   // 内存描述符（虚拟地址空间）
  unsigned long rss;      // 物理内存占用

文件：
  struct files_struct *files;  // 打开的文件描述符表

时间：
  unsigned long start_time;    // 进程启动时间
  unsigned long utime;         // 用户态时间（jiffies）
  unsigned long stime;         // 内核态时间（jiffies）

线程：
  struct thread_struct thread; // CPU 寄存器上下文（栈、IP 等）

fork 的本质：

父进程调用 fork()
    ↓
内核做三件事：
    1. 分配一个新的 task_struct
    2. 复制父进程的地址空间（COW，Copy-On-Write）
    3. 把新进程加入调度器
    ↓
返回：在父进程里返回子进程 PID，在子进程里返回 0

结果：两个几乎完全相同的进程在跑，只是返回值不同

// Linux fork 核心函数（简化版）
// 源码：kernel/fork.c

int do_fork(unsigned long clone_flags,
            unsigned long stack_start,
            struct pt_regs *regs,
            unsigned long stack_size) {
    // Step 1: 分配 task_struct（copy_process）
    struct task_struct *p = copy_process(clone_flags,
                                          stack_start,
                                          regs,
                                          stack_size);

    // Step 2: 分配 PID
    p->pid = alloc_pid();

    // Step 3: 分配内核栈（每个进程独立的栈）
    p->stack = alloc_stack();

    // Step 4: 初始化调度实体
    sched_cgroup_fork(p);
    sched_fork(p);

    // Step 5: 加入调度器（把 task_struct 加入红黑树）
    wake_up_new_task(p);

    // Step 6: 返回
    return p->pid;
}

struct task_struct *copy_process(unsigned long clone_flags, ...) {
    // 分配新的 task_struct（用 SLAB 分配器）
    struct task_struct *p = alloc_task_struct();

    // 复制父进程的 mm（地址空间）
    if (!(clone_flags & CLONE_VM)) {
        // 不是线程（线程共享父的 mm）
        p->mm = dup_mm(current->mm);  // COW 复制
    }

    // 复制文件描述符表（线程共享）
    if (clone_flags & CLONE_FILES) {
        atomic_inc(&current->files->count);
        p->files = current->files;
    } else {
        p->files = dup_fd(current->files);
    }

    // 复制信号处理（线程共享）
    if (clone_flags & CLONE_SIGHAND) {
        atomic_inc(&current->sighand->count);
    } else {
        p->sighand = dup_sighand(current->sighand);
    }

    // 复制命名空间（CLONE_NEWNS 等）
    ...

    // 设置返回值（fork 在子进程返回 0）
    p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ?
                        child_tidptr : NULL;
    clear_tsk_thread_flag(p, TIF_NOTIFY_RESUME);

    // 关键：fork 返回值在两个地方不同
    // 子进程：p->thread.rax = 0
    // 父进程：do_fork 返回子 PID（通过寄存器带回去）
    p->thread.rax = 0;

    return p;
}

COW (Copy-On-Write) 原理：

fork 时：
  → 父子进程共享同一个物理页，标记为只读
  → 任何一个进程尝试写入 → 触发 #PF
  → PF handler 发现是 COW 页 → 分配新物理页，复制内容，更新 PTE
  → 两个进程各有自己的物理页，写入互不干扰

结果：fork 本身只复制页表（4KB），不复制任何物理页
      只有在实际写入时才复制，速度极快

exec 的本质：
  → 用新程序替换当前进程的地址空间
  → PID 不变（还是同一个进程）
  → 代码段、数据段、堆栈全部重新初始化
  → 从新程序的 main() 开始执行

// exec 系统调用（简化版）
int sys_execve(const char *filename,
               char *const argv[],
               char *const envp[]) {
    struct linux_binprm bprm;

    // Step 1: 读取可执行文件头部（检测格式：ELF/binary/script）
    bprm.file = open_exec(filename);

    // Step 2: 检查权限（CAP_SETPCAP 等）
    // Step 3: 搜索解释器（#! 脚本的 /bin/sh）
    search_binary_handler(&bprm);

    return 0;
}

// ELF 加载器（search_binary_handler 的其中一种 handler）
int load_elf_binary(struct linux_binprm *bprm) {
    // 读取 ELF header
    struct elfhdr *elf = bprm->buf;

    // 映射段（代码段、数据段）
    for (i = 0; i < elf->e_phnum; i++) {
        if (elf->phdr[i].p_type == PT_LOAD) {
            // 建立虚拟地址到物理文件的映射（mmap）
            elf_map(bprm->file, elf->phdr[i].p_vaddr,
                    elf->phdr[i].p_filesz,
                    elf->phdr[i].p_offset);
        }
    }

    // 设置 entry point
    current->mm->start_code = elf->e_entry;

    // 初始化栈（压入 argc, argv, envp）
    create_elf_tables(bprm);

    // 设置 EIP 到入口点
    // 下次调度到这个进程时，从 entry 开始执行
    start_thread(regs, elf->e_entry, ...);

    return 0;
}

CFS 原理：

每个进程有一个"vruntime"（虚拟运行时间）
  → 进程跑 1ms，vruntime += 1 * ( NICE_0_LOAD / 进程权重 )
  → 高优先级进程：权重更大 → 同样的墙上时间 → vruntime 增长更慢
  → 所以高优先级进程的 vruntime 总是更小 → 更容易被调度到

调度器总是选红黑树最左边的节点（最小 vruntime）执行

调度周期 = 所有可运行进程各跑一个"最小时间片"的总和
  → 如果有 10 个进程，调度周期 = 10 × min_timeslice
  → CFS 保证在这个周期内，每个进程都至少被调度一次（"完全公平"）

// CFS 调度实体（红黑树节点）
struct sched_entity {
    unsigned long vruntime;         // 虚拟运行时间（排序 key）
    unsigned long sum_exec_runtime; // 累计实际运行时间
    unsigned long prev_runtime;    // 上次调度时的 vruntime（恢复时用）

    struct rb_node run_node;       // 红黑树节点
    struct list_head group_node;    // 组调度用

    unsigned int on_rq;            // 是否在就绪队列上
};

// CFS 选下一个进程
struct task_struct *pick_next_task_fair(struct rq *rq) {
    struct sched_entity *se = __pick_next_entity(cfs_rq);
    return container_of(se, struct task_struct, se);
}

// 红黑树插入（CFS enqueue）
void enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se) {
    // 更新 vruntime
    se->vruntime += calc_delta_fair(se->load.weight);

    // 按 vruntime 插入红黑树
    __enqueue_entity(cfs_rq, se);

    // 设置 on_rq 标志
    se->on_rq = 1;
}

触发调度的时机：

1. 进程主动放弃 CPU：
   - 等待 I/O（进入阻塞状态）→ schedule()
   - 等待信号 → schedule()

2. 时间片用完：
   - 时钟中断（scheduler_tick）发现当前进程时间片耗尽
   - 设置 TIF_NEED_RESCHED 标志
   - 中断返回时检查此标志，触发 schedule()

3. 新进程加入就绪队列：
   - 高优先级进程就绪
   - wake_up_new_task → 如果新进程比当前进程更该跑，立即调度

4. 调度器被显式调用：
   - schedule() 被直接调用（wait_event, mutex_lock 等）

// Linux schedule()（简化版）
void schedule(void) {
    struct task_struct *prev = current;
    struct task_struct *next;

    // 关闭内核抢占（保护调度过程）
    raw_spin_lock(&rq->lock);

    // 清除当前进程的就绪标志
    prev->on_rq = 0;

    // 更新运行队列
    update_rq_clock(rq);

    // 切换调度策略
    switch (prev->state) {
        case TASK_RUNNING:
            // 主动让出（时间片耗尽），重新加入红黑树
            enqueue_task(prev);
            break;
        case TASK_INTERRUPTIBLE:
        case TASK_UNINTERRUPTIBLE:
            // 阻塞，不加入就绪队列
            break;
    }

    // pick_next_task：选 vruntime 最小的进程
    next = pick_next_task(rq, prev);

    // 切换上下文
    switch_mm(prev->mm, next->mm);
    switch_to(prev, next);   // 关键：这里做寄存器切换

    // 后续：next 继续从上次断点执行
}

# 查看当前进程的详细信息
cat /proc/self/status

# 查看进程运行时间
cat /proc/$$/stat

# 观察进程的调度信息
chrt -p $$     # 查看当前进程调度策略
chrt -f 10 -p $$  # 设为 FIFO 策略，优先级 10

# 观察进程的父子关系
pstree -p $$

# 用 top 观察调度
top -n 1
# NI 列 = Nice 值（影响优先级）
# PR 列 = 调度优先级（RT = 实时）
# S 列 = 状态（R=运行，S=睡眠，Z=僵尸）

# 实时观察进程切换（每 1 秒打印运行中的进程）
vmstat 1

# 观察 CFS 红黑树状态（需要 root）
cat /proc/sched_debug

# 查看某个进程的调度延迟
perf sched record -a sleep 5
perf sched latency

// wandos 进程控制块（PCB）
// 源码：kernel/process/process.cpp

struct process_control_block {
    uint32_t pid;                      // 进程 ID
    char name[64];                      // 进程名

    enum process_state state;            // NEW/RUNNING/BLOCKED/EXIT
    uint32_t priority;                  // 优先级（0=最高）

    // 寄存器上下文（调度时保存/恢复）
    uint64_t rip;                       // Instruction pointer
    uint64_t rsp;                       // Stack pointer
    uint64_t rax, rbx, rcx, rdx;        // 通用寄存器
    uint64_t rsi, rdi, rbp;
    uint64_t r8, r9, r10, r11, r12, r13, r14, r15;
    uint64_t rflags;
    uint64_t cs, ss;

    // 内存管理
    void *page_table;                   // CR3 的值（页表指针）
    uint64_t memory_base;               // 进程基址
    uint64_t memory_size;               // 进程内存大小

    // 文件描述符表
    struct file *fd_table[64];           // 最多 64 个 fd

    // 时间统计
    uint64_t cpu_time_used;             // 已用 CPU 时间
    uint64_t last_scheduled;            // 上次调度时间
};

static struct process_control_block processes[MAX_PROCESSES];
static struct process_control_block *current_process = NULL;
static uint32_t next_pid = 1;

// wandos fork（简化版）
uint32_t process_fork(void) {
    // 找空闲 PCB
    int pid = -1;
    for (int i = 0; i < MAX_PROCESSES; i++) {
        if (processes[i].state == NONE) {
            pid = i;
            break;
        }
    }
    if (pid < 0) return -1;  // 没有空槽

    // 复制当前进程 PCB
    struct process_control_block *child = &processes[pid];
    *child = *current_process;  // 浅拷贝

    // 分配新 PID
    child->pid = next_pid++;

    // 复制页表（COW）
    child->page_table = copy_page_table(current_process->page_table);

    // 分配新内核栈
    child->rsp = alloc_stack();

    // 关键：fork 在子进程返回 0
    child->rax = 0;

    // 加入就绪队列
    scheduler_add_runnable(child);

    return child->pid;  // 父进程返回子 PID
}

// wandos 调度器
void scheduler(void) {
    while (1) {
        // 找最高优先级就绪进程
        struct process_control_block *next = NULL;
        uint32_t best_priority = 0xFFFFFFFF;

        for (int i = 0; i < MAX_PROCESSES; i++) {
            if (processes[i].state == RUNNING &&
                processes[i].priority < best_priority) {
                next = &processes[i];
                best_priority = processes[i].priority;
            }
        }

        if (next == NULL) {
            // 没有就绪进程，执行 idle
            cpu_idle();
            continue;
        }

        // 切换到选中的进程
        switch_to(current_process, next);
    }
}