笔触狂放9

这个屌丝很懒，什么也没留下！

热门标签

VirtIO实现原理——virtblk设备初始化

作者：笔触狂放9 | 2024-07-26 11:28:52

踩

virtio设备是指基于virtio-pci总线实现的磁盘、网络、console等设备。Qemu实现了如下virtio设备：

1af4:1041  network device (modern)
1af4:1042  block device (modern)
1af4:1043  console device (modern)
1af4:1044  entropy generator device (modern)
1af4:1045  balloon device (modern)
1af4:1048  SCSI host bus adapter device (modern)
1af4:1049  9p filesystem device (modern)
1af4:1050  virtio gpu device (modern)
1af4:1052  virtio input device (modern)
1
2
3
4
5
6
7
8
9

我们本章介绍其中的virtio-block设备初始化，下面简称virtblk。

总线注册

virtio bus的注册是所有virtio设备注册的基础，所有virtio设备的探测都是在virtio bus注册完成后进行的。从virtio bus注册到最后的设备探测，整个步骤如下：

注册virtio bus
注册virtio设备驱动，比如virtio net driver或者virtio blk driver
注册virtio设备
触发驱动核心match操作virtio_dev_match
match成功后驱动调用probe函数（virtnet_probe/virtblk_probe）探测virtio设备

流程的示意图如下：
我们从virtio bus的注册开始分析，和linux的其它总线一样，virtio bus也在系统初始化的时候注册，过程如下：

static struct bus_type virtio_bus = {
    .name  = "virtio",
    .match = virtio_dev_match,
    .dev_groups = virtio_dev_groups,
    .uevent = virtio_uevent,
    .probe = virtio_dev_probe,
    .remove = virtio_dev_remove,
}; 

virtio_init
	bus_register(&virtio_bus)
1
2
3
4
5
6
7
8
9
10
11

virtio总线注册后，在sysfs文件系统下生成virtio目录，并创建devices和drivers子目录

驱动注册

驱动的注册流程如下：

static struct virtio_driver virtio_blk = {
    .feature_table          = features,
    .feature_table_size     = ARRAY_SIZE(features),
    .feature_table_legacy       = features_legacy,
    .feature_table_size_legacy  = ARRAY_SIZE(features_legacy),
    .driver.name            = KBUILD_MODNAME,
    .driver.owner           = THIS_MODULE,
    .id_table           = id_table,			/* 1 */
    .probe              = virtblk_probe,	/* 2 */
    .remove             = virtblk_remove,
    .config_changed         = virtblk_config_changed,
#ifdef CONFIG_PM_SLEEP
    .freeze             = virtblk_freeze,
    .restore            = virtblk_restore,
#endif
}; 

register_virtio_driver(&virtio_blk)
	driver->driver.bus = &virtio_bus	// 将virtio_blk驱动的总线指向virtio
	driver_register(&driver->driver)	// 注册驱动
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1. virtio_driver结构体中有一个id_table字段在驱动加载时起重要作用，virtio总线在match设备时会拿这里定义的id取比较设备的id，如果相等，认为匹配成功，然后将设备与驱动绑定，这里定义了一组ID，设置id.device为2，id.vendor为VIRTIO_DEV_ANY_ID。只要virtio设备的device能匹配驱动的device，就认为match成功。这里为什么device id是2？原因是 virtio-pci设备在探测过程中记录device id到virtio_device.id.device时对其做了处理，如果为modern(1.0)设备，要减去0x1040。
2. probe方法在驱动匹配后被调用，进一步地对virtio-blk驱动的加载，根据virtio-blk规范中的定义解析pci的bar空间。
1
2

仔细看virtio_blk驱动的id_table，后面

struct virtio_device_id {
    __u32 device;
    __u32 vendor;
};
#define VIRTIO_ID_BLOCK     2 /* virtio block */
static const struct virtio_device_id id_table[] = {
    { VIRTIO_ID_BLOCK, VIRTIO_DEV_ANY_ID },
    { 0 },
}; 

