Linux 内核块设备层深度实战：从 bio 请求到 blk-mq 多队列调度框架的完全工程指南

    struct block_device *bi_bdev;     // 目标块设备
    blk_opf_t        bi_opf;         // op + flags (READ/WRITE/FLUSH/DISCARD)
    unsigned short   bi_ioprio;      // I/O 优先级 (best-effort/realtime/idle)
    blk_status_t     bi_status;      // 完成状态
    atomic_t          __bi_remaining; // 引用计数 (多段拆分追踪)
    struct bio_vec    *bi_io_vec;     // 段数组
    struct bio_set    *bi_pool;       // 内存池来源
    unsigned short   bi_vcnt;        // 当前段数
    unsigned short   bi_max_vecs;    // 段数组容量
    struct bio_vec    bi_inline_vecs[];  // BIO_INLINE_VECS 内联优化
    void               (*bi_end_io)(struct bio *); // 完成回调
    void                *bi_private;    // 私有完成上下文
    bio_io_advance_fn *bi_iotype;  // I/O 统计分类
};

    unsigned int  bv_len;   // 段长度 (字节)
    unsigned int  bv_offset; // 页内偏移
};

void blk_finish_plug(struct blk_plug *plug)
{
    blk_mq_flush_plug_list(plug, false);
    kfree(plug);
}

    unsigned int       *map;           // hw_queue 映射表 [map_count]
    unsigned int       nr_maps;        // 映射类型数 (HCTX_TYPE_DEFAULT 等)
    unsigned int       nr_hw_queues;   // 硬件队列总数
    unsigned int       queue_depth;    // 每队列深度限制
    unsigned int       cmd_size;       // 私有命令体扩展大小
    int                 numa_node;        // NUMA 节点偏好
    void                *driver_data;      // 驱动层私有数据
};

    .commit_rqs   = my_commit_rqs,    // 批量提交到设备
    .get_budget   = my_get_budget,    // 限流预算获取
    .put_budget   = my_put_budget,    // 预算归还
    .timeout      = my_timeout,       // 超时处理 (用于 error recovery)
    .poll        = my_poll,         // 轮询完成模式 (高 IOPS 场景)
    .map_queue   = blk_mq_map_queue,// 物理映射到 hctx
    .init_hctx   = my_init_hctx,    // per-hw_queue 初始化钩子
    .exit_hctx   = my_exit_hctx,    // 清理钩子
    .init_request = my_init_request,   // request 分配后定制命令体
    .show_rq     = my_show_rq,      // /proc/调试输出
};

        break;
    default:
        return BLK_STS_IOERR;
    }
    return BLK_STS_OK;  // 异步完成，稍后 my_end_rq() 通知
}

├── scheduler          // 当前调度器 [mq-deadline bfq kyber none]
├── read_expire        // 读请求超时 (ms), 默认 500
├── write_expire       // 写请求超时 (ms), 默认 5000
├── writes_starved     // 写饿死前最大调度读次数, 默认 2
├── fifo_batch         // 单批下发量, 默认 16
├── front_merges       // 是否允许 front_merge, 布尔
├── nr_requests        // 队列深度上限, 默认 128
└── features           // 特性位图 (FUA/HEADMERGE/SG etc)

cat /sys/block/nvme0n1/queue/scheduler
[mq-deadline] kyber bfq none

# 切换到低延迟调度
echo none > /sys/block/nvme0n1/queue/scheduler

# 数据库场景启用 mq-deadline + 调大队列深度
echo mq-deadline > /sys/block/sda/queue/scheduler
echo 256 > /sys/block/sda/queue/nr_requests
echo 128 > /sys/block/sda/queue/read_expire

#include 
#include 
#include 
#include 

#define RAMDISK_SIZE  (64 * 1024 * 1024)  // 64 MB
#define RAMDISK_NAME  "myram"
#define SECTORSZ      512
#define MINORS         4

static int major;
static struct gendisk *disk;
static struct request_queue *queue;
static struct blk_mq_tag_set tag_set;
static u8 *data;   // vmalloc 后备内存
static DEFINE_SPINLOCK(lock);

