第7章：块设备层与I/O调度

    用户空间
        |
    系统调用 (read/write/mmap)
        |
    ┌─────┐
    │ VFS │ (虚拟文件系统)
    └──┬──┘
       │
    ┌──┴────────┐
    │ Page Cache│ (页缓存)
    └──┬────────┘
       │
    ┌──┴──────┐
    │ 文件系统 │ (ext4/xfs/btrfs...)
    └──┬──────┘
       │ submit_bio()
    ┌──┴────────────┐
    │  块设备层(Block Layer)  │
    │ ┌──────────┐ │
    │ │ bio 层   │ │ (块I/O层)
    │ └──┬───────┘ │
    │    │make_request
    │ ┌──┴───────┐ │
    │ │ 请求队列  │ │ (request queue)
    │ └──┬───────┘ │
    │    │         │
    │ ┌──┴───────┐ │
    │ │I/O调度器 │ │ (elevator)
    │ └──┬───────┘ │
    └────┴──────────┘
         │
    ┌────┴──────┐
    │ 块设备驱动 │ (scsi/nvme/virtio-blk...)
    └────┬──────┘
         │
    ┌────┴──────┐
    │ 硬件设备  │ (HDD/SSD/NVMe...)
    └───────────┘

struct bio {
    struct bio        *bi_next;      /* 请求链表中的下一个bio */
    struct gendisk    *bi_disk;      /* 目标磁盘 */
    unsigned int      bi_opf;        /* 操作标志(REQ_OP_*) */
    unsigned short    bi_flags;      /* bio标志 */
    unsigned short    bi_ioprio;     /* I/O优先级 */

    struct bvec_iter  bi_iter;       /* 当前迭代器位置 */
    unsigned int      bi_size;       /* 剩余I/O字节数 */

    unsigned short    bi_vcnt;       /* bio_vec数量 */
    unsigned short    bi_max_vecs;   /* 最大bio_vec数量 */
    atomic_t          bi_cnt;        /* 引用计数 */

    struct bio_vec    *bi_io_vec;    /* 实际的vec列表 */
    struct bio_set    *bi_pool;      /* bio内存池 */

    /* 回调和私有数据 */
    bio_end_io_t      *bi_end_io;    /* I/O完成回调 */
    void              *bi_private;   /* 私有数据 */
};

struct bio_vec {
    struct page     *bv_page;     /* 物理页 */
    unsigned int    bv_len;       /* 数据长度 */
    unsigned int    bv_offset;    /* 页内偏移 */
};

struct request {
    struct request_queue *q;         /* 所属请求队列 */
    struct blk_mq_ctx    *mq_ctx;    /* blk-mq上下文 */
    struct blk_mq_hw_ctx *mq_hctx;   /* 硬件队列上下文 */

    unsigned int cmd_flags;          /* 命令标志 */
    req_flags_t  rq_flags;           /* 请求标志 */

    sector_t     __sector;           /* 起始扇区 */
    unsigned int __data_len;         /* 数据长度 */

    struct bio   *bio;               /* bio链表头 */
    struct bio   *biotail;           /* bio链表尾 */

    struct list_head queuelist;      /* 队列链表 */

    /* 用于I/O统计 */
    u64 start_time_ns;              /* 开始时间 */
    u64 io_start_time_ns;           /* I/O开始时间 */

    /* 用于超时处理 */
    unsigned int timeout;            /* 超时时间 */
    struct timer_list timeout_timer; /* 超时定时器 */
};

struct gendisk {
    int major;                      /* 主设备号 */
    int first_minor;                /* 起始次设备号 */
    int minors;                     /* 次设备号数量 */

    char disk_name[DISK_NAME_LEN]; /* 磁盘名称(如sda) */

    struct request_queue *queue;    /* 请求队列 */
    struct block_device *part0;     /* 整个磁盘的块设备 */

    const struct block_device_operations *fops; /* 块设备操作 */

    /* 分区信息 */
    struct disk_part_tbl __rcu *part_tbl;  /* 分区表 */
    struct hd_struct part0;                /* 整盘分区 */

