qemu 挂载磁盘 qemu使用

转载

互联网小墨风 2024-08-04 16:43:28

文章标签 qemu 挂载磁盘初始化 bc ci 文章分类 机器学习人工智能

在计算机世界中存在众多的总线都叫做bus，比如pci总线，isa总线，这些总线将系统设备和cpu连接在一起，用于设备之间，设备和cpu之间进行通信。另外总线之间又可以通过各种转换器相连，这种转换器在计算机系统中被称之为桥，比如pci-pci桥用于pci总线的扩展。 pci-isa桥，用于pci总线扩展isa总线。这种桥设备使总线结构变成树状结构。但是在上一级总线看来下一级总线只不过是支持该总线协议的一个设备。

我们今天要做的就是分析qemu对总线机构的实现。其中bus.c就是各种总线的基础结构。今天我们先来分析bus.c的实现。

在分析bus.c之前我们来看看系统如何描述一个总线，和总线具备的基础能力。
在qdev-core.h里面定义了BusClass 和BusState分别代表bus的基类和对象

struct BusClass {
    ObjectClass parent_class;

    /* FIXME first arg should be BusState */
    void (*print_dev)(Monitor *mon, DeviceState *dev, int indent);
    char *(*get_dev_path)(DeviceState *dev);
    /*
     * This callback is used to create Open Firmware device path in accordance
     * with OF spec http://forthworks.com/standards/of1275.pdf. Individual bus
     * bindings can be found at http://playground.sun.com/1275/bindings/.
     */
    char *(*get_fw_dev_path)(DeviceState *dev);
    void (*reset)(BusState *bus);
    BusRealize realize;
    BusUnrealize unrealize;

    /* maximum devices allowed on the bus, 0: no limit. */
    int max_dev;
    /* number of automatically allocated bus ids (e.g. ide.0) */
    int automatic_ids;
};

print_dev 用于monitor监控调试使用
get_dev_path 用户获取总线上设备的路径
get_fw_dev_path 用于支持of规范
reset 用于重置bus
realize 用于bus的初始化
unrealize 用于bus的反初始化
max_dev 总线上最大支持的设备数
automatic_ids 用于给子设备命名

这里面定义了总线的基础能力，不同总线类型有不同的实现。

/**
 * BusState:
 * @hotplug_device: link to a hotplug device associated with bus.
 */
struct BusState {
    Object obj;
    DeviceState *parent;
    char *name;
    HotplugHandler *hotplug_handler;
    int max_index;
    bool realized;
    QTAILQ_HEAD(ChildrenHead, BusChild) children;
    QLIST_ENTRY(BusState) sibling;
};

BusState为总线的实例，obj为基类
parent表示总线的父设备，一般为总线桥设备。
name 总线名称
hotplug_handler 热插拔处理接口
max_index 当前设备最大索引
realized 是否初始化完成
children 用于存放总线上的子设备
sibling 用于挂载到父节点上。

typedef struct BusChild {
    DeviceState *child;
    int index;
    QTAILQ_ENTRY(BusChild) sibling;
} BusChild;

BusChild用于描述总线上的一个设备。
child 设备
index表示是第几个设备
sibling用于挂载到总线的children节点。

看完bus的类型定义后后门来看看bus.c提供的哪些基础功能。

static const TypeInfo bus_info = {
    .name = TYPE_BUS,
    .parent = TYPE_OBJECT,
    .instance_size = sizeof(BusState),
    .abstract = true,
    .class_size = sizeof(BusClass),
    .instance_init = qbus_initfn,
    .instance_finalize = qbus_finalize,
    .class_init = bus_class_init,
};

static void bus_register_types(void)
{
    type_register_static(&bus_info);
}

type_init(bus_register_types)

bus_class_init 完成类的初始化。
qbus_initfn 实例的初始化。
qbus_finalize 实例的析构。

void qbus_create_inplace(void *bus, size_t size, const char *typename,
                         DeviceState *parent, const char *name)
{
    object_initialize(bus, size, typename);
    qbus_realize(bus, parent, name);
}

BusState *qbus_create(const char *typename, DeviceState *parent, const char *name)
{
    BusState *bus;

    bus = BUS(object_new(typename));
    qbus_realize(bus, parent, name);

    return bus;
}

qbus_create_inplace 和 qbus_create 总线的创建。qbus_create_inplace 用于已经分配BusState内存的情况下完成初始化，qbus_create则完整的创建一个新的bus。最后两者都调用了qbus_realize 来执行一些初始化操作。（其实object_new里面也执行了object_initialize）。创建过程中还执行了 bus_class_init和qbus_initfn。

