M3: 进程与处理机调度

struct task_struct {
    // === 进程状态 ===
    volatile long state;          // 进程状态 (TASK_RUNNING, TASK_INTERRUPTIBLE, ...)
    unsigned int flags;           // 进程标志 (PF_EXITING, PF_FORKNOEXEC, ...)
    
    // === 调度信息 ===
    int prio;                     // 动态优先级
    int static_prio;              // 静态优先级 (由 nice 值决定)
    int normal_prio;              // 归一化优先级
    unsigned int rt_priority;     // 实时优先级 (0-99)
    const struct sched_class *sched_class;  // 调度类
    struct sched_entity se;       // CFS 调度实体
    struct sched_rt_entity rt;    // 实时调度实体
    struct sched_dl_entity dl;    // Deadline 调度实体
    
    // === 进程关系 ===
    struct task_struct *parent;   // 父进程
    struct list_head children;    // 子进程链表
    struct list_head sibling;     // 兄弟进程链表
    struct task_struct *group_leader;  // 线程组 leader
    
    // === 进程标识 ===
    pid_t pid;                    // 进程 ID
    pid_t tgid;                   // 线程组 ID (主线程 PID)
    
    // === 内存管理 ===
    struct mm_struct *mm;         // 用户地址空间描述符
    struct mm_struct *active_mm;  // 当前活动地址空间
    
    // === 文件系统 ===
    struct fs_struct *fs;         // 文件系统信息 (cwd, root)
    struct files_struct *files;   // 打开文件描述符表
    
    // === 信号处理 ===
    struct signal_struct *signal; // 信号描述符
    struct sighand_struct *sighand;  // 信号处理程序
    sigset_t blocked;             // 被阻塞的信号
    
    // === 凭证 ===
    const struct cred *cred;      // 有效凭证 (uid, gid, ...)
    
    // === 命名空间 ===
    struct nsproxy *nsproxy;      // 命名空间代理
    
    // === 记账信息 ===
    u64 utime, stime;             // 用户态/内核态 CPU 时间
    u64 start_time;               // 进程启动时间
    
    // ... 更多字段
};

#define TASK_RUNNING            0x0000    // 可运行 (就绪或正在运行)
#define TASK_INTERRUPTIBLE      0x0001    // 可中断睡眠 (等待信号或资源)
#define TASK_UNINTERRUPTIBLE    0x0002    // 不可中断睡眠 (等待 I/O)
#define __TASK_STOPPED          0x0004    // 停止 (SIGSTOP)
#define __TASK_TRACED           0x0008    // 被调试器跟踪
#define EXIT_DEAD               0x0010    // 最终状态
#define EXIT_ZOMBIE             0x0020    // 僵尸态
#define TASK_PARKED             0x0040    // 内核线程挂起
#define TASK_IDLE               0x0402    // 空闲

struct sched_entity {
    struct load_weight load;      // 负载权重
    struct rb_node run_node;      // 红黑树节点
    unsigned int on_rq;           // 是否在运行队列
    u64 exec_start;               // 当前执行开始时间
    u64 sum_exec_runtime;         // 总执行时间
    u64 vruntime;                 // 虚拟运行时间 (CFS 核心!)
    u64 prev_sum_exec_runtime;    // 上次调度周期的总执行时间
    // ...
};

pid_t pid = fork();
if (pid == 0) {
    // 子进程
    printf("I am child, PID = %d\n", getpid());
} else if (pid > 0) {
    // 父进程
    printf("I am parent, child PID = %d\n", pid);
} else {
    // fork 失败
    perror("fork");
}

while (true) {
    conn = accept(listen_fd);  // 阻塞等待连接
    request = read(conn);       // 阻塞读取请求
    response = process(request);
    write(conn, response);      // 阻塞写入响应
    close(conn);
}
// 问题: 一次只能服务一个客户端

void *handle_client(void *arg) {
    int conn = *(int *)arg;
    request = read(conn);
    response = process(request);
    write(conn, response);
    close(conn);
    return NULL;
}