    /* 容量信息 */
    sector_t capacity;              /* 磁盘容量(扇区) */

    /* 统计信息 */
    struct disk_stats __percpu *dkstats;   /* 磁盘统计 */
};

struct block_device_operations {
    int (*open)(struct block_device *, fmode_t);
    void (*release)(struct gendisk *, fmode_t);
    int (*ioctl)(struct block_device *, fmode_t, unsigned, unsigned long);
    int (*compat_ioctl)(struct block_device *, fmode_t, unsigned, unsigned long);
    int (*direct_access)(struct block_device *, sector_t, void **, unsigned long *);
    int (*media_changed)(struct gendisk *);
    int (*revalidate_disk)(struct gendisk *);
    int (*getgeo)(struct block_device *, struct hd_geometry *);
    void (*swap_slot_free_notify)(struct block_device *, unsigned long);
    struct module *owner;
};

文件系统 -> submit_bio() -> generic_make_request() -> 请求队列

bio -> 电梯算法合并 -> request -> 插入调度队列

调度器 -> blk_mq_dispatch_rq_list() -> 驱动程序

中断处理 -> blk_mq_complete_request() -> bio_endio() -> 唤醒等待进程

struct cfq_data {
    struct request_queue *queue;

    /* 服务树(红黑树)按优先级组织 */
    struct cfq_rb_root service_trees[2][3];  /* sync/async, 3个优先级 */

    /* 空闲和忙碌队列 */
    struct list_head idle_list;
    struct list_head busy_list;

    /* 时间片和配额 */
    unsigned int cfq_quantum;        /* 队列时间片 */
    unsigned int cfq_slice[2];       /* sync/async时间片 */
    unsigned int cfq_slice_idle;     /* 空闲等待时间 */

    /* 统计信息 */
    unsigned int busy_queues;
    struct cfq_io_context *active_cic;
};

struct deadline_data {
    /* 请求队列：读写分离，按扇区排序 */
    struct rb_root sort_list[2];     /* 读/写红黑树 */
    struct list_head fifo_list[2];   /* FIFO队列 */

    /* 当前批处理 */
    struct request *next_rq[2];      /* 下一个请求 */
    unsigned int batching;            /* 批处理计数 */
    unsigned int starved;             /* 饥饿计数 */

    /* 调度参数 */
    int fifo_expire[2];              /* 读500ms,写5000ms */
    int fifo_batch;                  /* 批大小16 */
    int writes_starved;              /* 写饥饿阈值2 */
    int front_merges;                /* 前向合并开关 */
};

struct noop_data {
    struct list_head queue;  /* 简单FIFO队列 */
};

struct mq_deadline_data {
    /* per-hardware queue */
    struct deadline_data **hq_data;

    /* 全局统计 */
    atomic_t dispatched[2];

    /* 每CPU统计避免缓存行竞争 */
    struct mq_deadline_cpu_stats __percpu *stats;
};

struct bfq_data {
    /* 服务树 */
    struct bfq_group *root_group;

    /* 权重树 */
    struct rb_root queue_weights_tree;
    struct rb_root group_weights_tree;

    /* 预算和时间片 */
    int bfq_max_budget;
    int bfq_timeout;

    /* 交互性检测 */
    bool strict_guarantees;
    bool low_latency;
};

struct kyber_data {
    /* 令牌桶 */
    struct kyber_token_bucket tb[KYBER_NUM_DOMAINS];

    /* 延迟目标 */
    unsigned int read_lat_nsec;   /* 2ms */
    unsigned int write_lat_nsec;  /* 10ms */

    /* 自适应调整 */
    struct timer_list timer;
    atomic_t samples[KYBER_NUM_DOMAINS];
};

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

# 切换调度器
echo mq-deadline > /sys/block/sda/queue/scheduler

    所有CPU
        ↓
    [全局锁]
        ↓
   单一请求队列
        ↓
    I/O调度器
        ↓
     设备驱动

  CPU0    CPU1    CPU2    CPU3
    ↓       ↓       ↓       ↓
  SWQ0    SWQ1    SWQ2    SWQ3  (软件队列)
    ↓       ↓       ↓       ↓
    └───────┴───────┴───────┘
              ↓
         [映射算法]
              ↓
    ┌─────────────────────┐
    │  HWQ0    HWQ1       │     (硬件队列)
    └──┬────────┬─────────┘
       ↓        ↓
    [标签0]  [标签1]            (标签管理)
       ↓        ↓
    ┌──────────────┐
    │   NVMe设备   │
    └──────────────┘