我们按照执行顺序来看初始化操作
首先执行的是bus_class_init 函数

static void bus_class_init(ObjectClass *class, void *data)
{
    BusClass *bc = BUS_CLASS(class);

    class->unparent = bus_unparent;
    bc->get_fw_dev_path = default_bus_get_fw_dev_path;
}

其实就是装填了两个回调函数
unparent函数，这和qom孩子属性比较相关，在调用object_property_add_child函数设置给一个qom对象设置父对象，object_property_del_child 和其他删除该属性的时候就会回调用unparent 函数，对于总线其实很好理解，当从总线桥上卸载该总线的时候就会调用unparent 回调。我们后面分析bus_unparent。设置get_fw_dev_path 回调用于of规范路径。
关于qom属性系统请参考文章qemu2的qom系统分析(二)规范路径和属性

BusClass初始化完成之后该是实例初始化，函数为qbus_initfn

static void qbus_initfn(Object *obj)
{
    BusState *bus = BUS(obj);

    QTAILQ_INIT(&bus->children);
    object_property_add_link(obj, QDEV_HOTPLUG_HANDLER_PROPERTY,
                             TYPE_HOTPLUG_HANDLER,
                             (Object **)&bus->hotplug_handler,
                             object_property_allow_set_link,
                             0,
                             NULL);
    object_property_add_bool(obj, "realized",
                             bus_get_realized, bus_set_realized, NULL);
}

比较简单，初始化了children链表，并且注册了两个属性realized 和 QDEV_HOTPLUG_HANDLER_PROPERTY。关于qom的属性系统请参考文章qemu2的qom系统分析(二)规范路径和属性 , 设置release的回调函数为bus_set_realized函数，在bus初始化完成调用object_property_set_qobject函数的时候会回调该函数。

再来看看bus创建过程中最后执行的一个函数qbus_realize

static void qbus_realize(BusState *bus, DeviceState *parent, const char *name)
{
    const char *typename = object_get_typename(OBJECT(bus));
    BusClass *bc;
    int i, bus_id;

    bus->parent = parent;

    if (name) {
        bus->name = g_strdup(name);
    } else if (bus->parent && bus->parent->id) {
        /* parent device has id -> use it plus parent-bus-id for bus name */
        bus_id = bus->parent->num_child_bus;
        bus->name = g_strdup_printf("%s.%d", bus->parent->id, bus_id);
    } else {
        /* no id -> use lowercase bus type plus global bus-id for bus name */
        bc = BUS_GET_CLASS(bus);
        bus_id = bc->automatic_ids++;
        bus->name = g_strdup_printf("%s.%d", typename, bus_id);
        for (i = 0; bus->name[i]; i++) {
            bus->name[i] = qemu_tolower(bus->name[i]);
        }
    }

    if (bus->parent) {
        QLIST_INSERT_HEAD(&bus->parent->child_bus, bus, sibling);
        bus->parent->num_child_bus++;
        object_property_add_child(OBJECT(bus->parent), bus->name, OBJECT(bus), NULL);
        object_unref(OBJECT(bus));
    } else if (bus != sysbus_get_default()) {
        /* TODO: once all bus devices are qdevified,
           only reset handler for main_system_bus should be registered here. */
        qemu_register_reset(qbus_reset_all_fn, bus);
    }
}

这个函数其实就做了两件事
1 给bus分配一个名字
这部分如果函数指定了bus的名字则直接设置。如果没有指定名称且不是根总线（parent不为空）则根据当前是第几个总线来设置名称。否则对于根总线则根据BusClass的automatic_ids 来分配一个名字，注意automatic_ids在BusClass下面，所以是类似静态变量的存在，是全局规划的。

对于非根总线，添加bus到父设备的child_bus 链表。
我们来看看qbus_realize初始化执行了什么操作，再使用object_property_add_child函数添加属性到父设备。
对于根总线没有父设备注册一个qbus_reset_all_fn方法，用于重置总线。

当总线创建完成后，系统会做一些其他的初始化，到合适的时机后就会调用 object_property_set_qobject(obj, QOBJECT(true), release, errp) 函数
来初始化总线，这个函数通过qom系统最终会调用bus.c的bus_set_realized函数。

