M6: 持久化抽象与异步 I/O 架构

struct super_block {
    struct list_head    s_list;         // 全局超级块链表
    dev_t               s_dev;          // 设备标识
    unsigned long       s_blocksize;    // 块大小
    unsigned long       s_magic;        // 魔数 (文件系统标识)
    struct dentry      *s_root;         // 根目录项
    struct file_system_type *s_type;    // 文件系统类型
    const struct super_operations *s_op; // 操作函数表
    // ...
    void               *s_fs_info;      // 文件系统私有数据
};

struct super_operations {
    struct inode *(*alloc_inode)(struct super_block *sb);
    void (*destroy_inode)(struct inode *);
    void (*dirty_inode)(struct inode *, int flags);
    int (*write_inode)(struct inode *, struct writeback_control *);
    void (*put_super)(struct super_block *);
    int (*sync_fs)(struct super_block *sb, int wait);
    int (*statfs)(struct dentry *, struct kstatfs *);
    // ...
};

struct inode {
    umode_t             i_mode;         // 文件类型和权限
    unsigned short      i_opflags;      
    kuid_t              i_uid;          // 所有者 UID
    kgid_t              i_gid;          // 所有者 GID
    unsigned int        i_flags;
    
    const struct inode_operations *i_op;     // inode 操作
    struct super_block *i_sb;                 // 所属超级块
    struct address_space *i_mapping;          // 关联的页缓存
    
    unsigned long       i_ino;          // inode 号
    union {
        const unsigned int i_nlink;     // 硬链接数
        unsigned int __i_nlink;
    };
    dev_t               i_rdev;         // 设备号 (设备文件)
    loff_t              i_size;         // 文件大小
    struct timespec64   i_atime;        // 访问时间
    struct timespec64   i_mtime;        // 修改时间
    struct timespec64   i_ctime;        // 状态改变时间
    
    const struct file_operations *i_fop;  // 文件操作
    struct address_space i_data;          // 页缓存
    // ...
};

struct inode_operations {
    struct dentry * (*lookup)(struct inode *, struct dentry *, unsigned int);
    int (*create)(struct inode *, struct dentry *, umode_t, bool);
    int (*link)(struct dentry *, struct inode *, struct dentry *);
    int (*unlink)(struct inode *, struct dentry *);
    int (*symlink)(struct inode *, struct dentry *, const char *);
    int (*mkdir)(struct inode *, struct dentry *, umode_t);
    int (*rmdir)(struct inode *, struct dentry *);
    int (*rename)(struct inode *, struct dentry *,
                  struct inode *, struct dentry *, unsigned int);
    // ...
};

struct dentry {
    unsigned int d_flags;
    seqcount_spinlock_t d_seq;
    struct hlist_bl_node d_hash;        // 哈希表节点
    struct dentry *d_parent;            // 父目录项
    struct qstr d_name;                 // 文件名
    struct inode *d_inode;              // 关联的 inode
    unsigned char d_iname[DNAME_INLINE_LEN];  // 短名称内联存储
    
    const struct dentry_operations *d_op;
    struct super_block *d_sb;           // 所属超级块
    void *d_fsdata;                     // 文件系统私有数据
    
    struct list_head d_child;           // 子目录项链表
    struct list_head d_subdirs;         // 子目录
};

struct file {
    struct path         f_path;         // 文件路径 (vfsmount + dentry)
    struct inode       *f_inode;        // 快速访问 inode
    const struct file_operations *f_op; // 文件操作
    spinlock_t          f_lock;
    atomic_long_t       f_count;        // 引用计数
    unsigned int        f_flags;        // 打开标志 (O_RDONLY, O_NONBLOCK, ...)
    fmode_t             f_mode;         // 访问模式
    loff_t              f_pos;          // 当前读写位置
    struct address_space *f_mapping;    // 页缓存
    void               *private_data;   // 驱动私有数据
};

struct file_operations {
    loff_t (*llseek)(struct file *, loff_t, int);
    ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
    ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
    ssize_t (*read_iter)(struct kiocb *, struct iov_iter *);
    ssize_t (*write_iter)(struct kiocb *, struct iov_iter *);
    int (*mmap)(struct file *, struct vm_area_struct *);
    int (*open)(struct inode *, struct file *);
    int (*release)(struct inode *, struct file *);
    int (*fsync)(struct file *, loff_t, loff_t, int datasync);
    // ...
};