struct blk_mq_hw_ctx {
    struct {
        spinlock_t      lock;
        struct list_head dispatch;     /* 派发队列 */
        unsigned long    state;         /* 队列状态 */
    } ____cacheline_aligned_in_smp;

    struct delayed_work run_work;      /* 异步运行 */
    struct delayed_work delay_work;    /* 延迟处理 */

    unsigned long       flags;         /* BLK_MQ_F_* */

    void               *driver_data;   /* 驱动私有数据 */

    struct sbitmap      ctx_map;       /* 软件队列位图 */

    struct blk_mq_ctx  **ctxs;        /* 软件队列数组 */
    unsigned int        nr_ctx;        /* 软件队列数量 */

    atomic_t            wait_index;    /* 等待索引 */

    struct blk_mq_tags *tags;          /* 标签集 */
    struct blk_mq_tags *sched_tags;   /* 调度器标签 */

    unsigned long       queued;        /* 排队请求数 */
    unsigned long       run;           /* 运行次数 */

    unsigned int        numa_node;     /* NUMA节点 */
    unsigned int        queue_num;     /* 队列编号 */
};

struct blk_mq_ctx {
    struct {
        spinlock_t      lock;
        struct list_head rq_list;      /* 请求列表 */
    } ____cacheline_aligned_in_smp;

    unsigned int        cpu;           /* 所属CPU */
    unsigned int        index_hw;      /* 硬件队列索引 */

    /* 统计信息 */
    struct blk_mq_ctxs  *ctxs;
    struct kobject      kobj;
} ____cacheline_aligned_in_smp;

/* 默认映射：轮询分配 */
static int blk_mq_map_queues(struct blk_mq_tag_set *set)
{
    unsigned int *map = set->mq_map;
    unsigned int nr_queues = set->nr_hw_queues;
    unsigned int cpu, queue;

    queue = 0;
    for_each_possible_cpu(cpu) {
        map[cpu] = queue;
        queue = (queue + 1) % nr_queues;
    }
    return 0;
}

/* NUMA感知映射 */
static int blk_mq_map_queues_numa(struct blk_mq_tag_set *set)
{
    const struct cpumask *mask;
    unsigned int queue, cpu;

    queue = 0;
    for_each_node_mask(node, node_possible_map) {
        mask = cpumask_of_node(node);
        for_each_cpu(cpu, mask) {
            set->mq_map[cpu] = queue % set->nr_hw_queues;
        }
        queue++;
    }
    return 0;
}

/* 1. bio提交到软件队列 */
void blk_mq_make_request(struct request_queue *q, struct bio *bio)
{
    struct blk_mq_ctx *ctx = blk_mq_get_ctx(q);
    struct request *rq;

    /* 分配请求 */
    rq = blk_mq_get_request(q, bio, ctx);

    /* 初始化请求 */
    blk_mq_bio_to_request(rq, bio);

    /* 插入软件队列 */
    blk_mq_insert_request(rq, ctx);

    /* 触发运行 */
    blk_mq_run_hw_queue(hctx, async);
}

/* 2. 从软件队列派发到硬件队列 */
bool blk_mq_dispatch_rq_list(struct blk_mq_hw_ctx *hctx,
                             struct list_head *list)
{
    struct request *rq;
    int errors = 0;

    while (!list_empty(list)) {
        rq = list_first_entry(list, struct request, queuelist);
        list_del_init(&rq->queuelist);

        /* 调用驱动的queue_rq */
        ret = q->mq_ops->queue_rq(hctx, rq);

        if (ret == BLK_STS_OK) {
            queued++;
        } else if (ret == BLK_STS_RESOURCE) {
            /* 资源不足，重新入队 */
            blk_mq_requeue_request(rq);
            break;
        }
    }