virtio_pci_modern_probe
	vp_dev->vdev.id.device = pci_dev->device - 0x1040;
1
2
3
4
5
6
7
8
9
10
11
12

驱动注册成功后，在sysfs目录创建了virtio_blk目录，同时创建了设备驱动卸载的unbind属性文件

设备探测

specification

match

当virtio设备往virtio总线注册后，触发virtio_bus的match流程如下：

/* This looks through all the IDs a driver claims to support.  If any of them
 * match, we return 1 and the kernel will call virtio_dev_probe(). */
static int virtio_dev_match(struct device *_dv, struct device_driver *_dr)
{
    unsigned int i;
    struct virtio_device *dev = dev_to_virtio(_dv);
    const struct virtio_device_id *ids;

    ids = drv_to_virtio(_dr)->id_table;	// 取出驱动定义的id
    for (i = 0; ids[i].device; i++)
        if (virtio_id_match(dev, &ids[i]))
            return 1;
    return 0;
}

static inline int virtio_id_match(const struct virtio_device *dev,
                  const struct virtio_device_id *id)
{
    if (id->device != dev->id.device && id->device != VIRTIO_DEV_ANY_ID)
        return 0;

    return id->vendor == VIRTIO_DEV_ANY_ID || id->vendor == dev->id.vendor;
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

match动作比较简单，只要驱动的device id和设备的device id相等，认为match成功，随后进行virtio-blk的设备探测

驱动加载

virtio-blk设备的探测，主要是读取BAR空间中virtio-blk的配置结构virtio_blk_config，根据得到的信息进行virtqueue初始化，通用块设备初始化，virtio-blk设备初始化。

virtblk配置空间布局

virio-pci的配置空间中，除了通用的common，isr和notify cap之外，还有一个device-specific config cap，它的结构不一，和具体的virtio设备有关，对于virtio-blk设备，其device-specific config结构为virtio_blk_config，如下图：

virtqueue初始化

设备探测的入口点是virtblk_probe，virtqueue初始化在其后，函数调用如下：

virtblk_probe
    init_vq
        virtio_cread_feature(vdev, VIRTIO_BLK_F_MQ,			/* 读取pci配置空间中的磁盘队列数 */
                   struct virtio_blk_config, num_queues,
                   &num_vqs);
		num_vqs = min_t(unsigned int, nr_cpu_ids, num_vqs);	/* 取配置队列数与CPU总数的最小值，作为队列数 */
        virtio_find_vqs
            vdev->config->find_vqs(vdev, nvqs, vqs, callbacks, names, NULL, desc)   
            virtio_pci_config_ops.find_vqs
            vp_find_vqs
                vp_find_vqs_msix
                    vp_setup_vq
                        vp_dev->setup_vq
1
2
3
4
5
6
7
8
9
10
11
12
13

在drivers/virtio/virtio_pci_modern.c中有setup_vq的具体实现，这是virtqueue的初始化核心

static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev,
                  struct virtio_pci_vq_info *info,
                  unsigned index,
                  void (*callback)(struct virtqueue *vq),
                  const char *name,
                  u16 msix_vec)
{ 
	......
	if (index >= vp_ioread16(&cfg->num_queues))						/* 1 */
     	return ERR_PTR(-ENOENT);

    /* Select the queue we're interested in */						/* 2 */
    vp_iowrite16(index, &cfg->queue_select);

    /* Check if queue is either not available or already active. */
    num = vp_ioread16(&cfg->queue_size);
    if (!num || vp_ioread16(&cfg->queue_enable))
        return ERR_PTR(-ENOENT);
        
    /* get offset of notification word for this vq */				/* 3 */
    off = vp_ioread16(&cfg->queue_notify_off);

    vq = vring_create_virtqueue(index, num,							/* 4 */
                    SMP_CACHE_BYTES, &vp_dev->vdev,
                    true, true, vp_notify, callback, name);

    /* activate the queue */										/* 5 */
    vp_iowrite16(virtqueue_get_vring_size(vq), &cfg->queue_size);
    vp_iowrite64_twopart(virtqueue_get_desc_addr(vq),
                 &cfg->queue_desc_lo, &cfg->queue_desc_hi);
    vp_iowrite64_twopart(virtqueue_get_avail_addr(vq),
                 &cfg->queue_avail_lo, &cfg->queue_avail_hi);
    vp_iowrite64_twopart(virtqueue_get_used_addr(vq),
                 &cfg->queue_used_lo, &cfg->queue_used_hi);
                 
 	vq->priv = (void __force *)vp_dev->notify_base +				/* 6 */
            off * vp_dev->notify_offset_multiplier;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

1. 读取Host侧设置的队列数，如果要设置的队列位置超出了Host设置的队列数，返回 
2. 选择要操作的队列，这时virtio规范定义的动作，一个virtio-blk设备可能有多个队列，当要操作其中某个队列时，首先通过queue_select字段告知
后端
3. virtqueue的队列深度由Host设置，读取队列深度，队列初始化时环的长度，descriptor表的长度都是这个
4. 创建一个vring
5. 创建成功，需要通知后端，前端创建的virtqueue的地址
6. 根据virtio规范计算notify字段的地址，当Guest想通知后端有数据到来时，需要向这个字段写入队列的idx
1
2
3
4
5
6
7

BLK-MQ初始化

blk-mq框架简介

传统磁盘因其工作原理随机访问比顺序访问性能低很多，内核块设备IO系统设计之初针对这种情况的主要优化手段是缓存用户态IO请求并尽可能合并，保证IO请求顺序访问磁盘。在实现时设计单队列存储用户态对块设备的IO请求，一把锁保护该队列上的IO请求数据结构。传统磁盘IO性能瓶颈在于硬件，跨分区访问，随机访问的速度远远没法和磁盘软件栈的处理速度匹配。使用单队列的传统Linux块设备架构图如下：
固态硬盘和NVME磁盘在并发访问上的性能较传统提升很多，硬件磁盘能够及时处理单队列的块设备IO请求，此时优化IO性能的手段是让多个CPU向磁盘驱动并发提交IO请求。单队列的锁转而成为多个CPU并发执行IO请求的软件瓶颈，为解决这个问题内核设计了Multi-Queue Block IO Queueing Mechanism（blk-mq）框架，使用多个队列缓存IO请求，每个socket或CPU独享一个队列。将对单队列拆成多队列，将原来的一把大锁拆成多个小锁，不同队列可独立处理IO请求并提交给硬件磁盘，没有了大锁的竞争和CPU跨NUMA访问性能开销。如下图所示：
blk-mq的思想是设计两级队列来处理IO请求，一级队列作为传统队列的扩展，缓存IO并合并请求，基于一级队列可以实现Qos和IO调度器，二级队列用来缓存将要并发提交到磁盘的IO。前者称为软件暂存队列Software staging queues（下文称软件队列），后者称为硬件分发队列Hardware dispatch queues（硬件队列）。软件队列的个数由内核设备层驱动层基于用户程序（比如fio工具）的IO队列深度动态调整，用户程序IO队列越深软件队列数越多，但范围一定在系统socket数和CPU数之间。硬件队列数由厂商的磁盘驱动绝对，磁盘驱动会访问该磁盘最佳队列数和队列深度，块设备层驱动根据此信息分配相匹配的硬件队列数，下图是一个磁盘驱动队列数的配置：
在blk-mq框架设计中，设备驱动除了提供硬件队列数，还需要提供软件队列到硬件队列的映射函数，告诉块设备驱动如果实现软件队列到硬件队列的映射。
blk-mq框架中还引入了tagged IO概念，一个IO的tag是个整数，范围在0到硬件队列深度（[0, hw_queue_depth]）之间，用来唯一标记块设备层驱动提交的IO在硬件队列的位置，当设备驱动完成该IO后，会根据IO的tag找到它在硬件队列的位置，将此IO标记为完成。通过引入tagged IO，原来通过块设备层驱动主动线性搜索才能标记IO完成的动作，现在只需要设备驱动根据IO的tagged来找到对应位置，标记IO完成，从而减少了IO延迟。
从上面的介绍我们可以得出，blk-mq框架需要设备驱动需要做3个事情，如下：

提供磁盘设备处理IO的最佳队列数和队列深度。
提供块设备层软件队列到硬件队列的映射函数。
增加tagged IO逻辑，当一个tagged IO完成后，设备驱动需要在硬件队列上标记其已完成。

在虚拟化场景下，因为磁盘不是真实物理磁盘，但仍然使用blk-mq的机制，所以以上工作都需要在virtblk驱动加载过程中完成，原来由设备驱动负责的工作现在需要virtblk驱动来完成。

blk-mq数据结构

blk_mq_queue_map

blk_mq_queue_map用来存放软件队列到硬件队列的映射关系

struct blk_mq_queue_map {
  unsigned int *mq_map;			/* 1 */
  unsigned int nr_queues;		/* 2 */
  unsigned int queue_offset;	/* 3 */
};
1
2
3
4
5

mq_map存放的是硬件队列的索引，由于软件队列个数最多为CPU个，因此mq_map数组长度为CPU的个数，mq_map[N]中存放的即CPU-N在硬件队列中的索引。
硬件队列的个数。
软件队列映射的硬件队列起始偏移，queue_offset和nr_queues一起，限定了CPU映射的队列范围在[queue_offset, queue_offset+nr_queues]

假设现在mq_map[5]为9，可以解析到映射关系为：CPU-5上软件队列会被映射到queue_offset+9这个队列上。

blk_mq_tag_set

blk_mq_tag_set用来标志每一个IO请求在硬件队列的位置，这个数据结构硬件队列和设备驱动共享。

/** 
 * enum hctx_type - Type of hardware queue
 * @HCTX_TYPE_DEFAULT:  All I/O not otherwise accounted for.
 * @HCTX_TYPE_READ: Just for READ I/O.
 * @HCTX_TYPE_POLL: Polled I/O of any kind.
 * @HCTX_MAX_TYPES: Number of types of hctx.
 */
enum hctx_type { 
    HCTX_TYPE_DEFAULT,
    HCTX_TYPE_READ,
    HCTX_TYPE_POLL, 
    
    HCTX_MAX_TYPES,
};
struct blk_mq_tag_set {
  struct blk_mq_queue_map map[HCTX_MAX_TYPES];	/* 1 */
  unsigned int            nr_maps;				
  const struct blk_mq_ops *ops;					/* 2 */
  unsigned int            nr_hw_queues;			/* 3 */
  unsigned int            queue_depth;			/* 4 */
  ......
  void *driver_data;							/* ? */
  struct blk_mq_tags      **tags;				/* 5 */
  struct blk_mq_tags      *shared_tags;
  ......
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

map，软件队列到硬件队列的映射关系，blk-mq设计了不同类型的硬件队列，每种队列都可以有自己的映射关系，因此map是一个数组。nr_maps表示map的元素个数。
ops，设备驱动提供给块设备层的用于提交IO请求的方法。
nr_hw_queues，硬件队列个数。
queue_depth，硬件队列深度。
tags，标记每个IO请求在硬件队列位置的数组。数组元素个数即为硬件队列的个数。

virtio_blk

virtio_blk是virtblk磁盘的核心数据结构，它将内核的磁盘数据结构和blk-mq相关数据结构与virtblk的队列关联起来，让virtblk磁盘在内核层面看起来和普通块设备一样且兼容blk-mq框架，但后端却是通过virtblk的队列实现磁盘IO。

struct virtio_blk {
    /*
     * This mutex must be held by anything that may run after
     * virtblk_remove() sets vblk->vdev to NULL.
     *
     * blk-mq, virtqueue processing, and sysfs attribute code paths are
     * shut down before vblk->vdev is set to NULL and therefore do not need
     * to hold this mutex.
     */ 
    struct mutex vdev_mutex;
    struct virtio_device *vdev;	/* 关联的virtio设备 */
    
    /* The disk structure for the kernel. */
    struct gendisk *disk;		/* 关联的内核磁盘设备 TODO */
        
    /* Block layer tags. */
    struct blk_mq_tag_set tag_set;	/* 关联块设备层需要的tag */
	......
    /* num of vqs */
    int num_vqs;
    int io_queues[HCTX_MAX_TYPES];	/* 每类硬件队列的队列数 */
    struct virtio_blk_vq *vqs;		/* virtio队列 */
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

blk-mq初始化

下图为基于数据结构描绘的blk-mq队列映射关系，blk-mq初始化的主要内容就是把这样的blk-mq框架建立起来。

设置硬件队列

virtblk磁盘队列由驱动厂商来实现，块设备层依据这个信息初始化硬件队列。下图为virtio-blk内核模块设置的队列深度：
virtblk驱动根据解析内核模块参数queue_depth，存放到全局变量virtblk_queue_depth中，在virtblk设备探测过程中，首先判断virtio-blk模块是否设置队列深度，如果没有设置，则取virtblk队列中当前空闲队列深度的二分之一，在设备探测阶段，通常就是整个virtblk队列深度的二分之一。如果virtio-blk模块设置了队列深度，则取设置的队列深度。

static unsigned int virtblk_queue_depth;	/* 存放virtio-blk模块的队列深度参数 */
module_param_named(queue_depth, virtblk_queue_depth, uint, 0444);	/* 定义virtio-blk queue_depth参数 */

virtblk_probe
	unsigned int queue_depth;
    /* Default queue sizing is to fill the ring. */
    if (likely(!virtblk_queue_depth)) {	/* virtio-blk模块参数未设置 */
        queue_depth = vblk->vqs[0].vq->num_free;	/* 取当前virtblk队列的空闲长度*/
        /* ... but without indirect descs, we use 2 descs per req */
        if (!virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC))
            queue_depth /= 2;				
    } else {
        queue_depth = virtblk_queue_depth;	/* 取设置的virtio-blk参数 */
    }

vblk->tag_set.queue_depth = queue_depth;	/* 设置硬件队列深度 */
vblk->tag_set.nr_hw_queues = vblk->num_vqs;	/* 设置硬件队列个数为virtblk队列个数 */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

virtio-blk磁盘在探测时，驱动把virtblk队列的数量设置成了块设备层的硬件队列数量，说明IO在经过块设备层后，往virtio-blk块设备提交时的硬件队列就是virtblk的队列。但virtblk的队列怎么和块设备层定义的硬件队列挂钩呢？内核提供了struct blk_mq_ops中的map_queues方法，让块设备驱动可以指定自己的实现的队列作为硬件队列，virtblk驱动在virtio_mq_ops.map_queues中实现该逻辑，具体函数virtblk_map_queues：

static void virtblk_map_queues(struct blk_mq_tag_set *set)
{
    struct virtio_blk *vblk = set->driver_data;
    int i, qoff;
	
    for (i = 0, qoff = 0; i < set->nr_maps; i++) {
    	/*  对每类硬件队列，逐一取出 */
        struct blk_mq_queue_map *map = &set->map[i];
		/* 获取每类硬件队列的个数 */
        map->nr_queues = vblk->io_queues[i];
        /* 设置队列偏移 */
        map->queue_offset = qoff;
        qoff += map->nr_queues;
		/* 没有硬件队列可以映射 */
        if (map->nr_queues == 0)
            continue;

        /*
         * Regular queues have interrupts and hence CPU affinity is
         * defined by the core virtio code, but polling queues have
         * no interrupts so we let the block layer assign CPU affinity.
         */
        if (i == HCTX_TYPE_POLL)
        	/* 如果是POLL类型的硬件队列，由于没有中断访问，因此参考硬件拓扑做映射 */
            blk_mq_map_queues(&set->map[i]);
        else
        	/* 将硬件队列映射到其中断亲和的CPU对应的软件队列上 */
            blk_mq_virtio_map_queues(&set->map[i], vblk->vdev, 0);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

blk_mq_virtio_map_queues函数是virtblk驱动提供的默认的块设备软件队列到硬件队列的映射函数，分析这个函数的本质工作，就是为每个硬件队列映射一个CPU上的软件队列，软件队列和硬件队列可以是一对一、一对多的关系，由于需要描述CPU上的软件队列，因此函数的输入是一个长度为CPU个数的数组，用于存放每个CPU软件队列对应的硬件队列的索引，函数的职责就是为每个硬件队列找到对应的软件队列，然后填充到这个数组，完成映射。为了性能考虑，函数默认获取硬件队列的中断亲和性，找到其中断亲和的CPU，然后将该CPU对应的软件队列映射到硬件队列上。

/**
 * blk_mq_virtio_map_queues - provide a default queue mapping for virtio device
 * @qmap:   CPU to hardware queue map.		/* 用来存放每个CPU上软件队列对应的硬件队列 */
 * @vdev:   virtio device to provide a mapping for.
 * @first_vec:  first interrupt vectors to use for queues (usually 0)
 *
 * This function assumes the virtio device @vdev has at least as many available
 * interrupt vectors as @set has queues.  It will then query the vector
 * corresponding to each queue for it's affinity mask and built queue mapping
 * that maps a queue to the CPUs that have irq affinity for the corresponding
 * vector.
 */
void blk_mq_virtio_map_queues(struct blk_mq_queue_map *qmap,
        struct virtio_device *vdev, int first_vec)
{
    const struct cpumask *mask;
    unsigned int queue, cpu;
	/* virtio设备如果没有中断亲和性的设置，则使用平均分配，参考硬件拓扑将硬件队列平均分配到软件队列上 */
    if (!vdev->config->get_vq_affinity)
        goto fallback;
	/* 逐一取出硬件队列，获取其中断亲和的cpu，映射 */
    for (queue = 0; queue < qmap->nr_queues; queue++) {
        mask = vdev->config->get_vq_affinity(vdev, first_vec + queue);
        if (!mask)
            goto fallback;

        for_each_cpu(cpu, mask)
            qmap->mq_map[cpu] = qmap->queue_offset + queue;
    }

    return;

fallback:
    blk_mq_map_queues(qmap);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

tagged IO初始化

tagged IO初始化核心内容是初始化blk_mq_tag_set数据结构，如下：

virtblk_probe
    memset(&vblk->tag_set, 0, sizeof(vblk->tag_set));
    vblk->tag_set.ops = &virtio_mq_ops;
    vblk->tag_set.queue_depth = queue_depth;
    vblk->tag_set.numa_node = NUMA_NO_NODE;
    vblk->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
    vblk->tag_set.cmd_size =
        sizeof(struct virtblk_req) +
        sizeof(struct scatterlist) * sg_elems;
    vblk->tag_set.driver_data = vblk;
    vblk->tag_set.nr_hw_queues = vblk->num_vqs;
    
    err = blk_mq_alloc_tag_set(&vblk->tag_set);
    if (err)
        goto out_put_disk;

    q = blk_mq_init_queue(&vblk->tag_set);
    vblk->disk->queue = q;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

TODO

gendisk初始化

完成blk_mq_tag_set数据结构分配后，virtblk驱动基于该结构继续初始化gendisk(generic disk)数据结构，gendisk是块设备层中代表一个硬件块设备的核心数据结构，概念山该，一个gendisk可以包含多个硬件队列，可以包含多个磁盘分区，初始化gendisk同样在virtblk_probe流程中完成，blk_mq_alloc_disk函数实现该逻辑：

vblk->disk = blk_mq_alloc_disk(&vblk->tag_set, vblk);
	blk_mq_alloc_disk
		__blk_mq_alloc_disk
			blk_mq_init_queue_data
				blk_mq_init_allocated_queue
					blk_mq_realloc_hw_ctxs
						blk_mq_alloc_and_init_hctx
							blk_mq_init_hctx
1
2
3
4
5
6
7
8

TODO

virtio-blk设备状态

virtio-blk初始化或者运行过程中，理论上是有可能失败的，因此需要有一个前后端都可以看到的字段，用来记录virtio-blk的状态，可以根据此状态做相应的处理。这个字段就是设备状态域。它存在于virtio-pci附加配置空间的common config中。

/* Fields in VIRTIO_PCI_CAP_COMMON_CFG: */
struct virtio_pci_common_cfg {
	/* About the whole device. */
	__le32 device_feature_select;	/* read-write */
	__le32 device_feature;			/* read-only */
	__le32 guest_feature_select;	/* read-write */
	__le32 guest_feature;		/* read-write */
	__le16 msix_config;			/* read-write */
	__le16 num_queues;			/* read-only */
	__u8 device_status;			/* read-write */
	__u8 config_generation;		/* read-only */

	/* About a specific virtqueue. */
	__le16 queue_select;		/* read-write */
	__le16 queue_size;			/* read-write, power of 2. */
	__le16 queue_msix_vector;	/* read-write */
	__le16 queue_enable;		/* read-write */
	__le16 queue_notify_off;	/* read-only */
	__le32 queue_desc_lo;		/* read-write */
	__le32 queue_desc_hi;		/* read-write */
	__le32 queue_avail_lo;		/* read-write */
	__le32 queue_avail_hi;		/* read-write */
	__le32 queue_used_lo;		/* read-write */
	__le32 queue_used_hi;		/* read-write */
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

设备状态的取值如下:

/* Status byte for guest to report progress, and synchronize features. */
/* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */
#define VIRTIO_CONFIG_S_ACKNOWLEDGE	1
/* We have found a driver for the device. */
#define VIRTIO_CONFIG_S_DRIVER		2
/* Driver has used its parts of the config, and is happy */
#define VIRTIO_CONFIG_S_DRIVER_OK	4
/* Driver has finished configuring features */
#define VIRTIO_CONFIG_S_FEATURES_OK	8
/* Device entered invalid state, driver must reset it */
#define VIRTIO_CONFIG_S_NEEDS_RESET	0x40
/* We've given up on this device. */
#define VIRTIO_CONFIG_S_FAILED		0x80
1
2
3
4
5
6
7
8
9
10
11
12
13

ACKNOWLEDGE：标记Guest已经发现了设备并识别到它是一个virtio设备
DRIVER：标记Guest知道这个virtio设备是什么驱动，知道用什么驱动让它工作
DRIVER_OK：标记Guest驱动加载这个设备成功
FEATURES_OK ：标记Guest与Host完成特性协商
NEEDS_RESET：Host端标记该设备有问题，需要Guest复位
FAILED：Guest在初始化或者使用virtio设备过程中出了问题并且没法修复，Guest标记放弃这个设备，不使用

VIRTIO_CONFIG_S_ACKNOWLEDGE

Guest侧
virtblk注册成virtio设备时，会写pci配置空间的device_status字段，设置设备状态为VIRTIO_CONFIG_S_ACKNOWLEDGE

register_virtio_device		/* virtio设备注册 */
	virtio_add_status(dev, VIRTIO_CONFIG_S_ACKNOWLEDGE)	/* 通知后端已发现此virtio设备 */
		dev->config->set_status(dev, dev->config->get_status(dev) | status)
			vp_set_status
				iowrite8(status, vp_dev->ioaddr + VIRTIO_PCI_STATUS)	/* 传统实现：写pci配置空间的IO地址 */
1
2
3
4
5

Host侧
qemu在模拟pci设备时，将pci设备的配置空间注册为IO空间，一旦Guest有对此空间的读写，会触发qemu注册的读写回调

virtio_pci_device_plugged
  	memory_region_init_io(&proxy->bar, OBJECT(proxy), &virtio_pci_config_ops, proxy, "virtio-pci", size)
       	virtio_pci_config_ops
       		static const MemoryRegionOps virtio_pci_config_ops = {
    			.read = virtio_pci_config_read,
    			.write = virtio_pci_config_write,
				.....
			}
/* Guest写pci配置空间的引发qemu侧注册的pci配置空间写回调 */
virtio_pci_config_write
   	virtio_ioport_write
     	switch (addr) {				/* 判断客户机写的pci配置空间的字段 */
       	case VIRTIO_PCI_STATUS:		/* 匹配到device_status字段 */
       		virtio_set_status(vdev, val & 0xFF);
          	/* Linux before 2.6.34 drives the device without enabling
           	 the PCI device bus master bit. Enable it automatically
           	 for the guest. This is a PCI spec violation but so is
           	 initiating DMA with bus master bit clear. */
        	if (val == (VIRTIO_CONFIG_S_ACKNOWLEDGE | VIRTIO_CONFIG_S_DRIVER)) {
       		pci_default_write_config(&proxy->pci_dev, PCI_COMMAND,
                                     proxy->pci_dev.config[PCI_COMMAND] |
                                     PCI_COMMAND_MASTER, 1);
        	}
   		}        	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

VIRTIO_CONFIG_S_DRIVER

Guest侧
virtblk是一个virtio设备，因此Guest首先会将virtblk设备作为virtio设备进行注册，这是会触发virtio总线上的probe动作，为注册的virtio设备寻找匹配的驱动，VIRTIO_CONFIG_S_DRIVER状态就在probe的时候设置

virtio_dev_probe
	virtio_add_status(dev, VIRTIO_CONFIG_S_DRIVER)
1
2

Host侧
Host侧触发IO空间的回调，进入virtio_pci_config_write处理该状态，其核心动作除了将VIRTIO_CONFIG_S_DRIVER记录到qemu的数据结构以外，还会使能ioeventfd，也就是说，VIRTIO_CONFIG_S_DRIVER之后

virtio_pci_config_write
	virtio_ioport_write
		switch (addr) {				/* 判断客户机写的pci配置空间的字段 */
		case VIRTIO_PCI_STATUS:		/* 匹配到device_status字段 */
			virtio_set_status(vdev, val & 0xFF)
			if (val & VIRTIO_CONFIG_S_DRIVER_OK) {
            	virtio_pci_start_ioeventfd(proxy)
            		if (!bus->ioeventfd_grabbed) {
            			vdc->start_ioeventfd(vdev)	<=>	virtio_device_start_ioeventfd_impl
            		}
        	}
virtio_device_start_ioeventfd_impl			
	/* 为每个virtio queue分配一个eventfd并注册对应的读fd的回调 */	
	for (n = 0; n < VIRTIO_QUEUE_MAX; n++) {
        VirtQueue *vq = &vdev->vq[n];
        if (!virtio_queue_get_num(vdev, n)) {
            continue;
        }
        r = virtio_bus_set_host_notifier(qbus, n, true);				/* 分配eventfd */
        if (r < 0) {
            err = r;
            goto assign_error;
        }
        event_notifier_set_handler(&vq->host_notifier,
                                   virtio_queue_host_notifier_read);	/* 注册rfd读回调 */
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/885021

VirtIO实现原理——virtblk设备初始化

文章目录

总线注册

驱动注册

设备探测

specification

match

驱动加载

virtblk配置空间布局

virtqueue初始化

BLK-MQ初始化

blk-mq框架简介

blk-mq数据结构

blk_mq_queue_map

blk_mq_tag_set

virtio_blk

blk-mq初始化

设置硬件队列

tagged IO初始化

gendisk初始化

virtio-blk设备状态

VIRTIO_CONFIG_S_ACKNOWLEDGE

VIRTIO_CONFIG_S_DRIVER