// linux/genhd.h（简化）
struct gendisk {
    int major;                       // 主设备号
    int first_minor;                 // 起始次设备号
    int minors;                      // 次设备号数量（分区数+1。    const struct block_device_operations *fops;  // 操作函数集    struct request_queue *queue;     // 请求队列
    char disk_name[DISK_NAME_LEN];  // 设备名，如sda
    unsigned int flags;              // 标志位，如GENHD_FL_NO_PART
    // ... 更多字段
};

// linux/blkdev.h（简化）
struct block_device_operations {
    int (*open)(struct gendisk *disk, blk_mode_t mode);
    void (*release)(struct gendisk *disk);
    int (*ioctl)(struct block_device *bdev, blk_mode_t mode,
                 unsigned cmd, unsigned long arg);
    int (*getgeo)(struct block_device *bdev, struct hd_geometry *geo);
    // 6.8中owner字段已移除，模块引用计数由内核自动管理};

// linux/blk-mq.h（简化）
struct request_queue {
    struct blk_mq_tag_set *tag_set;  // blk-mq标签。    struct request *rq;              // 当前请求
    // ... 大量内部字段，驱动一般不直接操作
};

// linux/blk_types.h（简化）
struct bio {
    struct block_device *bi_bdev;    // 目标块设。    struct bvec_iter bi_iter;        // 迭代器，含bi_sector
    unsigned short bi_vcnt;          // bio_vec数量
    unsigned short bi_idx;           // 当前bio_vec索引
    struct bio_vec *bi_io_vec;       // bio_vec数组
    unsigned int bi_opf;             // 操作标志（读/。flush等）
    // ... 更多字段
};

struct bvec_iter {
    sector_t bi_sector;     // 起始扇区。    unsigned int bi_size;   // 剩余字节。    unsigned int bi_idx;    // 当前bio_vec索引
    unsigned int bi_bvec_done;  // 当前bio_vec内已处理字节。};

// linux/bvec.h
struct bio_vec {
    struct page *bv_page;    // 数据所在的内存。    unsigned int bv_len;     // 数据长度（字节）
    unsigned int bv_offset;  // 页内偏移
};

// my_blkdev.c - Linux 6.8 RAM磁盘驱动
#include <linux/module.h>
#include <linux/blk-mq.h>
#include <linux/blkdev.h>
#include <linux/genhd.h>
#include <linux/hdreg.h>
#include <linux/vmalloc.h>

#define MY_DISK_NAME    "myram"
#define MY_DISK_MINORS  1
#define MY_DISK_SIZE    (4 * 1024 * 1024)  // 4MB
#define SECTOR_SIZE     512
#define NUM_SECTORS     (MY_DISK_SIZE / SECTOR_SIZE)

// 驱动私有数据
struct my_blkdev {
    struct gendisk          *disk;      // 磁盘设备
    struct blk_mq_tag_set   tag_set;    // blk-mq标签。    void                    *data;      // 模拟磁盘的内存    spinlock_t              lock;       // 保护数据访问
};

static struct my_blkdev *my_dev;

// ---- blk-mq操作回调 ----

// 处理单个请求
static blk_status_t my_queue_rq(struct blk_mq_hw_ctx *hctx,
                                 const struct blk_mq_queue_data *bd)
{
    struct request *rq = bd->rq;
    struct my_blkdev *dev = rq->q->queuedata;
    struct bio_vec bvec;
    struct req_iterator iter;
    sector_t sector = blk_rq_pos(rq);
    loff_t offset = sector << SECTOR_SHIFT;
    loff_t remaining = blk_rq_bytes(rq);

    // 标记请求开始处。    blk_mq_start_request(rq);

    // 检查越。    if (offset + remaining > MY_DISK_SIZE) {
        blk_mq_end_request(rq, BLK_STS_IOERR);
        return BLK_STS_IOERR;
    }

    // 遍历请求中的每个bio。    rq_for_each_segment(bvec, rq, iter) {
        void *buf = kmap_local_page(bvec.bv_page);
        unsigned int len = bvec.bv_len;
        loff_t pos = offset + bvec.bv_offset;

        if (req_op(rq) == REQ_OP_READ) {
            // 读：从内存拷贝到bio
            memcpy(buf + bvec.bv_offset,
                   dev->data + pos, len);
        } else if (req_op(rq) == REQ_OP_WRITE) {
            // 写：从bio拷贝到内存            memcpy(dev->data + pos,
                   buf + bvec.bv_offset, len);
        }

        kunmap_local(buf);
        offset += len;
        remaining -= len;
    }

    blk_mq_end_request(rq, BLK_STS_OK);
    return BLK_STS_OK;
}

// 初始化硬件上下文
static int my_init_hctx(struct blk_mq_hw_ctx *hctx, void *data,
                         unsigned int index)
{
    return 0;
}

