/* 内核的核心角色可以通过一个简单的系统调用路径来理解 */
/* 当用户程序调用 write() 时： */

/* 1. 用户态：glibc 封装的系统调用接口 */
ssize_t write(int fd, const void *buf, size_t count) {
    /* 通过 syscall 指令切换到内核态 */
    /* 参数：fd -> rdi, buf -> rsi, count -> rdx */
    /* 系统调用号：1 (SYS_write) -> rax */
    return syscall(SYS_write, fd, buf, count);
}

/* 2. 内核态：系统调用处理函数 */
/* 内核验证用户空间指针的合法性 */
/* 将数据从用户缓冲区复制到内核缓冲区 */
/* 调用设备驱动将数据写入设备 */
/* 返回写入的字节数 */

宏内核架构：
┌─────────────────────────────────────────┐
│            用户应用程序                   │
├─────────────────────────────────────────┤
│         系统调用接口                      │
├──────┬──────┬──────┬──────┬─────────────┤
│进程  │内存  │文件  │网络  │ 设备驱动     │
│调度  │管理  │系统  │栈   │             │
├──────┴──────┴──────┴──────┴─────────────┤
│            硬件抽象层                     │
├─────────────────────────────────────────┤
│            硬件                          │
└─────────────────────────────────────────┘

微内核架构：
┌─────────────────────────────────────────┐
│            用户应用程序                   │
├─────────────────────────────────────────┤
│         系统调用接口                      │
├──────┬──────┬──────┬──────┬─────────────┤
│文件  │网络  │设备  │     │             │
│服务  │服务  │驱动  │     │             │
│(用户)│(用户)│(用户)│     │             │
├──────┴──────┴──────┴──────┴─────────────┤
│         微内核（IPC、调度、内存）          │
├─────────────────────────────────────────┤
│            硬件                          │
└─────────────────────────────────────────┘

/* 用户态与内核态的切换示意 */

/* 用户态代码 */
#include <unistd.h>
#include <fcntl.h>

int main() {
    int fd = open("/etc/hosts", O_RDONLY);  /* 系统调用：用户态→内核态 */
    char buf[256];
    read(fd, buf, sizeof(buf));             /* 系统调用：用户态→内核态 */
    close(fd);                              /* 系统调用：用户态→内核态 */
    return 0;
}

/* 内核态处理 open 系统调用（简化） */
/* fs/open.c */
SYSCALL_DEFINE3(open, const char __user *, filename,
                int, flags, umode_t, mode) {
    /* 此时已在内核态（Ring 0） */
    /* 验证用户空间指针 filename 的合法性 */
    /* 在文件系统中查找文件 */
    /* 分配文件描述符 */
    /* 返回文件描述符给用户态 */
}

/* 系统调用表（简化版） */
/* arch/x86/entry/syscalls/syscall_64.tbl */
/*
 * 系统调用号    函数名           入口
 * 0             read             sys_read
 * 1             write            sys_write
 * 2             open             sys_open
 * 3             close            sys_close
 * 9             mmap             sys_mmap
 * 56            clone            sys_clone
 * 57            fork             sys_fork
 * 60            exit             sys_exit
 * 231           exit_group       sys_exit_group
 */

/* 使用 syscall() 直接调用系统调用（绕过 glibc 封装） */
#include <sys/syscall.h>
#include <unistd.h>
#include <stdio.h>

int main() {
    /* 直接调用 write 系统调用 */
    long ret = syscall(SYS_write, 1, "Hello, syscall!\n", 16);
    printf("write returned: %ld\n", ret);

    /* 直接调用 getpid 系统调用 */
    pid_t pid = syscall(SYS_getpid);
    printf("My PID: %d\n", pid);

    return 0;
}

/* 一个简单的内核模块示例 */
/* hello.c */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Linux Kernel Reader");
MODULE_DESCRIPTION("A simple hello world kernel module");

static int __init hello_init(void) {
    printk(KERN_INFO "Hello, Linux Kernel!\n");
    printk(KERN_INFO "Module loaded successfully.\n");
    return 0;
}

static void __exit hello_exit(void) {
    printk(KERN_INFO "Goodbye, Linux Kernel!\n");
    printk(KERN_INFO "Module unloaded.\n");
}

module_init(hello_init);
module_exit(hello_exit);

/* Makefile */
/*
 * obj-m += hello.o
 * KDIR := /lib/modules/$(shell uname -r)/build
 * PWD := $(shell pwd)
 *
 * default:
 *     $(MAKE) -C $(KDIR) M=$(PWD) modules
 *
 * clean:
 *     $(MAKE) -C $(KDIR) M=$(PWD) clean
 */

