第1章：Linux 内核概述与发展史

用户空间 (Ring 3)
    |
    | 系统调用接口 (syscall)
    v
+--------------------------------------------------+
|                Linux 内核 (Ring 0)              |
|                                                  |
| +------------+  +------------+  +-------------+ |
| | 进程管理   |  | 内存管理   |  | 文件系统    | |
| +------------+  +------------+  +-------------+ |
| +------------+  +------------+  +-------------+ |
| | 网络协议栈 |  | 设备驱动   |  | IPC机制     | |
| +------------+  +------------+  +-------------+ |
|                                                  |

+--------------------------------------------------+
                        |
                    硬件抽象层
                        |
                    物理硬件

0xFFFFFFFFFFFFFFFF ┬─────────────────┬
                   │                 │
                   │   内核空间       │ 128TB (高端地址)
                   │                 │
0xFFFF800000000000 ├─────────────────┤ ← 内核/用户分界线
                   │                 │
                   │     未使用      │
                   │                 │
0x00007FFFFFFFFFFF ├─────────────────┤
                   │                 │
                   │   用户空间       │ 128TB (低端地址)
                   │                 │
0x0000000000000000 └─────────────────┘

// 典型的内核模块结构
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>

static int __init my_module_init(void)
{
    printk(KERN_INFO "模块加载\\n");
    return 0;
}

static void __exit my_module_exit(void)
{
    printk(KERN_INFO "模块卸载\\n");
}