    return queued > 0;
}

/* 中断上下文的完成处理 */
void blk_mq_complete_request(struct request *rq)
{
    struct blk_mq_ctx *ctx = rq->mq_ctx;

    /* 标记完成 */
    if (!blk_mark_rq_complete(rq))
        return;

    /* 本地CPU处理 */
    if (rq->cpu == smp_processor_id()) {
        __blk_mq_complete_request(rq);
    } else {
        /* IPI到目标CPU */
        blk_mq_trigger_softirq(rq);
    }
}

/* 软中断中的处理 */
static void __blk_mq_complete_request(struct request *rq)
{
    struct request_queue *q = rq->q;

    /* 更新统计 */
    blk_account_io_completion(rq);

    /* 调用完成回调 */
    if (rq->end_io)
        rq->end_io(rq, error);
    else
        blk_mq_free_request(rq);
}

struct blk_mq_tags {
    unsigned int nr_tags;       /* 标签总数 */
    unsigned int nr_reserved;   /* 保留标签数 */

    struct sbitmap_queue bitmap_tags;    /* 普通标签位图 */
    struct sbitmap_queue breserved_tags; /* 保留标签位图 */

    struct request **rqs;       /* 请求数组 */
    struct list_head page_list; /* 内存页列表 */
};

/* 标签分配 */
unsigned int blk_mq_get_tag(struct blk_mq_alloc_data *data)
{
    struct blk_mq_tags *tags = data->tags;
    struct sbitmap_queue *bt;
    unsigned int tag;

    /* 选择位图：普通或保留 */
    bt = &tags->bitmap_tags;
    if (data->flags & BLK_MQ_REQ_RESERVED)
        bt = &tags->breserved_tags;

    /* 从位图分配 */
    tag = __sbitmap_queue_get(bt);

    if (tag == -1 && !(data->flags & BLK_MQ_REQ_NOWAIT)) {
        /* 等待标签释放 */
        blk_mq_wait_for_tag(data);
        tag = __sbitmap_queue_get(bt);
    }

    return tag;
}

/* 等待标签 */
static int blk_mq_wait_for_tag(struct blk_mq_alloc_data *data)
{
    struct sbq_wait_state *ws;
    DEFINE_WAIT(wait);

    ws = bt_wait_ptr(bt, data->hctx);

    do {
        prepare_to_wait(&ws->wait, &wait, TASK_UNINTERRUPTIBLE);

        tag = __sbitmap_queue_get(bt);
        if (tag != -1)
            break;

        io_schedule();
    } while (1);

    finish_wait(&ws->wait, &wait);
    return tag;
}

/* 释放标签并唤醒等待者 */
void blk_mq_put_tag(struct blk_mq_hw_ctx *hctx, unsigned int tag)
{
    struct blk_mq_tags *tags = hctx->tags;

    sbitmap_queue_clear(&tags->bitmap_tags, tag);

    /* 唤醒等待者 */
    sbitmap_queue_wake_up(&tags->bitmap_tags);
}

    用户空间工具 (lvm2, cryptsetup, dmsetup)
            ↓ ioctl
    ┌─────────────────────────┐
    │    Device Mapper Core    │
    │  (映射表管理，I/O路由)    │
    └───────────┬─────────────┘
                ↓
    ┌───────────────────────────────┐
    │       Target Drivers          │
    │  (linear, striped, mirror,    │
    │   snapshot, crypt, thin...)   │
    └───────────┬───────────────────┘
                ↓
    ┌───────────────────────────────┐
    │     Underlying Devices        │
    │   (物理磁盘、分区、其他DM设备)  │
    └───────────────────────────────┘

/* 映射设备 */
struct mapped_device {
    struct rw_semaphore io_lock;
    struct mutex suspend_lock;

    struct request_queue *queue;
    struct gendisk *disk;

    atomic_t holders;
    atomic_t open_count;

    struct dm_table *map;

    /* I/O统计 */
    struct dm_stats stats;

    /* 事件处理 */
    atomic_t event_nr;
    wait_queue_head_t eventq;

    /* 工作队列 */
    struct workqueue_struct *wq;
};