// fs/namei.c
// 从根目录开始逐级解析路径

path_lookupat():
    1. 从 "/" 或 "." 开始
    2. 分割路径为组件
    3. 对每个组件:
       a) 查 dentry 缓存
       b) 未命中则调用 lookup() 从磁盘读取
       c) 检查权限
       d) 处理符号链接
    4. 返回最终的 dentry

struct ext4_inode {
    __le16  i_mode;         // 文件类型和权限
    __le16  i_uid;          // 所有者 UID (低 16 位)
    __le32  i_size_lo;      // 文件大小 (低 32 位)
    __le32  i_atime;        // 访问时间
    __le32  i_ctime;        // inode 修改时间
    __le32  i_mtime;        // 数据修改时间
    __le32  i_dtime;        // 删除时间
    __le16  i_gid;          // 组 GID (低 16 位)
    __le16  i_links_count;  // 硬链接数
    __le32  i_blocks_lo;    // 块数 (低 32 位)
    __le32  i_flags;        // 文件标志
    // ...
    __le32  i_block[EXT4_N_BLOCKS];  // 块指针或 extent 树
    // ...
};

传统间接块 (ext2/ext3):
inode → [直接块指针 ×12]
      → [一次间接块] → [数据块]
      → [二次间接块] → [一次间接] → [数据块]
      → [三次间接块] → ...

ext4 Extent:
inode → [Extent Header]
      → [Extent Entry 1]: {起始逻辑块, 长度, 物理块}
      → [Extent Entry 2]: ...
      → [Extent Index] → [叶子节点] → [Extent Entries]

Extent 优势:
1. 大文件连续分配, 减少元数据
2. 更快的大文件访问
3. 减少碎片

struct ext4_extent {
    __le32  ee_block;      // 起始逻辑块号
    __le16  ee_len;        // extent 长度 (块数)
    __le16  ee_start_hi;   // 物理块号高位
    __le32  ee_start_lo;   // 物理块号低位
};

写入流程:
1. 开始事务
2. 写入日志区 (元数据 / 数据)
3. 提交事务 (commit)
4. 写入实际位置
5. 删除日志记录

### 3.5 一致性与崩溃恢复策略

文件系统必须保证在断电或崩溃后数据的一致性.现代系统采用以下三种核心策略: 

| 策略 | 核心机制 | 核心优势 | 代表系统 |
|:---:|----------|----------|----------|
| **Journaling** | 先在预写日志 (WAL) 记录操作, 成功后修改数据 | 恢复极快, 在线一致性 | Ext4, XFS |
| **CoW (Copy-on-Write)** | 不覆盖旧块, 写入新块并修改树指针 | 无损快照, 数据始终一致 | Btrfs, ZFS |
| **Soft Updates** | 严格控制元数据写入顺序 | 与 UFS 性能相近, 无需日志开销 | FreeBSD UFS |

**Ext4 日志模式对比**:

| 模式 | 日志内容 | 性能 | 安全性 |
|:---:|----------|:---:|--------|
| `journal` | 元数据 + 数据 | 最慢 | 最高 |
| `ordered` | 仅元数据 (先写数据后写元数据) | 中等 | 中等 (默认) |
| `writeback` | 仅元数据 (无顺序保证) | 最快 | 最低 |

---

## 4. 链接与目录操作

Linux 文件系统支持两种链接机制, 分别解决不同的引用需求.

### 4.1 硬链接 vs 符号链接

