qemu-kvm virtio 虚拟化-----Linux客户机 virtio设备初始化

Linux客户机 virtio设备初始化

virtio设备物理上连接在pci物理总线上，逻辑上连接在virtio虚拟总线。做为pci设备便于资源分配与配置，逻辑设备模型中，便于管理与组织。

1.qemu-kvm提供的virtio pci设备

virtio-blk(硬盘)，virtio-net（网络），virtio-balloon（气球）等pci设备，这些设备连接在pci总线上。代码位于qemu: hw/virtio-pci.c

static PCIDeviceInfo virtio_info[] = {

{

.qdev.name = "virtio-blk-pci",

},{

.qdev.name = "virtio-net-pci",

},{

.qdev.name = "virtio-serial-pci",

},{

.qdev.name = "virtio-balloon-pci",

},

}

static void virtio_pci_register_devices(void)

{

pci_qdev_register_many(virtio_info);

}

2.客户机PCI设备进行枚举和资源分配

当Linux客户机系统启动时，对PCI设备进行枚举和资源分配（配置PCI的配置空间），通常由BIOS完成。不过对Linux系统提供方式，一种由BIOS实现，另一种自己实现枚举和资源分配功能。代码位于kernel:arch/x86/pci/init.c

static __init int pci_arch_init(void)

{

#ifdef CONFIG_PCI_DIRECT

int type = 0;

type = pci_direct_probe();

#endif

#endif

#ifdef CONFIG_PCI_BIOS

pci_pcbios_init();

#endif

}

真正设备枚举和资源分配由这里开始

static int __init pci_legacy_init(void)

{

printk("PCI: Probing PCI hardware\n");

pci_root_bus = pcibios_scan_root(0);

if (pci_root_bus)

pci_bus_add_devices(pci_root_bus);

return 0;

}

pcibios_scan_root（）---->pci_scan_bus_parented()---->pci_scan_child_bus()--->pci_scan_slot()--->pci_scan_single_device()----->pci_device_add()

将PCI总线上的设备添加到链表

void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)

{

/*

* Add the device to our list of discovered devices

* and the bus list for fixup functions, etc.

*/

down_write(&pci_bus_sem);

list_add_tail(&dev->bus_list, &bus->devices);

up_write(&pci_bus_sem);

}

上述过程执行完成，在/sys/devices/pci0000:00目录下，创建virtio pci设备。并且在/sys/bus/pci/devices/目录下，创建相应对于pci设备的符号连接，同时在/sys/bus/pci/drivers/目录下，创建virtio-pci目录，目录下存在支持设备符号连接文件。

3.virtio总线定义与注册,virtio总线为虚拟的总线，目的为了设备管理与组织需要。代码位于：

static struct bus_type virtio_bus = {

.name = "virtio",

.match = virtio_dev_match,

.dev_attrs = virtio_dev_attrs,

.uevent = virtio_uevent,

.probe = virtio_dev_probe,

.remove = virtio_dev_remove,

};

static int virtio_init(void)

{

if (bus_register(&virtio_bus) != 0)

panic("virtio bus registration failed");

return 0;

}

上述注册函数调用执行完成，在/sys/bus/目录下，创建了一个新的目录virtio，在该目录下同时创建了两个文件夹为devices和drivers。表示创建virtio总线，总线支持设备与驱动devices和drivers目录下。

4. virtio-pci设备驱动加载

static struct pci_driver virtio_pci_driver = {

.name = "virtio-pci",

.id_table = virtio_pci_id_table,

.probe = virtio_pci_probe,

.remove = virtio_pci_remove,

#ifdef CONFIG_PM

.suspend = virtio_pci_suspend,

.resume = virtio_pci_resume,

#endif

};

static int __init virtio_pci_init(void)

{

virtio_pci_root = root_device_register("virtio-pci");

err = pci_register_driver(&virtio_pci_driver);

return err;

}

上述注册函数调用执行完成，在/sys/bus/pci/drivers和/sys/devices目录下创建了virtio-pci文件夹

5，virtio总线子设备注册

上面步骤2，对PCI设备进行枚举和资源分配中介绍了，枚举的设备，已经关联到总线链表中。对函数调用pci_register_driver(&virtio_pci_driver)就是对链表的每一个pci设备进行探测，该驱动是否支持该设备，如果支持进，调用驱动probe函数，完成启用该pci设备，同时在virtio总线进行注册设备。

bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);

if (drv->probe) {

ret = drv->probe(dev);

}

static int __devinit virtio_pci_probe(struct pci_dev *pci_dev,

const struct pci_device_id *id)