/* --- blk-mq 操作集 --- */
static blk_status_t
myram_queue_rq(struct blk_hw_ctx *hctx, const struct blk_queue_ctx *bd)
{
    struct request *rq  = bd->rq;
    sector_t     sector = blk_rq_pos(rq);
    unsigned long offset = sector * SECTORSZ;
    blk_status_t  ret = BLK_STS_OK;
    struct bio_vec bv;
    struct req_iterator iter;

    if (offset + blk_rq_bytes(rq) > RAMDISK_SIZE) {
        blk_mq_end_request(rq, BLK_STS_IOERR);
        return BLK_STS_IOERR;
    }

    /* 遍历 request 中包含的所有 bio 段 */
    rq_for_each_segment(bv, rq, iter) {
        void *mem = kmap_local_page(bv.bv_page);
        unsigned long flags;

        switch (req_op(rq)) {
        case REQ_OP_READ:
            spin_lock_irqsave(&lock, flags);
            memcpy(mem + bv.bv_offset,
                   data + offset + iter.iter.bi_bvec_done,
                   bv.bv_len);
            spin_unlock_irqrestore(&lock, flags);
            break;
        case REQ_OP_WRITE:
            spin_lock_irqsave(&lock, flags);
            memcpy(data + offset + iter.iter.bi_bvec_done,
                   mem + bv.bv_offset,
                   bv.bv_len);
            spin_unlock_irqrestore(&lock, flags);
            break;
        default:
            ret = BLK_STS_IOERR;
            goto out;
        }
        kunmap_local(mem);
    }

out:
    blk_mq_end_request(rq, ret);
    return ret;
}

static const struct blk_mq_ops myram_ops = {
    .queue_rq = myram_queue_rq,
};

/* --- 注册与卸载 --- */
static int __init myram_init(void)
{
    int ret;

    major = register_blkdev(0, RAMDISK_NAME);
    if (major < 0 xss=removed>return major;

    data = vmalloc(RAMDISK_SIZE);
    if (!data) { ret = -ENOMEM; goto out_unreg; }

    disk = alloc_disk(MINORS);
    if (!disk) { ret = -ENOMEM; goto out_free; }

    memset(&tag_set, 0, sizeof(tag_set));
    tag_set.ops        = &myram_ops;
    tag_set.nr_hw_queues = 4;           // 4 个硬件队列
    tag_set.queue_depth  = 128;          // 每队列深度 128
    tag_set.numa_node    = NUMA_NO_NODE;
    tag_set.cmd_size     = 0;

    ret = blk_mq_alloc_tag_set(&tag_set);
    if (ret) goto out_free_disk;

    queue = blk_mq_init_queue(&tag_set);
    if (IS_ERR(queue)) { ret = PTR_ERR(queue); goto out_tagset; }

    blk_queue_logical_block_sizeblk_queue_max_hw_sectorsblk_queue_flag_set// SSD 标识
    queue->queuedata = (void *)disk;

    disk->major         = major;
    disk->first_minor  = 0;
    disk->minors       = MINORS;
    disk->fops         = &myram_fops;
    disk->private_data = data;
    sprintf(disk->disk_name, "%s", RAMDISK_NAME);
    set_capacity(disk, RAMDISK_SIZE / SECTORSZ);
    device_add_disk(NULL, disk, false);

    pr_info("myram: loaded, %u MB / %u queues
",
            RAMDISK_SIZE/(1024*1024), tag_set.nr_hw_queues);
    return 0;

out_tagset:    blk_mq_free_tag_set(&tag_set);
out_free_disk: put_disk(disk);
out_free:      vfree(data);
out_unreg:     unregister_blkdev(major, RAMDISK_NAME);
    return ret;
}

static void __exit myram_exit(void)
{
    del_gendisk(disk);
    blk_cleanup_disk(disk);      // 自动 put_disk+cleanup queue
    blk_mq_free_tag_set(&tag_set);
    vfree(data);
    unregister_blkdev(major, RAMDISK_NAME);
    pr_info("myram: unloaded
");
}

module_init(myram_init);
module_exit(myram_exit);
MODULE_LICENSE("GPL");

// Device: rbps 读上限 wbps 写上限 riops 读IOPS wiops 写IOPS
8:0 rbps=104857600 wbps=52428800 riops=2000 wiops=1000

# 检查 /sys/fs/cgroup/container-a/io.stat
// 字段: rbytes wbytes rios wios dbytes dios