while (true) {
    conn = accept(listen_fd);
    pthread_create(&tid, NULL, handle_client, &conn);
    pthread_detach(tid);  // 线程结束后自动清理
}
// 优点: 并发处理多个客户端
// 缺点: 线程创建开销, 大量连接时线程数爆炸

#define POOL_SIZE 100
pthread_t workers[POOL_SIZE];
queue_t task_queue;

void *worker_thread(void *arg) {
    while (true) {
        conn = queue_pop(&task_queue);  // 阻塞等待任务
        request = read(conn);
        response = process(request);
        write(conn, response);
        close(conn);
    }
}

int main() {
    // 预创建线程池
    for (int i = 0; i < POOL_SIZE; i++)
        pthread_create(&workers[i], NULL, worker_thread, NULL);
    
    while (true) {
        conn = accept(listen_fd);
        queue_push(&task_queue, conn);  // 放入任务队列
    }
}
// 优点: 线程复用, 控制并发度

// P 操作原语伪代码
void P(semaphore *s) {
    关中断();
    s->value--;
    if (s->value < 0) {
        将当前进程加入等待队列;
        阻塞当前进程;
    }
    开中断();
}

// 不可再入: 使用静态变量
char *strtok(char *str, const char *delim) {
    static char *last;  // 静态变量, 多线程不安全
    // ...
}

// 可再入版本: 由调用者管理状态
char *strtok_r(char *str, const char *delim, char **saveptr) {
    // saveptr 由调用者提供, 线程安全
    // ...
}

// 判断是否同一进程的线程
bool same_thread_group(struct task_struct *p1, struct task_struct *p2) {
    return p1->tgid == p2->tgid;
}

#include <pthread.h>

// 线程属性
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
pthread_attr_setstacksize(&attr, 2 * 1024 * 1024);  // 2MB 栈

// 创建线程
pthread_t tid;
int *arg = malloc(sizeof(int));
*arg = 42;
pthread_create(&tid, &attr, thread_func, arg);

// 等待线程结束
void *retval;
pthread_join(tid, &retval);

// 线程函数
void *thread_func(void *arg) {
    int value = *(int *)arg;
    // ... 处理
    return NULL;
}

// 创建进程: fork()
clone(SIGCHLD);  // 不共享任何资源

// 创建线程: pthread_create()
clone(CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | 
      CLONE_THREAD | CLONE_SYSVSEM | SIGCHLD);

vruntime += delta_exec × (NICE_0_LOAD / weight)

其中:
- delta_exec: 实际执行时间 (纳秒)
- weight: 进程当前权重

1. 从所有 eligible 进程中选择
2. 选择 Virtual Deadline 最早的进程
3. 如果无 eligible 进程, 选择 lag 最大者

# Linux 6.6+ 默认启用 EEVDF
# 查看当前调度器
cat /sys/kernel/debug/sched/features

# 相关 sysctl
sysctl kernel.sched_min_granularity_ns

### 6.4 nice 值与权重