{

struct virtio_pci_device *vp_dev;

int err;

/* We only own devices >= 0x1000 and <= 0x103f: leave the rest. */

if (pci_dev->device < 0x1000 || pci_dev->device > 0x103f)

return -ENODEV;

/* allocate our structure and fill it out */

vp_dev = kzalloc(sizeof(struct virtio_pci_device), GFP_KERNEL);

if (vp_dev == NULL)

return -ENOMEM;

vp_dev->vdev.dev.parent = virtio_pci_root;

vp_dev->vdev.dev.release = virtio_pci_release_dev;

vp_dev->vdev.config = &virtio_pci_config_ops;

vp_dev->pci_dev = pci_dev;

INIT_LIST_HEAD(&vp_dev->virtqueues);

spin_lock_init(&vp_dev->lock);

/* Disable MSI/MSIX to bring device to a known good state. */

pci_msi_off(pci_dev);

/* enable the device */

err = pci_enable_device(pci_dev);

if (err)

goto out;

err = pci_request_regions(pci_dev, "virtio-pci");

if (err)

goto out_enable_device;

vp_dev->ioaddr = pci_iomap(pci_dev, 0, 0);

if (vp_dev->ioaddr == NULL)

goto out_req_regions;

pci_set_drvdata(pci_dev, vp_dev);

/* we use the subsystem vendor/device id as the virtio vendor/device

* id. this allows us to use the same PCI vendor/device id for all

* virtio devices and to identify the particular virtio driver by

* the subsytem ids */

vp_dev->vdev.id.vendor = pci_dev->subsystem_vendor;

vp_dev->vdev.id.device = pci_dev->subsystem_device;

/* finally register the virtio device */

err = register_virtio_device(&vp_dev->vdev);

if (err)

goto out_set_drvdata;

return 0;

}

上述注册函数调用执行完成，/sys/devices/virtio-pci/创建相应子设备{virtio1,virtio2,virtio3}，同时在/sys/bus/virtio/devices下面创建三个符号连接文件{virtio1,virtio2,virtio3}

6. virtio总线子设备驱动注册。

当virtio总线进行注册设备register_virtio_device，将调用virtio总线的probe函数：virtio_dev_probe（）。该函数遍历驱动，找到支持驱动关联到该设备。

register_virtio_device（）--->bus_probe_device()---->device_attach();

bus_for_each_drv(dev->bus, NULL, dev, __device_attach);

if (dev->bus->probe) {

ret = dev->bus->probe(dev);

}

static int virtio_dev_probe(struct device *_d)

{

int err, i;

struct virtio_device *dev = container_of(_d,struct virtio_device,dev);

struct virtio_driver *drv = container_of(dev->dev.driver,

struct virtio_driver, driver);

u32 device_features;

/* We have a driver! */

add_status(dev, VIRTIO_CONFIG_S_DRIVER);

/* Figure out what features the device supports. */

device_features = dev->config->get_features(dev);

/* Features supported by both device and driver into dev->features. */

memset(dev->features, 0, sizeof(dev->features));

for (i = 0; i < drv->feature_table_size; i++) {

unsigned int f = drv->feature_table[i];

BUG_ON(f >= 32);

if (device_features & (1 << f))

set_bit(f, dev->features);

}

/* Transport features always preserved to pass to finalize_features. */

for (i = VIRTIO_TRANSPORT_F_START; i < VIRTIO_TRANSPORT_F_END; i++)

if (device_features & (1 << i))

set_bit(i, dev->features);

dev->config->finalize_features(dev);

err = drv->probe(dev);

if (err)

add_status(dev, VIRTIO_CONFIG_S_FAILED);

else

add_status(dev, VIRTIO_CONFIG_S_DRIVER_OK);

return err;

}

//virtio_balloon设备驱动实例

static struct virtio_driver virtio_balloon_driver = {

.feature_table = features,

.feature_table_size = ARRAY_SIZE(features),

.driver.name = KBUILD_MODNAME,

.driver.owner = THIS_MODULE,

.id_table = id_table,

.probe = virtballoon_probe,

.remove = __devexit_p(virtballoon_remove),

.config_changed = virtballoon_changed,

};

static int __init init(void)

{

return register_virtio_driver(&virtio_balloon_driver);

}

同时在/sys/bus/virtio/drivers下面创建三个文件{virtio_balloon,virtio_blk,virtio_console},并且与设备发生关联

//////////////////////////////

热插拔事件的产生往往是由总线驱动级的逻辑处理，所以总线一般提供事件发送函数。例如virtio总线事件函数virtio_uevent。