/* 映射表 */
struct dm_table {
    struct mapped_device *md;
    unsigned type;

    /* 目标设备数组 */
    unsigned int num_targets;
    struct dm_target *targets;

    /* 设备限制 */
    struct queue_limits limits;

    /* 底层设备列表 */
    struct list_head devices;
};

/* 目标驱动 */
struct target_type {
    const char *name;
    struct module *module;
    unsigned version[3];

    /* 构造和析构 */
    int (*ctr)(struct dm_target *ti, unsigned argc, char **argv);
    void (*dtr)(struct dm_target *ti);

    /* I/O处理 */
    int (*map)(struct dm_target *ti, struct bio *bio);
    int (*end_io)(struct dm_target *ti, struct bio *bio, int error);

    /* 管理操作 */
    int (*preresume)(struct dm_target *ti);
    void (*resume)(struct dm_target *ti);
    void (*presuspend)(struct dm_target *ti);
    void (*postsuspend)(struct dm_target *ti);

    /* 状态查询 */
    void (*status)(struct dm_target *ti, status_type_t type,
                   char *result, unsigned maxlen);

    struct list_head list;
};

struct linear_c {
    struct dm_dev *dev;
    sector_t start;  /* 物理设备起始扇区 */
};

static int linear_map(struct dm_target *ti, struct bio *bio)
{
    struct linear_c *lc = ti->private;

    /* 重定向到底层设备 */
    bio->bi_bdev = lc->dev->bdev;
    bio->bi_iter.bi_sector = lc->start + dm_target_offset(ti, bio);

    return DM_MAPIO_REMAPPED;
}

# 创建线性映射：将/dev/sdb1和/dev/sdc1连接
echo "0 1000000 linear /dev/sdb1 0" | dmsetup create linear1
echo "1000000 1000000 linear /dev/sdc1 0" | dmsetup create linear2

struct stripe_c {
    uint32_t stripes;        /* 条带数量 */
    uint32_t stripe_width;   /* 条带宽度(扇区) */

    /* 条带数组 */
    struct stripe {
        struct dm_dev *dev;
        sector_t physical_start;
    } stripe[0];
};

static int stripe_map(struct dm_target *ti, struct bio *bio)
{
    struct stripe_c *sc = ti->private;
    sector_t sector = bio->bi_iter.bi_sector;
    uint32_t stripe;

    /* 计算条带索引 */
    stripe = sector_div(sector, sc->stripe_width) % sc->stripes;

    /* 重定向到对应条带 */
    bio->bi_bdev = sc->stripe[stripe].dev->bdev;
    bio->bi_iter.bi_sector = sc->stripe[stripe].physical_start +
                             (sector * sc->stripe_width) +
                             (bio->bi_iter.bi_sector % sc->stripe_width);

    return DM_MAPIO_REMAPPED;
}

struct dm_snapshot {
    struct rw_semaphore lock;

    struct dm_dev *origin;    /* 原始设备 */
    struct dm_dev *cow;       /* COW设备 */

    /* 异常存储 */
    struct dm_exception_store *store;

    /* 异常哈希表 */
    struct exception_table complete;
    struct exception_table pending;

    /* 块大小 */
    uint32_t chunk_size;
    uint32_t chunk_shift;

    /* 位图跟踪 */
    unsigned long *tracked_chunk_bitset;
};

/* COW处理 */
static int snapshot_map(struct dm_target *ti, struct bio *bio)
{
    struct dm_snapshot *s = ti->private;
    chunk_t chunk;

    chunk = bio->bi_iter.bi_sector >> s->chunk_shift;

    /* 查找异常映射 */
    e = dm_lookup_exception(&s->complete, chunk);
    if (e) {
        /* 已复制，重定向到COW设备 */
        remap_exception(s, e, bio, chunk);
        return DM_MAPIO_REMAPPED;
    }

    /* 首次写入，触发COW */
    if (bio_data_dir(bio) == WRITE) {
        pe = __lookup_pending_exception(s, chunk);
        if (!pe) {
            /* 创建挂起异常 */
            pe = alloc_pending_exception(s);
            start_copy(pe);
        }
        bio_list_add(&pe->origin_bios, bio);
        return DM_MAPIO_SUBMITTED;
    }

    /* 读操作，直接访问原始设备 */
    bio->bi_bdev = s->origin->bdev;
    return DM_MAPIO_REMAPPED;
}