module_init(my_module_init);
module_exit(my_module_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("示例模块");

linux-0.01/
├── boot/       # 引导代码
├── fs/         # 文件系统
├── include/    # 头文件
├── init/       # 初始化
├── kernel/     # 核心功能
├── lib/        # 库函数
└── mm/         # 内存管理

// Linux 0.11 的调度核心
for(p = &LAST_TASK; p > &FIRST_TASK; --p) {
    if (*p) {
        if ((*p)->alarm && (*p)->alarm < jiffies) {
            (*p)->signal |= (1<<(SIGALRM-1));
            (*p)->alarm = 0;
        }
        if (((*p)->signal & ~(_BLOCKABLE & (*p)->blocked)) &&
            (*p)->state==TASK_INTERRUPTIBLE)
            (*p)->state=TASK_RUNNING;
    }
}

// 选择下一个任务
while (1) {
    c = -1;
    next = 0;
    i = NR_TASKS;
    p = &task[NR_TASKS];
    while (--i) {
        if (!*--p)
            continue;
        if ((*p)->state == TASK_RUNNING && (*p)->counter > c)
            c = (*p)->counter, next = i;
    }
    if (c) break;
    // 重新计算时间片
    for(p = &LAST_TASK; p > &FIRST_TASK; --p)
        if (*p)
            (*p)->counter = ((*p)->counter >> 1) + (*p)->priority;
}
switch_to(next);

// Ingo Molnar 的 O(1) 调度器核心思想
struct prio_array {
    unsigned int nr_active;
    unsigned long bitmap[BITMAP_SIZE];
    struct list_head queue[MAX_PRIO];
};

// 查找最高优先级任务 - O(1) 复杂度
idx = sched_find_first_bit(array->bitmap);
queue = array->queue + idx;
next = list_entry(queue->next, struct task_struct, run_list);

主版本发布
    ↓
rc1 → rc2 → ... → rc7 → 稳定版
 ↑                        ↓
 └──────  2-3 个月  ──────┘

1991 ━━ Linux 0.01：单 CPU、单用户
  │
1994 ━━ Linux 1.0：网络支持
  │
1996 ━━ Linux 2.0：SMP 支持
  │
2001 ━━ Linux 2.4：企业级特性
  │
2003 ━━ Linux 2.6：O(1) 调度器、内核抢占
  │
2007 ━━ CFS 调度器取代 O(1)
  │
2008 ━━ cgroups 引入
  │
2013 ━━ 容器技术兴起（Docker）
  │
2014 ━━ eBPF 合并主线
  │
2019 ━━ io_uring 引入
  │
2022 ━━ Rust 进入内核
  │
现在 ━━ 持续优化、新硬件支持

linux/
├── arch/           # 架构相关代码
├── block/          # 块设备层
├── certs/          # 证书处理
├── crypto/         # 加密算法
├── Documentation/  # 内核文档
├── drivers/        # 设备驱动（占 60%+ 代码）
├── fs/             # 文件系统
├── include/        # 头文件
├── init/           # 内核初始化
├── io_uring/       # io_uring 子系统
├── ipc/            # 进程间通信
├── kernel/         # 核心子系统
├── lib/            # 库函数
├── mm/             # 内存管理
├── net/            # 网络协议栈
├── rust/           # Rust 支持（6.1+）
├── samples/        # 示例代码
├── scripts/        # 构建脚本
├── security/       # 安全模块
├── sound/          # 音频子系统
├── tools/          # 用户空间工具
├── usr/            # initramfs 生成
└── virt/           # 虚拟化支持

arch/
├── x86/            # Intel/AMD x86 架构
│   ├── boot/       # 引导代码
│   ├── kernel/     # 架构相关核心代码
│   ├── mm/         # 架构相关内存管理
│   └── ...
├── arm64/          # ARM 64位
├── riscv/          # RISC-V
├── powerpc/        # PowerPC
└── ...             # 总计 20+ 架构

// 架构无关接口（include/linux/atomic.h）
static inline int atomic_add_return(int i, atomic_t *v);

// x86 实现（arch/x86/include/asm/atomic.h）
static inline int arch_atomic_add_return(int i, atomic_t *v)
{
    return i + xadd(&v->counter, i);
}

// ARM64 实现（arch/arm64/include/asm/atomic.h）
static inline int arch_atomic_add_return(int i, atomic_t *v)
{
    return __lse_atomic_add_return(i, v);
}

drivers/
├── acpi/           # ACPI 电源管理
├── block/          # 块设备驱动
├── char/           # 字符设备驱动
├── gpu/            # GPU 驱动
│   ├── drm/        # Direct Rendering Manager
│   └── ...
├── net/            # 网络设备驱动
│   ├── ethernet/   # 以太网驱动
│   ├── wireless/   # 无线网卡驱动
│   └── ...
├── nvme/           # NVMe SSD 驱动
├── pci/            # PCI 总线
├── usb/            # USB 子系统
└── ...             # 100+ 子目录

kernel/
├── sched/          # 调度器
│   ├── core.c      # 调度核心
│   ├── fair.c      # CFS 调度类
│   ├── rt.c        # 实时调度类
│   └── deadline.c  # Deadline 调度类
├── time/           # 时间管理
├── irq/            # 中断处理
├── locking/        # 锁机制
├── fork.c          # 进程创建
├── exit.c          # 进程退出
├── signal.c        # 信号处理
├── printk/         # 内核日志
└── ...

# drivers/char/Kconfig 示例
config DEVMEM
    bool "/dev/mem virtual device support"
    default y
    help
      Say Y here if you want to support the /dev/mem device.
      The /dev/mem device is used to access physical memory.

config DEVKMEM
    bool "/dev/kmem virtual device support"
    depends on DEVMEM
    help
      Say Y here if you want to support the /dev/kmem device.

make menuconfig  # 文本界面
make xconfig     # Qt 界面  
make gconfig     # GTK 界面

# kernel/Makefile 示例
obj-y     = fork.o exec_domain.o panic.o \\
            cpu.o exit.o softirq.o resource.o \\
            sysctl.o capability.o ptrace.o user.o

obj-$(CONFIG_MODULES) += module.o
obj-$(CONFIG_SMP) += smp.o
obj-$(CONFIG_KPROBES) += kprobes.o

# 子目录
obj-y += sched/
obj-y += time/

.config → include/generated/autoconf.h
    ↓
源文件 → .o 目标文件
    ↓
链接 → vmlinux（未压缩内核）
    ↓
压缩 → bzImage/zImage（可引导内核）

# 配置
make defconfig          # 默认配置
make oldconfig          # 基于 .config 更新
make localmodconfig     # 基于当前运行模块

# 编译
make -j$(nproc)         # 并行编译内核
make modules            # 编译模块
make bzImage            # 仅编译内核镜像

# 安装
make modules_install    # 安装模块
make install            # 安装内核

# 清理
make clean              # 清理目标文件
make mrproper           # 完全清理
make distclean          # 清理所有生成文件

# 特定目标
make M=drivers/net      # 编译特定目录
make drivers/net/       # 同上
make drivers/net/e1000/ # 编译特定驱动

# ARM64 交叉编译
make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- defconfig
make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- -j$(nproc)

# RISC-V 交叉编译
make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- defconfig
make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- -j$(nproc)

用户进程  文件服务器  网络服务器  驱动程序
   ↓         ↓          ↓          ↓
   └─────────┴──────────┴──────────┘
                   ↓ IPC
            ┌──────────────┐
            │   微内核      │ (最小化：调度、IPC、内存)
            └──────────────┘
                   ↓
               硬件层

            用户进程
                ↓ 系统调用
    ┌───────────────────────────┐
    │        单一内核            │
    │  (所有服务在内核空间)      │
    └───────────────────────────┘
                ↓
            硬件层

// 内核代码不可被抢占
spin_lock(&lock);
// 长时间操作...即使有高优先级任务也无法打断
// 可能造成几十毫秒延迟
spin_unlock(&lock);

// preempt_count 跟踪抢占状态
preempt_disable();  // preempt_count++
// 关键区域
preempt_enable();   // preempt_count--
// 如果 preempt_count == 0 且需要调度，则抢占

// 自愿抢占点
might_sleep();      // 可能睡眠，检查是否需要调度
cond_resched();     // 条件重新调度

From: torvalds@klaava.Helsinki.FI (Linus Benedict Torvalds)
Subject: What would you like to see most in minix?
Date: 25 Aug 91 20:57:08 GMT

Hello everybody out there using minix -

I'm doing a (free) operating system (just a hobby, won't be 
big and professional like gnu) for 386(486) AT clones...