static int virtio_uevent(struct device *_dv, struct kobj_uevent_env *env)

{

struct virtio_device *dev = container_of(_dv,struct virtio_device,dev);

return add_uevent_var(env, "MODALIAS=virtio:d%08Xv%08X",

dev->id.device, dev->id.vendor);

}

下面函数工作流程如下：

1.由设备对象往上查找，直到找到包含kset的kobject（总线包含着kset）

2.判断kobject对象是否提供filter，name，uevent函数，如果提供，调用它。

3.分配一个kobj_uevent_env，并开始填充env环境变量：ACTION,DEVPATH,SUBSYSTEM,SEQNUM,MODALIAS

4.通过netlink发送到用户空间

register_virtio_device（）---->device_register()---->device_add()---->kobject_uevent()---->kobject_uevent_env()

int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,

char *envp_ext[])

{

/* search the kset we belong to */

top_kobj = kobj;

while (!top_kobj->kset && top_kobj->parent)

top_kobj = top_kobj->parent;

kset = top_kobj->kset;

uevent_ops = kset->uevent_ops;

/* skip the event, if the filter returns zero. */

if (uevent_ops && uevent_ops->filter)

if (!uevent_ops->filter(kset, kobj)) {

pr_debug("kobject: '%s' (%p): %s: filter function "

"caused the event to drop!\n",

kobject_name(kobj), kobj, __func__);

return 0;

}

/* originating subsystem */

if (uevent_ops && uevent_ops->name)

subsystem = uevent_ops->name(kset, kobj);

else

subsystem = kobject_name(&kset->kobj);

/* environment buffer */

env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);

if (!env)

return -ENOMEM;

/* complete object path */

devpath = kobject_get_path(kobj, GFP_KERNEL);

if (!devpath) {

retval = -ENOENT;

goto exit;

}

/* default keys */

retval = add_uevent_var(env, "ACTION=%s", action_string);

if (retval)

goto exit;

retval = add_uevent_var(env, "DEVPATH=%s", devpath);

if (retval)

goto exit;

retval = add_uevent_var(env, "SUBSYSTEM=%s", subsystem);

if (retval)

goto exit;

/* keys passed in from the caller */

if (envp_ext) {

for (i = 0; envp_ext[i]; i++) {

retval = add_uevent_var(env, "%s", envp_ext[i]);

if (retval)

goto exit;

}

}

/* let the kset specific function add its stuff */

if (uevent_ops && uevent_ops->uevent) {

retval = uevent_ops->uevent(kset, kobj, env);

if (retval) {

pr_debug("kobject: '%s' (%p): %s: uevent() returned "

"%d\n", kobject_name(kobj), kobj,

__func__, retval);

goto exit;

}

}

/*

* Mark "add" and "remove" events in the object to ensure proper

* events to userspace during automatic cleanup. If the object did

* send an "add" event, "remove" will automatically generated by

* the core, if not already done by the caller.

*/

if (action == KOBJ_ADD)

kobj->state_add_uevent_sent = 1;

else if (action == KOBJ_REMOVE)

kobj->state_remove_uevent_sent = 1;

/* we will send an event, so request a new sequence number */

spin_lock(&sequence_lock);

seq = ++uevent_seqnum;

spin_unlock(&sequence_lock);

retval = add_uevent_var(env, "SEQNUM=%llu", (unsigned long long)seq);

if (retval)

goto exit;

/* send netlink message */

if (uevent_sock) {

struct sk_buff *skb;

size_t len;

/* allocate message with the maximum possible size */

len = strlen(action_string) + strlen(devpath) + 2;

skb = alloc_skb(len + env->buflen, GFP_KERNEL);

if (skb) {

char *scratch;

/* add header */

scratch = skb_put(skb, len);

sprintf(scratch, "%s@%s", action_string, devpath);

/* copy keys to our continuous event payload buffer */

for (i = 0; i < env->envp_idx; i++) {

len = strlen(env->envp[i]) + 1;

scratch = skb_put(skb, len);

strcpy(scratch, env->envp[i]);

}

NETLINK_CB(skb).dst_group = 1;

retval = netlink_broadcast(uevent_sock, skb, 0, 1,

GFP_KERNEL);

/* ENOBUFS should be handled in userspace */

if (retval == -ENOBUFS)

retval = 0;

} else

retval = -ENOMEM;

}

用户空间

当发送信息达到了用户空间，用户空间的udevd守护进程，接受到此信息。在udev规则文件里匹配，相应的规则。