struct thin_c {
    struct dm_pool_metadata *pmd;    /* 元数据 */
    struct dm_bio_prison *prison;    /* bio监狱 */

    struct pool {
        struct bio_list deferred_bios;
        struct workqueue_struct *wq;

        /* 数据块分配 */
        dm_block_t offset_mask;
        dm_block_t low_water_blocks;

        /* 精简设备列表 */
        struct list_head active_thins;
    } *pool;

    dm_thin_id dev_id;
    struct dm_thin_device *td;
};

/* 精简映射 */
static int thin_map(struct dm_target *ti, struct bio *bio)
{
    struct thin_c *tc = ti->private;
    dm_block_t block = bio->bi_iter.bi_sector >> tc->pool->block_shift;
    struct dm_thin_lookup_result result;

    /* 查找映射 */
    r = dm_thin_find_block(tc->td, block, 1, &result);

    if (r == 0) {
        /* 块已分配 */
        remap_to_pool(tc, bio, result.block);
        return DM_MAPIO_REMAPPED;
    }

    if (r == -ENODATA) {
        /* 块未分配 */
        if (bio_data_dir(bio) == READ) {
            /* 读零 */
            zero_fill_bio(bio);
            bio_endio(bio);
            return DM_MAPIO_SUBMITTED;
        }

        /* 写时分配 */
        schedule_zero_fill_copy(tc, bio);
        return DM_MAPIO_SUBMITTED;
    }

    return DM_MAPIO_KILL;
}

struct crypt_config {
    struct dm_dev *dev;
    sector_t start;

    /* 加密参数 */
    struct crypto_skcipher *tfm;
    char *cipher_string;
    unsigned key_size;
    u8 *key;

    /* IV生成 */
    struct iv_operations {
        int (*ctr)(struct crypt_config *cc);
        void (*dtr)(struct crypt_config *cc);
        int (*generator)(struct crypt_config *cc, u8 *iv,
                        struct dm_crypt_request *dmreq);
    } *iv_gen_ops;

    /* 工作队列 */
    struct workqueue_struct *queue;
    struct workqueue_struct *crypt_queue;

    /* 内存池 */
    mempool_t *req_pool;
    mempool_t *page_pool;
};

/* 加密I/O处理 */
static int crypt_map(struct dm_target *ti, struct bio *bio)
{
    struct crypt_config *cc = ti->private;
    struct dm_crypt_io *io;

    /* 分配加密I/O上下文 */
    io = mempool_alloc(cc->io_pool, GFP_NOIO);
    io->cc = cc;
    io->base_bio = bio;
    io->sector = bio->bi_iter.bi_sector;

    if (bio_data_dir(bio) == READ) {
        /* 读：先读取加密数据，后解密 */
        kcryptd_queue_read(io);
    } else {
        /* 写：先加密，后写入 */
        kcryptd_queue_crypt(io);
    }

    return DM_MAPIO_SUBMITTED;
}

# 创建加密设备
cryptsetup luksFormat /dev/sdb1
cryptsetup open /dev/sdb1 encrypted
mkfs.ext4 /dev/mapper/encrypted

/* 前向合并：新bio合并到已有request前面 */
bool blk_attempt_front_merge(struct request_queue *q,
                             struct request *rq, struct bio *bio)
{
    if (!blk_rq_merge_ok(rq, bio))
        return false;

    if (!ll_front_merge_fn(q, rq, bio))
        return false;

    /* 更新request */
    rq->__sector = bio->bi_iter.bi_sector;
    rq->__data_len += bio->bi_iter.bi_size;

    /* 链接bio */
    bio->bi_next = rq->bio;
    rq->bio = bio;

    return true;
}

/* 后向合并：新bio合并到已有request后面 */
bool blk_attempt_back_merge(struct request_queue *q,
                            struct request *rq, struct bio *bio)
{
    if (!blk_rq_merge_ok(rq, bio))
        return false;