static void bus_set_realized(Object *obj, bool value, Error **errp)
{
    BusState *bus = BUS(obj);
    BusClass *bc = BUS_GET_CLASS(bus);
    BusChild *kid;
    Error *local_err = NULL;

    if (value && !bus->realized) {
        if (bc->realize) {
            bc->realize(bus, &local_err);
        }

        /* TODO: recursive realization */
    } else if (!value && bus->realized) {
        QTAILQ_FOREACH(kid, &bus->children, sibling) {
            DeviceState *dev = kid->child;
            object_property_set_bool(OBJECT(dev), false, "realized",
                                     &local_err);
            if (local_err != NULL) {
                break;
            }
        }
        if (bc->unrealize && local_err == NULL) {
            bc->unrealize(bus, &local_err);
        }
    }

    if (local_err != NULL) {
        error_propagate(errp, local_err);
        return;
    }

    bus->realized = value;
}

这个函数处理两种情况，一种是设置bus的realized属性为true表示初始化完成，中设置realized属性为false，表示未初始化完成。两种情况都要在发生切实变化的时候才会执行一些操作。
对于realized从false变为true的情况如果需要调用BusClass的realized方法来完成初始化BusClass,因为在ObjectClass中所以该方法只对系统中第一个bus调用一次。
对于realized从true变为false的情况则遍历bus来设置子设备的realized属性。还会调用BusClass的unrealize函数。这里看起来有点奇怪，所以才有TODO里面的注释。

当bus从父节点删除的时候调用bus_unparent 函数

static void bus_unparent(Object *obj)
{
    BusState *bus = BUS(obj);
    BusChild *kid;

    while ((kid = QTAILQ_FIRST(&bus->children)) != NULL) {
        DeviceState *dev = kid->child;
        object_unparent(OBJECT(dev));
    }
    if (bus->parent) {
        QLIST_REMOVE(bus, sibling);
        bus->parent->num_child_bus--;
        bus->parent = NULL;
    } else {
        assert(bus != sysbus_get_default()); /* main_system_bus is never freed */
        qemu_unregister_reset(qbus_reset_all_fn, bus);
    }
}

首先将子设备卸载，对于非根总线再从父设备中删除自己。根总线则需要删除注册的reset函数。

上述函数全都是设备的创建和初始化功能。下面来看下还提供了其他功能。

static void qbus_set_hotplug_handler_internal(BusState *bus, Object *handler,
                                              Error **errp)
{

    object_property_set_link(OBJECT(bus), OBJECT(handler),
                             QDEV_HOTPLUG_HANDLER_PROPERTY, errp);
}

void qbus_set_hotplug_handler(BusState *bus, DeviceState *handler, Error **errp)
{
    qbus_set_hotplug_handler_internal(bus, OBJECT(handler), errp);
}

void qbus_set_bus_hotplug_handler(BusState *bus, Error **errp)
{
    qbus_set_hotplug_handler_internal(bus, OBJECT(bus), errp);
}

设置热插拔接口

qbus_walk_children函数用于遍历总线

int qbus_walk_children(BusState *bus,
                       qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
                       qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
                       void *opaque)
{
    BusChild *kid;
    int err;

    if (pre_busfn) {
        err = pre_busfn(bus, opaque);
        if (err) {
            return err;
        }
    }

    QTAILQ_FOREACH(kid, &bus->children, sibling) {
        err = qdev_walk_children(kid->child,
                                 pre_devfn, pre_busfn,
                                 post_devfn, post_busfn, opaque);
        if (err < 0) {
            return err;
        }
    }

    if (post_busfn) {
        err = post_busfn(bus, opaque);
        if (err) {
            return err;
        }
    }

    return 0;
}

int qdev_walk_children(DeviceState *dev,
                       qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
                       qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
                       void *opaque)
{
    BusState *bus;
    int err;

    if (pre_devfn) {
        err = pre_devfn(dev, opaque);
        if (err) {
            return err;
        }
    }

    QLIST_FOREACH(bus, &dev->child_bus, sibling) {
        err = qbus_walk_children(bus, pre_devfn, pre_busfn,
                                 post_devfn, post_busfn, opaque);
        if (err < 0) {
            return err;
        }
    }

    if (post_devfn) {
        err = post_devfn(dev, opaque);
        if (err) {
            return err;
        }
    }

    return 0;
}

如果dev的child_bus不为空，说明它是一个总线桥设备，下面挂在的是总线设备，所以整个函数采用深度优先算法来遍历这一颗总线树。

总线的基本框架就是这样的，下面来做一些总结。

1 创建总线
qbus_create_inplace
qbus_create

2 遍历总线
qbus_walk_children

3 总线基础TypeInfo
#define TYPE_BUS “bus”

static const TypeInfo bus_info = {
    .name = TYPE_BUS,
    .parent = TYPE_OBJECT,
    .instance_size = sizeof(BusState),
    .abstract = true,
    .class_size = sizeof(BusClass),
    .instance_init = qbus_initfn,
    .instance_finalize = qbus_finalize,
    .class_init = bus_class_init,
};

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。