```c
// kernel/sched/core.c
const int sched_prio_to_weight[40] = {
    /* -20 */ 88761, 71755, 56483, 46273, 36291,
    /* -15 */ 29154, 23254, 18705, 14949, 11916,
    /* -10 */ 9548, 7620, 6100, 4904, 3906,
    /*  -5 */ 3121, 2501, 1991, 1586, 1277,
    /*   0 */ 1024, 820,  655,  526,  423,  // nice 0 = 1024
    /*   5 */ 335,  272,  215,  172,  137,
    /*  10 */ 110,  87,   70,   56,   45,
    /*  15 */ 36,   29,   23,   18,   15,   // nice 19
};

// kernel/sched/fair.c

// 选择下一个进程
static struct task_struct *pick_next_task_fair(struct rq *rq, ...) {
    struct cfs_rq *cfs_rq = &rq->cfs;
    struct sched_entity *se;
    
    // 如果没有可运行任务, 返回 NULL
    if (!cfs_rq->nr_running)
        return NULL;
    
    // 选择 vruntime 最小的实体 (红黑树最左节点)
    se = pick_next_entity(cfs_rq, NULL);
    
    return task_of(se);
}

// 更新 vruntime
static void update_curr(struct cfs_rq *cfs_rq) {
    struct sched_entity *curr = cfs_rq->curr;
    u64 now = rq_clock_task(rq_of(cfs_rq));
    u64 delta_exec;
    
    delta_exec = now - curr->exec_start;
    curr->exec_start = now;
    curr->sum_exec_runtime += delta_exec;
    
    // 计算加权后的 vruntime 增量
    curr->vruntime += calc_delta_fair(delta_exec, curr);
    
    // 更新 cfs_rq 的 min_vruntime
    update_min_vruntime(cfs_rq);
}

// 调度周期 (所有进程至少运行一次的时间)
sched_latency_ns = 6ms (少于 8 个进程)
sched_latency_ns = nr_running × 0.75ms (多进程时)

// 最小运行时间粒度
sched_min_granularity_ns = 0.75ms

struct sched_attr attr = {
    .size = sizeof(attr),
    .sched_policy = SCHED_DEADLINE,
    .sched_runtime  = 10000000,  // 10ms 执行时间
    .sched_deadline = 30000000,  // 30ms 截止时间
    .sched_period   = 30000000,  // 30ms 周期
};
sched_setattr(pid, &attr, 0);

# 创建 cgroup
mkdir /sys/fs/cgroup/mygroup

# 限制 CPU 带宽 (每 100ms 最多使用 50ms)
echo "50000 100000" > /sys/fs/cgroup/mygroup/cpu.max

# 设置 CPU 权重 (相对于其他 cgroup)
echo 100 > /sys/fs/cgroup/mygroup/cpu.weight

# 将进程加入 cgroup
echo $PID > /sys/fs/cgroup/mygroup/cgroup.procs

$MAX $PERIOD

示例:
50000 100000  → 每 100ms 可使用 50ms (50%)
max 100000    → 无限制

# 查看进程状态
cat /proc/$PID/status

# 关键字段
State: S (sleeping)
Pid:   12345
PPid:  1234
Threads: 4
VmPeak: 1234 kB    # 虚拟内存峰值
VmRSS:  567 kB     # 常驻内存
voluntary_ctxt_switches:   100
nonvoluntary_ctxt_switches: 50

# 查看进程调度策略和优先级
chrt -p $PID

# 设置实时优先级
chrt -f -p 50 $PID    # SCHED_FIFO, 优先级 50
chrt -r -p 50 $PID    # SCHED_RR, 优先级 50

# 设置 nice 值
nice -n 10 ./myprogram
renice -n -5 -p $PID

┌─────────────────────────────────────────────────────────────────────────┐
│  优点: 零拷贝, 速度最快                                                  │
│  缺点: 需要同步机制 (互斥锁/信号量) 保护                                  │
└─────────────────────────────────────────────────────────────────────────┘

#include <signal.h>

void handler(int sig) {
    // 只能调用 async-signal-safe 函数
    write(STDOUT_FILENO, "caught\n", 7);
}

int main() {
    struct sigaction sa = {
        .sa_handler = handler,
        .sa_flags = SA_RESTART,
    };
    sigemptyset(&sa.sa_mask);
    sigaction(SIGINT, &sa, NULL);
    // ...
}

┌─────────────────────────────────────────────────────────────────────────┐
│                       上下文切换完整流程                                  │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  1. 保存当前进程上下文                                                   │
│     ┌──────────────────────────────────────────────────────────────┐    │
│     │  保存 CPU 寄存器 (通用寄存器, PC, SP, 标志位) 到 task_struct  │    │
│     └──────────────────────────────────────────────────────────────┘    │
│                                 ↓                                       │
│  2. 更新调度数据结构                                                     │
│     ┌──────────────────────────────────────────────────────────────┐    │
│     │  更新当前进程的 vruntime, 将其放回运行队列                       │    │
│     │  从运行队列选择下一个进程                                        │    │
│     └──────────────────────────────────────────────────────────────┘    │
│                                 ↓                                       │
│  3. 切换地址空间 (如果跨进程)                                            │
│     ┌──────────────────────────────────────────────────────────────┐    │
│     │  加载新进程的页表基地址 (CR3 寄存器)                             │    │
│     │  TLB 失效 → 大量 TLB Miss                                        │    │
│     └──────────────────────────────────────────────────────────────┘    │
│                                 ↓                                       │
│  4. 恢复新进程上下文                                                     │
│     ┌──────────────────────────────────────────────────────────────┐    │
│     │  从 task_struct 恢复寄存器, 跳转到 PC 执行                       │    │
│     └──────────────────────────────────────────────────────────────┘    │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

# 观察上下文切换
pidstat -w 1
# cswch/s: 自愿切换 (I/O 等待)
# nvcswch/s: 非自愿切换 (时间片耗尽)

# v2 配置示例
mkdir /sys/fs/cgroup/mygroup

# 启用控制器
echo "+cpu +memory" > /sys/fs/cgroup/cgroup.subtree_control

# 设置 CPU 配额: 100ms 周期内最多使用 20ms (20%)
echo "20000 100000" > /sys/fs/cgroup/mygroup/cpu.max

# 将进程加入组
echo $$ > /sys/fs/cgroup/mygroup/cgroup.procs

# 1. 基础负载
uptime                    # Load Average
dmesg -T | tail -n 50     # 内核错误/OOM

# 2. CPU 分布
vmstat 1                  # r(运行队列), b(等待I/O)
mpstat -P ALL 1           # 各 CPU 核心状态

# 3. 进程分析
pidstat 1                 # 各进程 CPU/内存
top -1                    # 按 CPU 排序

# 4. I/O 状态
iostat -xz 1              # %util, await
iotop                     # 进程级 I/O

# 5. 内存状态
free -h                   # 内存/Swap
cat /proc/meminfo | grep -E "Dirty|Writeback"

# 6. 网络状态
sar -n DEV 1              # 网卡吞吐
ss -s                     # Socket 统计

# CPU 压力 (仅 some)
cat /proc/pressure/cpu
# some avg10=0.00 avg60=0.00 avg300=0.00 total=12345

# 内存压力
cat /proc/pressure/memory
# some avg10=0.50 avg60=0.30 avg300=0.10 total=67890
# full avg10=0.00 avg60=0.00 avg300=0.00 total=1234

# I/O 压力
cat /proc/pressure/io
# some avg10=2.50 avg60=1.20 avg300=0.80 total=98765
# full avg10=0.10 avg60=0.05 avg300=0.02 total=5678

# 查看特定 cgroup 的压力
cat /sys/fs/cgroup/mygroup/cpu.pressure
cat /sys/fs/cgroup/mygroup/memory.pressure
cat /sys/fs/cgroup/mygroup/io.pressure

# 查找僵尸进程
ps aux | grep 'Z'
ps -eo stat,ppid,pid,cmd | grep '^Z'

# 统计数量
ps aux | awk '{if($8=="Z") print}' | wc -l

// 经典守护进程创建步骤
void daemonize() {
    // 1. 第一次 fork, 父进程退出
    if (fork() > 0) exit(0);
    
    // 2. 创建新会话, 脱离控制终端
    setsid();
    
    // 3. 第二次 fork, 确保不会重新获取终端
    if (fork() > 0) exit(0);
    
    // 4. 更改工作目录
    chdir("/");
    
    // 5. 重设文件权限掩码
    umask(0);
    
    // 6. 关闭继承的文件描述符
    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);
    
    // 7. 重定向标准流到 /dev/null
    open("/dev/null", O_RDONLY);  // stdin
    open("/dev/null", O_WRONLY);  // stdout
    open("/dev/null", O_WRONLY);  // stderr
}

# 查看内核线程 (方括号表示)
ps aux | grep '\[.*\]'
# [kswapd0]  - 内存回收
# [ksoftirqd/0] - 软中断处理
# [migration/0] - CPU 迁移