```mermaid
graph TD
    subgraph HardLink ["硬链接: 多个名字 -> 同一实体"]
        D1[Dentry: /a/file1] -- 指向 --> I100[Inode 100<br/>n_link=2]
        D2[Dentry: /b/file2] -- 指向 --> I100
    end

    subgraph SoftLink ["软链接: 桥梁指向路径"]
        D3[Dentry: /c/link] -- 指向 --> I200[Inode 200<br/>Type: Symlink]
        I200 -- "内容: '/a/file1'" --> D1
    end
    
    style I100 fill:#e8f0fe
    style I200 fill:#fef7e0

struct bio {
    struct bio         *bi_next;        // 链表
    struct block_device *bi_bdev;       // 目标块设备
    unsigned int        bi_opf;         // 操作类型和标志
    unsigned short      bi_vcnt;        // bio_vec 数量
    unsigned short      bi_max_vecs;    // 最大 bio_vec 数量
    atomic_t            bi_cnt;         // 引用计数
    
    struct bvec_iter    bi_iter;        // 当前迭代位置
    
    bio_end_io_t       *bi_end_io;      // 完成回调
    void               *bi_private;     // 私有数据
    
    struct bio_vec     *bi_io_vec;      // 页面数组
};

struct bio_vec {
    struct page    *bv_page;            // 页面
    unsigned int    bv_len;             // 长度
    unsigned int    bv_offset;          // 页内偏移
};

# 查看当前调度器
cat /sys/block/sda/queue/scheduler

# 设置调度器
echo mq-deadline > /sys/block/sda/queue/scheduler

# 查看脏页阈值
cat /proc/sys/vm/dirty_ratio         # 触发同步写的阈值 (%)
cat /proc/sys/vm/dirty_background_ratio  # 触发后台写回的阈值 (%)
cat /proc/sys/vm/dirty_expire_centisecs  # 脏页过期时间 (厘秒)

# 查看页缓存状态
cat /proc/meminfo | grep -E "Cached|Dirty|Writeback"

同步 I/O:       read() ─── 阻塞等待 ───→ 返回
线程池异步:     创建线程 → read() 阻塞 → 回调
AIO (libaio):  仅支持 O_DIRECT, 接口复杂

#include <liburing.h>

struct io_uring ring;
io_uring_queue_init(32, &ring, 0);  // 32 个条目

// 准备读操作
struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
io_uring_prep_read(sqe, fd, buf, size, offset);
sqe->user_data = (unsigned long)my_context;

// 提交
io_uring_submit(&ring);

// 等待完成
struct io_uring_cqe *cqe;
io_uring_wait_cqe(&ring, &cqe);

// 处理结果
int result = cqe->res;
void *ctx = (void *)cqe->user_data;

// 标记已处理
io_uring_cqe_seen(&ring, cqe);

// 清理
io_uring_queue_exit(&ring);

#include <linux/cdev.h>
#include <linux/fs.h>

static struct cdev my_cdev;
static dev_t dev_num;

static int my_open(struct inode *inode, struct file *file) {
    // 打开设备时调用
    return 0;
}

static ssize_t my_read(struct file *file, char __user *buf, 
                       size_t count, loff_t *ppos) {
    // 读取设备
    if (copy_to_user(buf, kernel_buf, count))
        return -EFAULT;
    return count;
}

static ssize_t my_write(struct file *file, const char __user *buf,
                        size_t count, loff_t *ppos) {
    // 写入设备
    if (copy_from_user(kernel_buf, buf, count))
        return -EFAULT;
    return count;
}

static const struct file_operations my_fops = {
    .owner = THIS_MODULE,
    .open = my_open,
    .read = my_read,
    .write = my_write,
};

static int __init my_init(void) {
    // 分配设备号
    alloc_chrdev_region(&dev_num, 0, 1, "mydev");
    
    // 初始化 cdev
    cdev_init(&my_cdev, &my_fops);
    cdev_add(&my_cdev, dev_num, 1);
    
    return 0;
}

static void __exit my_exit(void) {
    cdev_del(&my_cdev);
    unregister_chrdev_region(dev_num, 1);
}

module_init(my_init);
module_exit(my_exit);

---

## 9. 磁盘调度算法

### 9.1 经典算法 (HDD)

| 算法 | 英文 | 策略 | 特点 |
|:---:|------|:---:|------|
| FCFS | First-Come First-Served | 按请求顺序 | 简单, 寻道距离大 |
| SSTF | Shortest Seek Time First | 最短寻道优先 | 吞吐高, 可能饥饿 |
| SCAN | Elevator | 单向扫描到端后反向 | 公平, 避免饥饿 |
| C-SCAN | Circular SCAN | 单向扫描, 直接返回起点 | 更均匀的等待时间 |
| LOOK | - | SCAN 但不到端点 | 实际采用 |

### 9.2 SSD 不需要传统调度

---

## 10. 缓冲技术

### 10.1 缓冲层次

```mermaid
graph TD
    App[应用层: stdio 缓存<br/>fread/fwrite] --> Kernel[内核层: 页缓存<br/>Page Cache]
    Kernel --> Disk[硬件层: 磁盘缓存<br/>Controller Cache]
    Disk --> Media[(物理介质)]
    
    style Media fill:#e8f0fe