// blk-mq操作集static const struct blk_mq_ops my_mq_ops = {
    .queue_rq   = my_queue_rq,
    .init_hctx  = my_init_hctx,
};

// ---- block_device_operations ----

static int my_blk_open(struct gendisk *disk, blk_mode_t mode)
{
    struct my_blkdev *dev = disk->private_data;

    if (!dev)
        return -ENODEV;
    return 0;
}

static void my_blk_release(struct gendisk *disk)
{
    // RAM磁盘不需要特殊释放操。}

static int my_blk_ioctl(struct block_device *bdev, blk_mode_t mode,
                         unsigned int cmd, unsigned long arg)
{
    struct my_blkdev *dev = bdev->bd_disk->private_data;

    switch (cmd) {
    case HDIO_GETGEO: {
        struct hd_geometry geo;
        geo.cylinders = NUM_SECTORS / (4 * 16);
        geo.heads = 4;
        geo.sectors = 16;
        geo.start = 0;
        if (copy_to_user((void __user *)arg, &geo, sizeof(geo)))
            return -EFAULT;
        return 0;
    }
    default:
        return -ENOTTY;
    }
}

static const struct block_device_operations my_blk_fops = {
    .open       = my_blk_open,
    .release    = my_blk_release,
    .ioctl      = my_blk_ioctl,
};

// ---- 模块初始化与退。----

static int __init my_blkdev_init(void)
{
    int ret;

    // 分配私有数据
    my_dev = kzalloc(sizeof(*my_dev), GFP_KERNEL);
    if (!my_dev)
        return -ENOMEM;

    spin_lock_init(&my_dev->lock);

    // 分配模拟磁盘的内存    my_dev->data = vzalloc(MY_DISK_SIZE);
    if (!my_dev->data) {
        ret = -ENOMEM;
        goto fail_data;
    }

    // 分配gendisk
    my_dev->disk = blk_alloc_disk(NULL, NUMA_NO_NODE);
    if (IS_ERR(my_dev->disk)) {
        ret = PTR_ERR(my_dev->disk);
        goto fail_disk;
    }

    // 设置gendisk字段
    my_dev->disk->major = 0;  // 动态分配主设备。    my_dev->disk->first_minor = 0;
    my_dev->disk->minors = MY_DISK_MINORS;
    my_dev->disk->fops = &my_blk_fops;
    my_dev->disk->private_data = my_dev;
    snprintf(my_dev->disk->disk_name, DISK_NAME_LEN, MY_DISK_NAME);

    // 初始化blk-mq标签。    my_dev->tag_set.ops = &my_mq_ops;
    my_dev->tag_set.nr_hw_queues = 1;
    my_dev->tag_set.queue_depth = 128;
    my_dev->tag_set.numa_node = NUMA_NO_NODE;
    my_dev->tag_set.cmd_size = 0;
    my_dev->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
    my_dev->tag_set.driver_data = my_dev;

    ret = blk_mq_alloc_tag_set(&my_dev->tag_set);
    if (ret)
        goto fail_tag_set;

    // 创建请求队列
    my_dev->disk->queue = blk_mq_init_queue(&my_dev->tag_set);
    if (IS_ERR(my_dev->disk->queue)) {
        ret = PTR_ERR(my_dev->disk->queue);
        goto fail_queue;
    }
    my_dev->disk->queue->queuedata = my_dev;

    // 设置队列参数
    blk_queue_logical_block_size(my_dev->disk->queue, SECTOR_SIZE);
    blk_queue_physical_block_size(my_dev->disk->queue, SECTOR_SIZE);
    blk_queue_max_hw_sectors(my_dev->disk->queue, 256);
    set_capacity(my_dev->disk, NUM_SECTORS);

    // 注册磁盘，对用户空间可见
    ret = add_disk(my_dev->disk);
    if (ret)
        goto fail_add_disk;

    pr_info("my_blkdev: RAM磁盘已注册，大小 %d MB\n",
            MY_DISK_SIZE / 1024 / 1024);
    return 0;

fail_add_disk:
    blk_cleanup_queue(my_dev->disk->queue);
fail_queue:
    blk_mq_free_tag_set(&my_dev->tag_set);
fail_tag_set:
    put_disk(my_dev->disk);
fail_disk:
    vfree(my_dev->data);
fail_data:
    kfree(my_dev);
    return ret;
}

static void __exit my_blkdev_exit(void)
{
    // 删除磁盘
    del_gendisk(my_dev->disk);

    // 清理请求队列
    blk_cleanup_queue(my_dev->disk->queue);

    // 释放标签。    blk_mq_free_tag_set(&my_dev->tag_set);

    // 释放gendisk引用
    put_disk(my_dev->disk);

    // 释放模拟磁盘内存
    vfree(my_dev->data);

    kfree(my_dev);

    pr_info("my_blkdev: RAM磁盘已卸载\n");
}

module_init(my_blkdev_init);
module_exit(my_blkdev_exit);

MODULE_AUTHOR("linuxros");
MODULE_DESCRIPTION("Linux 6.8 RAM磁盘块设备驱动);
MODULE_LICENSE("GPL");

// 遍历bio中的每个段
struct bio_vec bvec;
struct bvec_iter iter;

bio_for_each_segment(bvec, bio, iter) {
    void *buf = kmap_local_page(bvec.bv_page);
    // 访问 buf + bvec.bv_offset，长bvec.bv_len
    kunmap_local(buf);
}

// 6.8推荐方式
void *buf = kmap_local_page(bvec.bv_page);
memcpy(dst, buf + bvec.bv_offset, bvec.bv_len);
kunmap_local(buf);

// 旧方式（6.8仍可用但不推荐）
void *buf = kmap_atomic(bvec.bv_page);
memcpy(dst, buf + bvec.bv_offset, bvec.bv_len);
kunmap_atomic(buf);

// 直接完成bio（不经过blk-mqbio_endio(bio);

// 通过blk-mq完成request
blk_mq_end_request(rq, BLK_STS_OK);    // 成功
blk_mq_end_request(rq, BLK_STS_IOERR); // IO错误
blk_mq_end_request(rq, BLK_STS_NOSPC); // 空间不足

// 从bio拷贝数据到迭代器（读操作集size_t bio_copy_to_iter(struct bio *bio, struct iov_iter *iter);

// 从迭代器拷贝数据到bio（写操作集size_t bio_copy_from_iter(struct bio *bio, struct iov_iter *iter);

// linux/blk-mq.h（简化）
struct blk_mq_tag_set {
    const struct blk_mq_ops *ops;     // 操作回调试    unsigned int nr_hw_queues;        // 硬件队列。    unsigned int queue_depth;         // 每个队列深度
    int numa_node;                    // NUMA节点
    unsigned int cmd_size;            // 驱动私有数据大小
    unsigned int flags;               // 标志。    void *driver_data;                // 驱动私有数据
    // ... 内部字段
};

// linux/blk-mq.h（简化）
struct blk_mq_ops {
    blk_status_t (*queue_rq)(struct blk_mq_hw_ctx *hctx,
                             const struct blk_mq_queue_data *bd);
    int (*init_hctx)(struct blk_mq_hw_ctx *hctx, void *data,
                     unsigned int index);
    void (*exit_hctx)(struct blk_mq_hw_ctx *hctx, unsigned int index);
    int (*init_request)(struct blk_mq_tag_set *set, struct request *rq,
                        unsigned int hctx_idx, unsigned int numa_node);
    void (*cleanup_rq)(struct request *rq);
    // ... 更多可选回调};

# 列出所有块设备的树形视图
lsblk

# 查看设备UUID和文件系统类blkid /dev/myram

# 查看分区
fdisk -l /dev/myram

# 查看块设备详细信息cat /proc/partitions

# 查看块设备队列参数ls /sys/block/myram/queue/

# 查看调度器
cat /sys/block/myram/queue/scheduler

# 查看队列深度
cat /sys/block/myram/queue/nr_requests

# 查看最大扇区数
cat /sys/block/myram/queue/max_hw_sectors_kb

# 查看逻辑块大小
cat /sys/block/myram/queue/logical_block_size

# 查看物理块大小
cat /sys/block/myram/queue/physical_block_size

# 安装blktrace
# Ubuntu/Debian: apt install blktrace
# CentOS/RHEL:   yum install blktrace

# 跟踪块设备的所有I/O事件
blktrace -d /dev/myram -o - | blkparse -i -

# 只跟。。timeout 5 blktrace -d /dev/myram -o - | blkparse -i -

# 输出到文件后分析
blktrace -d /dev/myram -o myram_trace
blkparse -i myram_trace -o myram_parsed.txt

# 安装fio
# Ubuntu/Debian: apt install fio
# CentOS/RHEL:   yum install fio

# 顺序读测试
fio --name=seqread --filename=/dev/myram \
    --rw=read --bs=4k --size=1M --numjobs=1 --time_based --runtime=10

# 随机写测试
fio --name=randwrite --filename=/dev/myram \
    --rw=randwrite --bs=4k --size=1M --numjobs=4 --time_based --runtime=10 \
    --iodepth=32

# 混合读写测试
fio --name=mixed --filename=/dev/myram \
    --rw=randrw --rwmixread=70 --bs=4k --size=1M \
    --numjobs=2 --time_based --runtime=10 --iodepth=16