// eBPF 程序示例：跟踪系统调用
SEC("tracepoint/syscalls/sys_enter_open")
int trace_open(struct trace_event_raw_sys_enter* ctx)
{
    char filename[256];
    bpf_probe_read_user_str(filename, sizeof(filename), 
                            (char*)ctx->args[0]);
    bpf_printk("打开文件: %s\\n", filename);
    return 0;
}

// Rust 内核模块示例
#![no_std]
#![feature(allocator_api, global_asm)]

use kernel::prelude::*;

module! {
    type: RustExample,
    name: b"rust_example",
    license: b"GPL",
}

struct RustExample;

impl kernel::Module for RustExample {
    fn init(_: &'static ThisModule) -> Result<Self> {
        pr_info!("Rust 模块加载\\n");
        Ok(RustExample)
    }
}

// io_uring 使用示例
struct io_uring ring;
io_uring_queue_init(32, &ring, 0);

struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
io_uring_prep_readv(sqe, fd, iovecs, 1, offset);
io_uring_submit(&ring);

struct io_uring_cqe *cqe;
io_uring_wait_cqe(&ring, &cqe);

#include <linux/module.h>
#include <linux/kernel.h>

static char *buffer;

static int init_module(void)
{
    buffer = kmalloc(1024, GFP_KERNEL);
    printk("Module loaded\n");
    return 0;
}

static void cleanup_module(void)
{
    printk("Module unloaded\n");
}

# 错误：直接使用 defconfig
make defconfig
make -j8
# 结果：编译的内核可能无法启动（缺少必要驱动）

# 正确：基于当前运行内核配置
cp /boot/config-$(uname -r) .config
make oldconfig

# 错误：CONFIG_FOO 依赖 CONFIG_BAR，但只启用 FOO
CONFIG_FOO=y
# CONFIG_BAR is not set

# 正确：使用 menuconfig 自动处理依赖
make menuconfig

// 错误：内核不能使用 printf、malloc
printf("Hello from kernel\n");
void *p = malloc(1024);

// 正确：使用内核对应函数
printk(KERN_INFO "Hello from kernel\n");
void *p = kmalloc(1024, GFP_KERNEL);

// 错误：直接访问用户空间指针
void ioctl_handler(char __user *user_buf) {
    char first = *user_buf;  // 可能导致内核崩溃
}

// 正确：使用专门的拷贝函数
void ioctl_handler(char __user *user_buf) {
    char first;
    if (copy_from_user(&first, user_buf, 1))
        return -EFAULT;
}

// 错误：中断上下文使用可睡眠锁
irqreturn_t irq_handler(int irq, void *dev) {
    mutex_lock(&my_mutex);  // BUG：中断上下文不能睡眠
    // ...
}

// 正确：使用自旋锁
irqreturn_t irq_handler(int irq, void *dev) {
    spin_lock(&my_spinlock);
    // ...
}

// 错误：不一致的锁顺序
// CPU0:                  CPU1:
spin_lock(&lock_a);      spin_lock(&lock_b);
spin_lock(&lock_b);      spin_lock(&lock_a);  // 死锁！

// 正确：始终保持相同的锁顺序

// 错误：高频路径使用 printk
void hot_path_function(void) {
    printk(KERN_DEBUG "Entering function\n");  // 严重影响性能
}

// 正确：使用 tracepoint 或条件打印
void hot_path_function(void) {
    trace_hot_path_entry();  // 低开销
}

// 错误：频繁访问的变量在同一 cache line
struct bad_struct {
    atomic_t counter1;  // CPU0 频繁更新
    atomic_t counter2;  // CPU1 频繁更新
};  // 伪共享导致性能下降

// 正确：cache line 对齐
struct good_struct {
    atomic_t counter1 ____cacheline_aligned;
    atomic_t counter2 ____cacheline_aligned;
};

#define DEBUG  // 启用调试信息
pr_debug("调试信息: var=%d\n", var);
// 生产环境编译时不定义 DEBUG，自动去除

BUG_ON(condition);   // 条件为真则内核 panic
WARN_ON(condition);  // 条件为真则打印警告栈回溯

# 运行时启用特定文件的调试信息
echo 'file drivers/net/e1000/e1000_main.c +p' > /sys/kernel/debug/dynamic_debug/control