    if (!ll_back_merge_fn(q, rq, bio))
        return false;

    /* 更新request */
    rq->__data_len += bio->bi_iter.bi_size;

    /* 链接bio */
    rq->biotail->bi_next = bio;
    rq->biotail = bio;

    return true;
}

struct file_ra_state {
    pgoff_t start;          /* 预读窗口起始 */
    unsigned int size;      /* 当前窗口大小 */
    unsigned int async_size;/* 异步预读大小 */
    unsigned int ra_pages;  /* 最大预读页数 */
    unsigned int mmap_miss; /* mmap缓存未命中计数 */
    loff_t prev_pos;       /* 上次读取位置 */
};

/* 预读算法 */
static unsigned long get_next_ra_size(struct file_ra_state *ra,
                                      unsigned long max)
{
    unsigned long cur = ra->size;
    unsigned long newsize;

    if (cur < max / 16)
        newsize = 4 * cur;    /* 快速增长 */
    else
        newsize = 2 * cur;    /* 线性增长 */

    return min(newsize, max);
}

struct bdi_writeback {
    struct backing_dev_info *bdi;

    unsigned long state;
    unsigned long last_old_flush;

    struct list_head b_dirty;      /* 脏inode列表 */
    struct list_head b_io;         /* 正在写回列表 */
    struct list_head b_more_io;    /* 需要更多I/O列表 */
    struct list_head b_dirty_time; /* 只有时间戳变化 */

    struct percpu_counter stat[NR_WB_STAT_ITEMS];
};

/* 写回控制参数 */
int dirty_background_ratio = 10;  /* 后台写回阈值10% */
int dirty_ratio = 20;             /* 前台写回阈值20% */
unsigned int dirty_expire_interval = 30 * HZ; /* 30秒过期 */

struct disk_stats {
    unsigned long sectors[NR_STAT_GROUPS];  /* 读写扇区数 */
    unsigned long ios[NR_STAT_GROUPS];      /* I/O次数 */
    unsigned long merges[NR_STAT_GROUPS];   /* 合并次数 */
    unsigned long ticks[NR_STAT_GROUPS];    /* I/O时间 */
    unsigned long io_ticks;                 /* 总I/O时间 */
    unsigned long time_in_queue;            /* 队列时间 */
};

# 字段说明：
# 1-3: 主次设备号和设备名
# 4: 读完成次数
# 5: 合并读次数
# 6: 读扇区数
# 7: 读耗时(ms)
# 8-11: 写相关统计
# 12: 正在进行的I/O
# 13: I/O耗时
# 14: 加权I/O耗时

cat /proc/diskstats

void blk_mq_bio_to_request(struct request *rq, struct bio *bio)
{
    rq->__sector = bio->bi_iter.bi_sector;
    rq->__data_len = bio->bi_iter.bi_size;
    rq->bio = rq->biotail = bio;
}

# 检查挂起的I/O
cat /proc/<pid>/stack
cat /sys/kernel/debug/block/<dev>/hctx*/busy

# 使用blktrace追踪
blktrace -d /dev/sda -o trace
blkparse -i trace

# 监控队列深度
iostat -x 1

# 查看调度器统计
cat /sys/block/sda/queue/scheduler
grep . /sys/block/sda/queue/iosched/*

# 设置合理的脏页比例
echo 5 > /proc/sys/vm/dirty_background_ratio
echo 10 > /proc/sys/vm/dirty_ratio

# 调整预读大小
blockdev --setra 256 /dev/sda

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

# 启用多队列
echo 8 > /sys/block/sda/queue/nr_requests

# 顺序读写
fio --name=seq --rw=write --bs=1M --size=10G

# 随机IOPS
fio --name=rand --rw=randread --bs=4K --iodepth=32

# 混合负载
fio --name=mixed --rw=randrw --rwmixread=70 --bs=4K

# 模拟I/O错误
echo 1 > /sys/block/sda/make-it-fail

# 模拟I/O延迟
echo "100" > /sys/kernel/debug/fail_io_timeout/probability