# 编译和加载模块
make                          # 编译
sudo insmod hello.ko          # 加载模块
dmesg | tail                  # 查看内核日志输出
lsmod | grep hello            # 查看已加载的模块
sudo rmmod hello              # 卸载模块

linux/
├── arch/          # 体系结构相关代码（x86、arm、mips等）
├── block/         # 块设备I/O调度
├── crypto/        # 加密API
├── drivers/       # 设备驱动程序（最大的目录）
├── fs/            # 文件系统（ext4、btrfs、proc等）
├── include/       # 头文件（内核API声明）
├── init/          # 内核初始化和启动
├── ipc/           # 进程间通信（信号量、消息队列、共享内存）
├── kernel/        # 核心子系统（进程调度、信号、定时器等）
├── lib/           # 通用库函数
├── mm/            # 内存管理（伙伴系统、slab、vmalloc等）
├── net/           # 网络协议栈（TCP/IP、socket等）
├── security/      # 安全模块（SELinux、AppArmor等）
├── sound/         # 音频子系统
└── virt/          # 虚拟化支持

# 查看内核版本
cat /proc/version
# Linux version 5.15.0 (gcc version 11.3.0) ...

# 查看CPU信息
cat /proc/cpuinfo

# 查看内存使用情况
cat /proc/meminfo

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

# 查看系统加载的模块
cat /proc/modules

# 查看系统调用统计
cat /proc/self/syscall

# 查看中断信息
cat /proc/interrupts

# 跟踪 ls 命令的系统调用
strace ls 2>&1 | head -30

execve("/usr/bin/ls", ["ls"], 0x7ffd12345 /* 50 vars */) = 0
brk(NULL)                               = 0x55a123456000
arch_prctl(0x3001 /* ARCH_??? */, 0x7ffd12345678) = -1 EINVAL
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f1234567000
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=123456, ...}) = 0
mmap(NULL, 123456, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f1234568000
close(3)                                = 0
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
...

# 统计系统调用的次数和时间
strace -c ls /tmp 2>&1

% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 35.12    0.001234          12       102        50 openat
 25.67    0.000896           8       112           close
 15.34    0.000535          10        53           fstat
 12.89    0.000450          15        30           mmap
 ...

# 只跟踪特定系统调用
strace -e trace=openat,read,write ls

/* proc_info.c - 在 /proc 下创建自定义文件 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/uaccess.h>
#include <linux/jiffies.h>

#define PROC_NAME "kernel_reader_info"

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Linux Kernel Reader");

static ssize_t proc_read(struct file *file, char __user *buf,
                         size_t count, loff_t *ppos) {
    char tmp[256];
    int len;

    if (*ppos > 0)
        return 0;

    len = sprintf(tmp,
        "Uptime (jiffies): %lu\n"
        "HZ: %d\n"
        "Current PID: %d\n"
        "Module refcount: %d\n",
        jiffies,
        HZ,
        current->pid,
        module_refcount(THIS_MODULE));

    if (copy_to_user(buf, tmp, len))
        return -EFAULT;

    *ppos = len;
    return len;
}

static const struct proc_ops proc_ops = {
    .proc_read = proc_read,
};

static struct proc_dir_entry *proc_entry;

static int __init proc_info_init(void) {
    proc_entry = proc_create(PROC_NAME, 0444, NULL, &proc_ops);
    if (!proc_entry)
        return -ENOMEM;
    printk(KERN_INFO "proc_info module loaded.\n");
    return 0;
}

static void __exit proc_info_exit(void) {
    proc_remove(proc_entry);
    printk(KERN_INFO "proc_info module unloaded.\n");
}

module_init(proc_info_init);
module_exit(proc_info_exit);

# 编译并加载后
sudo insmod proc_info.ko
cat /proc/kernel_reader_info
# 输出：
# Uptime (jiffies): 4295123456
# HZ: 1000
# Current PID: 12345
# Module refcount: 0
sudo rmmod proc_info

# 查看内核启动日志
dmesg | head -50

[    0.000000] Linux version 5.15.0-generic (buildd@lcy02-amd64-023) ...
[    0.000000] Command line: BOOT_IMAGE=/boot/vmlinuz-5.15.0 root=UUID=...
[    0.000000] BIOS-provided physical RAM map:
[    0.000000]  BIOS-e820: [mem 0x0000000000000000-0x000000000009fbff] usable
[    0.234567] CPU: Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz
[    0.345678] Memory: 16384MB RAM available
[    0.456789] Calibrating delay loop (skipped), value calculated using timer frequency.. 5800.00 BogoMIPS
...
[    1.234567] VFS: Disk quotas dquot_6.6.0
[    1.345678] EXT4-fs (sda1): mounted filesystem with ordered data mode