// 直接 I/O, 绕过页缓存
int fd = open("/data/file", O_RDWR | O_DIRECT);

// 要求:
// 1. 地址对齐 (通常 512 字节)
// 2. 长度对齐
// 3. 偏移对齐

// 适用场景:
// - 数据库 (自己管理缓存)
// - 大文件顺序读写

// 字符设备驱动框架
static struct file_operations my_fops = {
    .owner = THIS_MODULE,
    .open = my_open,     // 打开设备
    .release = my_release,// 关闭设备  
    .read = my_read,     // 读数据
    .write = my_write,   // 写数据
    .ioctl = my_ioctl,   // 控制命令
};

// 块设备驱动框架
static struct block_device_operations my_block_ops = {
    .owner = THIS_MODULE,
    .open = my_open,
    .release = my_release,
    .submit_bio = my_submit_bio, // 提交 I/O 请求
};

// I/O 端口访问 (x86)
unsigned char data = inb(0x60);   // 从端口 0x60 读取
outb(0x03, 0x3F8);                // 向端口 0x3F8 写入

// 内存映射 I/O (Linux)
void __iomem *regs = ioremap(phys_addr, size);
writel(value, regs + OFFSET);
value = readl(regs + OFFSET);
iounmap(regs);

┌─────────────────────────────────────────────────────────────────────┐
│  进程 1: printf() ──┐                                               │
│  进程 2: printf() ──┼──→ 输出井 (磁盘缓冲区) ──→ 输出进程 ──→ 打印机  │
│  进程 3: printf() ──┘                                               │
│                                                                     │
│  效果: 慢速独占设备变成高速共享设备                                   │
└─────────────────────────────────────────────────────────────────────┘

创建文件需要:
1. 分配 inode
2. 初始化 inode
3. 更新目录项
4. 更新位图

若在步骤 2-3 之间崩溃 → inode 泄漏
若在步骤 3-4 之间崩溃 → 位图与实际不一致

struct io_uring ring;
struct io_uring_params params = {
    .flags = IORING_SETUP_SQPOLL,
    .sq_thread_idle = 2000, // 空闲 2 秒后休眠
};

io_uring_queue_init_params(32, &ring, &params);

// 提交请求 (无需 syscall!)
struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
io_uring_prep_read(sqe, fd, buf, size, 0);
io_uring_submit(&ring);  // 仅更新 SQ tail, 无 syscall

# 创建子卷
btrfs subvolume create /mnt/data/subvol1

# 创建只读快照 (瞬间完成)
btrfs subvolume snapshot -r /mnt/data/subvol1 /mnt/data/snap1

# 创建可写快照 (用于测试)
btrfs subvolume snapshot /mnt/data/subvol1 /mnt/data/test_snap

# 发送增量备份
btrfs send -p /mnt/data/snap1 /mnt/data/snap2 | btrfs receive /backup/

# 查看 ARC 统计
arc_summary

# 设置 ARC 最大内存
echo "options zfs zfs_arc_max=8589934592" >> /etc/modprobe.d/zfs.conf

# 添加 L2ARC 设备
zpool add tank cache /dev/nvme0n1

// Linux 多队列块层 (blk-mq)
// 为每个 CPU 创建独立软件队列, 直接映射到 NVMe 硬件队列

struct blk_mq_tag_set {
    unsigned int        nr_hw_queues;   // 硬件队列数 (= NVMe 队列)
    unsigned int        queue_depth;    // 每队列深度
    struct blk_mq_ops   *ops;           // 操作回调
};

// 查看设备队列配置
// ls /sys/block/nvme0n1/mq/
// 每个目录代表一个硬件队列

# 设置 NVMe 使用 none 调度器 (无需排序)
echo none > /sys/block/nvme0n1/queue/scheduler

# 调整队列深度
echo 256 > /sys/block/nvme0n1/queue/nr_requests