[qemu.git] / hw / qdev-monitor.c

/*
 *  Dynamic device configuration and creation.
 *
 *  Copyright (c) 2009 CodeSourcery
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */

#include "qdev.h"
#include "monitor/monitor.h"
#include "qmp-commands.h"
#include "sysemu/arch_init.h"
#include "qemu/config-file.h"

/*
 * Aliases were a bad idea from the start.  Let's keep them
 * from spreading further.
 */
typedef struct QDevAlias
{
    const char *typename;
    const char *alias;
    uint32_t arch_mask;
} QDevAlias;

static const QDevAlias qdev_alias_table[] = {
    { "virtio-blk-pci", "virtio-blk", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
    { "virtio-net-pci", "virtio-net", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
    { "virtio-serial-pci", "virtio-serial", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
    { "virtio-balloon-pci", "virtio-balloon",
            QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
    { "virtio-blk-s390", "virtio-blk", QEMU_ARCH_S390X },
    { "virtio-net-s390", "virtio-net", QEMU_ARCH_S390X },
    { "virtio-serial-s390", "virtio-serial", QEMU_ARCH_S390X },
    { "lsi53c895a", "lsi" },
    { "ich9-ahci", "ahci" },
    { "kvm-pci-assign", "pci-assign" },
    { }
};

static const char *qdev_class_get_alias(DeviceClass *dc)
{
    const char *typename = object_class_get_name(OBJECT_CLASS(dc));
    int i;

    for (i = 0; qdev_alias_table[i].typename; i++) {
        if (qdev_alias_table[i].arch_mask &&
            !(qdev_alias_table[i].arch_mask & arch_type)) {
            continue;
        }

        if (strcmp(qdev_alias_table[i].typename, typename) == 0) {
            return qdev_alias_table[i].alias;
        }
    }

    return NULL;
}

static bool qdev_class_has_alias(DeviceClass *dc)
{
    return (qdev_class_get_alias(dc) != NULL);
}

static void qdev_print_devinfo(ObjectClass *klass, void *opaque)
{
    DeviceClass *dc;
    bool *show_no_user = opaque;

    dc = (DeviceClass *)object_class_dynamic_cast(klass, TYPE_DEVICE);

    if (!dc || (show_no_user && !*show_no_user && dc->no_user)) {
        return;
    }

    error_printf("name \"%s\"", object_class_get_name(klass));
    if (dc->bus_type) {
        error_printf(", bus %s", dc->bus_type);
    }
    if (qdev_class_has_alias(dc)) {
        error_printf(", alias \"%s\"", qdev_class_get_alias(dc));
    }
    if (dc->desc) {
        error_printf(", desc \"%s\"", dc->desc);
    }
    if (dc->no_user) {
        error_printf(", no-user");
    }
    error_printf("\n");
}

static int set_property(const char *name, const char *value, void *opaque)
{
    DeviceState *dev = opaque;

    if (strcmp(name, "driver") == 0)
        return 0;
    if (strcmp(name, "bus") == 0)
        return 0;

    if (qdev_prop_parse(dev, name, value) == -1) {
        return -1;
    }
    return 0;
}

static const char *find_typename_by_alias(const char *alias)
{
    int i;

    for (i = 0; qdev_alias_table[i].alias; i++) {
        if (qdev_alias_table[i].arch_mask &&
            !(qdev_alias_table[i].arch_mask & arch_type)) {
            continue;
        }

        if (strcmp(qdev_alias_table[i].alias, alias) == 0) {
            return qdev_alias_table[i].typename;
        }
    }

    return NULL;
}

int qdev_device_help(QemuOpts *opts)
{
    const char *driver;
    Property *prop;
    ObjectClass *klass;

    driver = qemu_opt_get(opts, "driver");
    if (driver && is_help_option(driver)) {
        bool show_no_user = false;
        object_class_foreach(qdev_print_devinfo, TYPE_DEVICE, false, &show_no_user);
        return 1;
    }

    if (!driver || !qemu_opt_has_help_opt(opts)) {
        return 0;
    }

    klass = object_class_by_name(driver);
    if (!klass) {
        const char *typename = find_typename_by_alias(driver);

        if (typename) {
            driver = typename;
            klass = object_class_by_name(driver);
        }
    }

    if (!klass) {
        return 0;
    }
    do {
        for (prop = DEVICE_CLASS(klass)->props; prop && prop->name; prop++) {
            /*
             * TODO Properties without a parser are just for dirty hacks.
             * qdev_prop_ptr is the only such PropertyInfo.  It's marked
             * for removal.  This conditional should be removed along with
             * it.
             */
            if (!prop->info->set) {
                continue;           /* no way to set it, don't show */
            }
            error_printf("%s.%s=%s\n", driver, prop->name,
                         prop->info->legacy_name ?: prop->info->name);
        }
        klass = object_class_get_parent(klass);
    } while (klass != object_class_by_name(TYPE_DEVICE));
    return 1;
}

static Object *qdev_get_peripheral(void)
{
    static Object *dev;

    if (dev == NULL) {
        dev = container_get(qdev_get_machine(), "/peripheral");
    }

    return dev;
}

static Object *qdev_get_peripheral_anon(void)
{
    static Object *dev;

    if (dev == NULL) {
        dev = container_get(qdev_get_machine(), "/peripheral-anon");
    }

    return dev;
}

static void qbus_list_bus(DeviceState *dev)
{
    BusState *child;
    const char *sep = " ";

    error_printf("child busses at \"%s\":",
                 dev->id ? dev->id : object_get_typename(OBJECT(dev)));
    QLIST_FOREACH(child, &dev->child_bus, sibling) {
        error_printf("%s\"%s\"", sep, child->name);
        sep = ", ";
    }
    error_printf("\n");
}

static void qbus_list_dev(BusState *bus)
{
    BusChild *kid;
    const char *sep = " ";

    error_printf("devices at \"%s\":", bus->name);
    QTAILQ_FOREACH(kid, &bus->children, sibling) {
        DeviceState *dev = kid->child;
        error_printf("%s\"%s\"", sep, object_get_typename(OBJECT(dev)));
        if (dev->id)
            error_printf("/\"%s\"", dev->id);
        sep = ", ";
    }
    error_printf("\n");
}

static BusState *qbus_find_bus(DeviceState *dev, char *elem)
{
    BusState *child;

    QLIST_FOREACH(child, &dev->child_bus, sibling) {
        if (strcmp(child->name, elem) == 0) {
            return child;
        }
    }
    return NULL;
}

static DeviceState *qbus_find_dev(BusState *bus, char *elem)
{
    BusChild *kid;

    /*
     * try to match in order:
     *   (1) instance id, if present
     *   (2) driver name
     *   (3) driver alias, if present
     */
    QTAILQ_FOREACH(kid, &bus->children, sibling) {
        DeviceState *dev = kid->child;
        if (dev->id  &&  strcmp(dev->id, elem) == 0) {
            return dev;
        }
    }
    QTAILQ_FOREACH(kid, &bus->children, sibling) {
        DeviceState *dev = kid->child;
        if (strcmp(object_get_typename(OBJECT(dev)), elem) == 0) {
            return dev;
        }
    }
    QTAILQ_FOREACH(kid, &bus->children, sibling) {
        DeviceState *dev = kid->child;
        DeviceClass *dc = DEVICE_GET_CLASS(dev);

        if (qdev_class_has_alias(dc) &&
            strcmp(qdev_class_get_alias(dc), elem) == 0) {
            return dev;
        }
    }
    return NULL;
}

static BusState *qbus_find_recursive(BusState *bus, const char *name,
                                     const char *bus_typename)
{
    BusChild *kid;
    BusState *child, *ret;
    int match = 1;

    if (name && (strcmp(bus->name, name) != 0)) {
        match = 0;
    }
    if (bus_typename && !object_dynamic_cast(OBJECT(bus), bus_typename)) {
        match = 0;
    }
    if (match) {
        return bus;
    }

    QTAILQ_FOREACH(kid, &bus->children, sibling) {
        DeviceState *dev = kid->child;
        QLIST_FOREACH(child, &dev->child_bus, sibling) {
            ret = qbus_find_recursive(child, name, bus_typename);
            if (ret) {
                return ret;
            }
        }
    }
    return NULL;
}

static BusState *qbus_find(const char *path)
{
    DeviceState *dev;
    BusState *bus;
    char elem[128];
    int pos, len;

    /* find start element */
    if (path[0] == '/') {
        bus = sysbus_get_default();
        pos = 0;
    } else {
        if (sscanf(path, "%127[^/]%n", elem, &len) != 1) {
            assert(!path[0]);
            elem[0] = len = 0;
        }
        bus = qbus_find_recursive(sysbus_get_default(), elem, NULL);
        if (!bus) {
            qerror_report(QERR_BUS_NOT_FOUND, elem);
            return NULL;
        }
        pos = len;
    }

    for (;;) {
        assert(path[pos] == '/' || !path[pos]);
        while (path[pos] == '/') {
            pos++;
        }
        if (path[pos] == '\0') {
            return bus;
        }

        /* find device */
        if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
            assert(0);
            elem[0] = len = 0;
        }
        pos += len;
        dev = qbus_find_dev(bus, elem);
        if (!dev) {
            qerror_report(QERR_DEVICE_NOT_FOUND, elem);
            if (!monitor_cur_is_qmp()) {
                qbus_list_dev(bus);
            }
            return NULL;
        }

        assert(path[pos] == '/' || !path[pos]);
        while (path[pos] == '/') {
            pos++;
        }
        if (path[pos] == '\0') {
            /* last specified element is a device.  If it has exactly
             * one child bus accept it nevertheless */
            switch (dev->num_child_bus) {
            case 0:
                qerror_report(QERR_DEVICE_NO_BUS, elem);
                return NULL;
            case 1:
                return QLIST_FIRST(&dev->child_bus);
            default:
                qerror_report(QERR_DEVICE_MULTIPLE_BUSSES, elem);
                if (!monitor_cur_is_qmp()) {
                    qbus_list_bus(dev);
                }
                return NULL;
            }
        }

        /* find bus */
        if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
            assert(0);
            elem[0] = len = 0;
        }
        pos += len;
        bus = qbus_find_bus(dev, elem);
        if (!bus) {
            qerror_report(QERR_BUS_NOT_FOUND, elem);
            if (!monitor_cur_is_qmp()) {
                qbus_list_bus(dev);
            }
            return NULL;
        }
    }
}

DeviceState *qdev_device_add(QemuOpts *opts)
{
    ObjectClass *obj;
    DeviceClass *k;
    const char *driver, *path, *id;
    DeviceState *qdev;
    BusState *bus;

    driver = qemu_opt_get(opts, "driver");
    if (!driver) {
        qerror_report(QERR_MISSING_PARAMETER, "driver");
        return NULL;
    }

    /* find driver */
    obj = object_class_by_name(driver);
    if (!obj) {
        const char *typename = find_typename_by_alias(driver);

        if (typename) {
            driver = typename;
            obj = object_class_by_name(driver);
        }
    }

    if (!obj) {
        qerror_report(QERR_INVALID_PARAMETER_VALUE, "driver", "device type");
        return NULL;
    }

    k = DEVICE_CLASS(obj);

    /* find bus */
    path = qemu_opt_get(opts, "bus");
    if (path != NULL) {
        bus = qbus_find(path);
        if (!bus) {
            return NULL;
        }
        if (!object_dynamic_cast(OBJECT(bus), k->bus_type)) {
            qerror_report(QERR_BAD_BUS_FOR_DEVICE,
                          driver, object_get_typename(OBJECT(bus)));
            return NULL;
        }
    } else {
        bus = qbus_find_recursive(sysbus_get_default(), NULL, k->bus_type);
        if (!bus) {
            qerror_report(QERR_NO_BUS_FOR_DEVICE,
                          k->bus_type, driver);
            return NULL;
        }
    }
    if (qdev_hotplug && !bus->allow_hotplug) {
        qerror_report(QERR_BUS_NO_HOTPLUG, bus->name);
        return NULL;
    }

    if (!bus) {
        bus = sysbus_get_default();
    }

    /* create device, set properties */
    qdev = DEVICE(object_new(driver));
    qdev_set_parent_bus(qdev, bus);

    id = qemu_opts_id(opts);
    if (id) {
        qdev->id = id;
    }
    if (qemu_opt_foreach(opts, set_property, qdev, 1) != 0) {
        qdev_free(qdev);
        return NULL;
    }
    if (qdev->id) {
        object_property_add_child(qdev_get_peripheral(), qdev->id,
                                  OBJECT(qdev), NULL);
    } else {
        static int anon_count;
        gchar *name = g_strdup_printf("device[%d]", anon_count++);
        object_property_add_child(qdev_get_peripheral_anon(), name,
                                  OBJECT(qdev), NULL);
        g_free(name);
    }        
    if (qdev_init(qdev) < 0) {
        qerror_report(QERR_DEVICE_INIT_FAILED, driver);
        return NULL;
    }
    qdev->opts = opts;
    return qdev;
}


#define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
static void qbus_print(Monitor *mon, BusState *bus, int indent);

static void qdev_print_props(Monitor *mon, DeviceState *dev, Property *props,
                             int indent)
{
    if (!props)
        return;
    for (; props->name; props++) {
        Error *err = NULL;
        char *value;
        char *legacy_name = g_strdup_printf("legacy-%s", props->name);
        if (object_property_get_type(OBJECT(dev), legacy_name, NULL)) {
            value = object_property_get_str(OBJECT(dev), legacy_name, &err);
        } else {
            value = object_property_print(OBJECT(dev), props->name, &err);
        }
        g_free(legacy_name);

        if (err) {
            error_free(err);
            continue;
        }
        qdev_printf("%s = %s\n", props->name,
                    value && *value ? value : "<null>");
        g_free(value);
    }
}

static void bus_print_dev(BusState *bus, Monitor *mon, DeviceState *dev, int indent)
{
    BusClass *bc = BUS_GET_CLASS(bus);

    if (bc->print_dev) {
        bc->print_dev(mon, dev, indent);
    }
}

static void qdev_print(Monitor *mon, DeviceState *dev, int indent)
{
    ObjectClass *class;
    BusState *child;
    qdev_printf("dev: %s, id \"%s\"\n", object_get_typename(OBJECT(dev)),
                dev->id ? dev->id : "");
    indent += 2;
    if (dev->num_gpio_in) {
        qdev_printf("gpio-in %d\n", dev->num_gpio_in);
    }
    if (dev->num_gpio_out) {
        qdev_printf("gpio-out %d\n", dev->num_gpio_out);
    }
    class = object_get_class(OBJECT(dev));
    do {
        qdev_print_props(mon, dev, DEVICE_CLASS(class)->props, indent);
        class = object_class_get_parent(class);
    } while (class != object_class_by_name(TYPE_DEVICE));
    bus_print_dev(dev->parent_bus, mon, dev, indent);
    QLIST_FOREACH(child, &dev->child_bus, sibling) {
        qbus_print(mon, child, indent);
    }
}

static void qbus_print(Monitor *mon, BusState *bus, int indent)
{
    BusChild *kid;

    qdev_printf("bus: %s\n", bus->name);
    indent += 2;
    qdev_printf("type %s\n", object_get_typename(OBJECT(bus)));
    QTAILQ_FOREACH(kid, &bus->children, sibling) {
        DeviceState *dev = kid->child;
        qdev_print(mon, dev, indent);
    }
}
#undef qdev_printf

void do_info_qtree(Monitor *mon)
{
    if (sysbus_get_default())
        qbus_print(mon, sysbus_get_default(), 0);
}

void do_info_qdm(Monitor *mon)
{
    object_class_foreach(qdev_print_devinfo, TYPE_DEVICE, false, NULL);
}

int do_device_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
{
    Error *local_err = NULL;
    QemuOpts *opts;

    opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, &local_err);
    if (error_is_set(&local_err)) {
        qerror_report_err(local_err);
        error_free(local_err);
        return -1;
    }
    if (!monitor_cur_is_qmp() && qdev_device_help(opts)) {
        qemu_opts_del(opts);
        return 0;
    }
    if (!qdev_device_add(opts)) {
        qemu_opts_del(opts);
        return -1;
    }
    return 0;
}

void qmp_device_del(const char *id, Error **errp)
{
    DeviceState *dev;

    dev = qdev_find_recursive(sysbus_get_default(), id);
    if (NULL == dev) {
        error_set(errp, QERR_DEVICE_NOT_FOUND, id);
        return;
    }

    qdev_unplug(dev, errp);
}

void qdev_machine_init(void)
{
    qdev_get_peripheral_anon();
    qdev_get_peripheral();
}
Commit	Line	Data
ee46d8a5 AL	1	/*
	2	* Dynamic device configuration and creation.
	3	*
	4	* Copyright (c) 2009 CodeSourcery
	5	*
	6	* This library is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License as published by the Free Software Foundation; either
	9	* version 2 of the License, or (at your option) any later version.
	10	*
	11	* This library is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* Lesser General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU Lesser General Public
	17	* License along with this library; if not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#include "qdev.h"
83c9089e	21	#include "monitor/monitor.h"
a15fef21	22	#include "qmp-commands.h"
9c17d615	23	#include "sysemu/arch_init.h"
1de7afc9	24	#include "qemu/config-file.h"
ee46d8a5 AL	25
	26	/*
	27	* Aliases were a bad idea from the start. Let's keep them
	28	* from spreading further.
	29	*/
	30	typedef struct QDevAlias
	31	{
	32	const char *typename;
	33	const char *alias;
5f629d94	34	uint32_t arch_mask;
ee46d8a5 AL	35	} QDevAlias;
	36
	37	static const QDevAlias qdev_alias_table[] = {
5f629d94 AG	38	{ "virtio-blk-pci", "virtio-blk", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
	39	{ "virtio-net-pci", "virtio-net", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
	40	{ "virtio-serial-pci", "virtio-serial", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
	41	{ "virtio-balloon-pci", "virtio-balloon",
	42	QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
	43	{ "virtio-blk-s390", "virtio-blk", QEMU_ARCH_S390X },
	44	{ "virtio-net-s390", "virtio-net", QEMU_ARCH_S390X },
	45	{ "virtio-serial-s390", "virtio-serial", QEMU_ARCH_S390X },
ee46d8a5 AL	46	{ "lsi53c895a", "lsi" },
ee46d8a5 AL	47	{ "ich9-ahci", "ahci" },
c3ebd3ba	48	{ "kvm-pci-assign", "pci-assign" },
ee46d8a5 AL	49	{ }
	50	};
	51
	52	static const char qdev_class_get_alias(DeviceClass dc)
	53	{
	54	const char *typename = object_class_get_name(OBJECT_CLASS(dc));
	55	int i;
	56
	57	for (i = 0; qdev_alias_table[i].typename; i++) {
5f629d94 AG	58	if (qdev_alias_table[i].arch_mask &&
	59	!(qdev_alias_table[i].arch_mask & arch_type)) {
	60	continue;
	61	}
	62
ee46d8a5 AL	63	if (strcmp(qdev_alias_table[i].typename, typename) == 0) {
	64	return qdev_alias_table[i].alias;
	65	}
	66	}
	67
	68	return NULL;
	69	}
	70
	71	static bool qdev_class_has_alias(DeviceClass *dc)
	72	{
	73	return (qdev_class_get_alias(dc) != NULL);
	74	}
	75
	76	static void qdev_print_devinfo(ObjectClass klass, void opaque)
	77	{
	78	DeviceClass *dc;
	79	bool *show_no_user = opaque;
	80
	81	dc = (DeviceClass *)object_class_dynamic_cast(klass, TYPE_DEVICE);
	82
	83	if (!dc \|\| (show_no_user && !*show_no_user && dc->no_user)) {
	84	return;
	85	}
	86
	87	error_printf("name \"%s\"", object_class_get_name(klass));
0d936928 AL	88	if (dc->bus_type) {
0d936928 AL	89	error_printf(", bus %s", dc->bus_type);
ee46d8a5 AL	90	}
	91	if (qdev_class_has_alias(dc)) {
	92	error_printf(", alias \"%s\"", qdev_class_get_alias(dc));
	93	}
	94	if (dc->desc) {
	95	error_printf(", desc \"%s\"", dc->desc);
	96	}
	97	if (dc->no_user) {
	98	error_printf(", no-user");
	99	}
	100	error_printf("\n");
	101	}
	102
	103	static int set_property(const char name, const char value, void *opaque)
	104	{
	105	DeviceState *dev = opaque;
	106
	107	if (strcmp(name, "driver") == 0)
	108	return 0;
	109	if (strcmp(name, "bus") == 0)
	110	return 0;
	111
	112	if (qdev_prop_parse(dev, name, value) == -1) {
	113	return -1;
	114	}
	115	return 0;
	116	}
	117
	118	static const char find_typename_by_alias(const char alias)
	119	{
	120	int i;
	121
	122	for (i = 0; qdev_alias_table[i].alias; i++) {
5f629d94 AG	123	if (qdev_alias_table[i].arch_mask &&
	124	!(qdev_alias_table[i].arch_mask & arch_type)) {
	125	continue;
	126	}
	127
ee46d8a5 AL	128	if (strcmp(qdev_alias_table[i].alias, alias) == 0) {
	129	return qdev_alias_table[i].typename;
	130	}
	131	}
	132
	133	return NULL;
	134	}
	135
	136	int qdev_device_help(QemuOpts *opts)
	137	{
	138	const char *driver;
	139	Property *prop;
	140	ObjectClass *klass;
ee46d8a5 AL	141
ee46d8a5 AL	142	driver = qemu_opt_get(opts, "driver");
c8057f95	143	if (driver && is_help_option(driver)) {
ee46d8a5 AL	144	bool show_no_user = false;
	145	object_class_foreach(qdev_print_devinfo, TYPE_DEVICE, false, &show_no_user);
	146	return 1;
	147	}
	148
c8057f95	149	if (!driver \|\| !qemu_opt_has_help_opt(opts)) {
ee46d8a5 AL	150	return 0;
	151	}
	152
	153	klass = object_class_by_name(driver);
	154	if (!klass) {
	155	const char *typename = find_typename_by_alias(driver);
	156
	157	if (typename) {
	158	driver = typename;
	159	klass = object_class_by_name(driver);
	160	}
	161	}
	162
	163	if (!klass) {
	164	return 0;
	165	}
bce54474 PB	166	do {
	167	for (prop = DEVICE_CLASS(klass)->props; prop && prop->name; prop++) {
	168	/*
	169	* TODO Properties without a parser are just for dirty hacks.
	170	* qdev_prop_ptr is the only such PropertyInfo. It's marked
	171	* for removal. This conditional should be removed along with
	172	* it.
	173	*/
90ca64a9	174	if (!prop->info->set) {
d03d6b4e AL	175	continue; /* no way to set it, don't show */
	176	}
	177	error_printf("%s.%s=%s\n", driver, prop->name,
	178	prop->info->legacy_name ?: prop->info->name);
ee46d8a5	179	}
bce54474 PB	180	klass = object_class_get_parent(klass);
bce54474 PB	181	} while (klass != object_class_by_name(TYPE_DEVICE));
ee46d8a5 AL	182	return 1;
	183	}
	184
57c9fafe	185	static Object *qdev_get_peripheral(void)
ee46d8a5	186	{
8b45d447	187	static Object *dev;
ee46d8a5 AL	188
ee46d8a5 AL	189	if (dev == NULL) {
dfe47e70	190	dev = container_get(qdev_get_machine(), "/peripheral");
ee46d8a5 AL	191	}
ee46d8a5 AL	192
8b45d447	193	return dev;
ee46d8a5 AL	194	}
ee46d8a5 AL	195
57c9fafe	196	static Object *qdev_get_peripheral_anon(void)
ee46d8a5	197	{
8b45d447	198	static Object *dev;
ee46d8a5 AL	199
ee46d8a5 AL	200	if (dev == NULL) {
dfe47e70	201	dev = container_get(qdev_get_machine(), "/peripheral-anon");
ee46d8a5 AL	202	}
ee46d8a5 AL	203
8b45d447	204	return dev;
ee46d8a5 AL	205	}
	206
	207	static void qbus_list_bus(DeviceState *dev)
	208	{
	209	BusState *child;
	210	const char *sep = " ";
	211
	212	error_printf("child busses at \"%s\":",
	213	dev->id ? dev->id : object_get_typename(OBJECT(dev)));
	214	QLIST_FOREACH(child, &dev->child_bus, sibling) {
	215	error_printf("%s\"%s\"", sep, child->name);
	216	sep = ", ";
	217	}
	218	error_printf("\n");
	219	}
	220
	221	static void qbus_list_dev(BusState *bus)
	222	{
0866aca1	223	BusChild *kid;
ee46d8a5 AL	224	const char *sep = " ";
	225
	226	error_printf("devices at \"%s\":", bus->name);
0866aca1 AL	227	QTAILQ_FOREACH(kid, &bus->children, sibling) {
0866aca1 AL	228	DeviceState *dev = kid->child;
ee46d8a5 AL	229	error_printf("%s\"%s\"", sep, object_get_typename(OBJECT(dev)));
	230	if (dev->id)
	231	error_printf("/\"%s\"", dev->id);
	232	sep = ", ";
	233	}
	234	error_printf("\n");
	235	}
	236
	237	static BusState qbus_find_bus(DeviceState dev, char *elem)
	238	{
	239	BusState *child;
	240
	241	QLIST_FOREACH(child, &dev->child_bus, sibling) {
	242	if (strcmp(child->name, elem) == 0) {
	243	return child;
	244	}
	245	}
	246	return NULL;
	247	}
	248
	249	static DeviceState qbus_find_dev(BusState bus, char *elem)
	250	{
0866aca1	251	BusChild *kid;
ee46d8a5 AL	252
	253	/*
	254	* try to match in order:
	255	* (1) instance id, if present
	256	* (2) driver name
	257	* (3) driver alias, if present
	258	*/
0866aca1 AL	259	QTAILQ_FOREACH(kid, &bus->children, sibling) {
0866aca1 AL	260	DeviceState *dev = kid->child;
ee46d8a5 AL	261	if (dev->id && strcmp(dev->id, elem) == 0) {
	262	return dev;
	263	}
	264	}
0866aca1 AL	265	QTAILQ_FOREACH(kid, &bus->children, sibling) {
0866aca1 AL	266	DeviceState *dev = kid->child;
ee46d8a5 AL	267	if (strcmp(object_get_typename(OBJECT(dev)), elem) == 0) {
	268	return dev;
	269	}
	270	}
0866aca1 AL	271	QTAILQ_FOREACH(kid, &bus->children, sibling) {
0866aca1 AL	272	DeviceState *dev = kid->child;
ee46d8a5 AL	273	DeviceClass *dc = DEVICE_GET_CLASS(dev);
	274
	275	if (qdev_class_has_alias(dc) &&
	276	strcmp(qdev_class_get_alias(dc), elem) == 0) {
	277	return dev;
	278	}
	279	}
	280	return NULL;
	281	}
	282
	283	static BusState qbus_find_recursive(BusState bus, const char *name,
0d936928	284	const char *bus_typename)
ee46d8a5	285	{
0866aca1	286	BusChild *kid;
ee46d8a5 AL	287	BusState child, ret;
	288	int match = 1;
	289
	290	if (name && (strcmp(bus->name, name) != 0)) {
	291	match = 0;
	292	}
e912c96f	293	if (bus_typename && !object_dynamic_cast(OBJECT(bus), bus_typename)) {
ee46d8a5 AL	294	match = 0;
	295	}
	296	if (match) {
	297	return bus;
	298	}
	299
0866aca1 AL	300	QTAILQ_FOREACH(kid, &bus->children, sibling) {
0866aca1 AL	301	DeviceState *dev = kid->child;
ee46d8a5	302	QLIST_FOREACH(child, &dev->child_bus, sibling) {
0d936928	303	ret = qbus_find_recursive(child, name, bus_typename);
ee46d8a5 AL	304	if (ret) {
	305	return ret;
	306	}
	307	}
	308	}
	309	return NULL;
	310	}
	311
	312	static BusState qbus_find(const char path)
	313	{
	314	DeviceState *dev;
	315	BusState *bus;
	316	char elem[128];
	317	int pos, len;
	318
	319	/* find start element */
	320	if (path[0] == '/') {
	321	bus = sysbus_get_default();
	322	pos = 0;
	323	} else {
	324	if (sscanf(path, "%127[^/]%n", elem, &len) != 1) {
	325	assert(!path[0]);
	326	elem[0] = len = 0;
	327	}
	328	bus = qbus_find_recursive(sysbus_get_default(), elem, NULL);
	329	if (!bus) {
	330	qerror_report(QERR_BUS_NOT_FOUND, elem);
	331	return NULL;
	332	}
	333	pos = len;
	334	}
	335
	336	for (;;) {
	337	assert(path[pos] == '/' \|\| !path[pos]);
	338	while (path[pos] == '/') {
	339	pos++;
	340	}
	341	if (path[pos] == '\0') {
	342	return bus;
	343	}
	344
	345	/* find device */
	346	if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
	347	assert(0);
	348	elem[0] = len = 0;
	349	}
	350	pos += len;
	351	dev = qbus_find_dev(bus, elem);
	352	if (!dev) {
	353	qerror_report(QERR_DEVICE_NOT_FOUND, elem);
	354	if (!monitor_cur_is_qmp()) {
	355	qbus_list_dev(bus);
	356	}
	357	return NULL;
	358	}
	359
	360	assert(path[pos] == '/' \|\| !path[pos]);
	361	while (path[pos] == '/') {
	362	pos++;
	363	}
	364	if (path[pos] == '\0') {
	365	/* last specified element is a device. If it has exactly
	366	* one child bus accept it nevertheless */
	367	switch (dev->num_child_bus) {
368	case 0:
369	qerror_report(QERR_DEVICE_NO_BUS, elem);
370	return NULL;
371	case 1:
372	return QLIST_FIRST(&dev->child_bus);
373	default:
374	qerror_report(QERR_DEVICE_MULTIPLE_BUSSES, elem);
375	if (!monitor_cur_is_qmp()) {
376	qbus_list_bus(dev);
377	}
378	return NULL;
379	}
380	}
381
382	/* find bus */
383	if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
384	assert(0);
385	elem[0] = len = 0;
386	}
387	pos += len;
388	bus = qbus_find_bus(dev, elem);
389	if (!bus) {
390	qerror_report(QERR_BUS_NOT_FOUND, elem);
391	if (!monitor_cur_is_qmp()) {
392	qbus_list_bus(dev);
393	}
394	return NULL;
395	}
396	}
397	}
398
399	DeviceState qdev_device_add(QemuOpts opts)
400	{
401	ObjectClass *obj;
402	DeviceClass *k;
403	const char driver, path, *id;
404	DeviceState *qdev;
405	BusState *bus;
406
407	driver = qemu_opt_get(opts, "driver");
408	if (!driver) {
409	qerror_report(QERR_MISSING_PARAMETER, "driver");
410	return NULL;
411	}
412
413	/* find driver */
414	obj = object_class_by_name(driver);
415	if (!obj) {
416	const char *typename = find_typename_by_alias(driver);
417
418	if (typename) {
419	driver = typename;
420	obj = object_class_by_name(driver);
421	}
422	}
423
424	if (!obj) {
425	qerror_report(QERR_INVALID_PARAMETER_VALUE, "driver", "device type");
426	return NULL;
427	}
428
429	k = DEVICE_CLASS(obj);
430
431	/* find bus */
432	path = qemu_opt_get(opts, "bus");
433	if (path != NULL) {
434	bus = qbus_find(path);
435	if (!bus) {
436	return NULL;
437	}
e912c96f	438	if (!object_dynamic_cast(OBJECT(bus), k->bus_type)) {
ee46d8a5	439	qerror_report(QERR_BAD_BUS_FOR_DEVICE,
0d936928	440	driver, object_get_typename(OBJECT(bus)));
ee46d8a5 AL	441	return NULL;
	442	}
	443	} else {
0d936928	444	bus = qbus_find_recursive(sysbus_get_default(), NULL, k->bus_type);
ee46d8a5 AL	445	if (!bus) {
ee46d8a5 AL	446	qerror_report(QERR_NO_BUS_FOR_DEVICE,
c3594ed7	447	k->bus_type, driver);
ee46d8a5 AL	448	return NULL;
	449	}
	450	}
	451	if (qdev_hotplug && !bus->allow_hotplug) {
	452	qerror_report(QERR_BUS_NO_HOTPLUG, bus->name);
	453	return NULL;
	454	}
	455
	456	if (!bus) {
	457	bus = sysbus_get_default();
	458	}
	459
	460	/* create device, set properties */
	461	qdev = DEVICE(object_new(driver));
	462	qdev_set_parent_bus(qdev, bus);
ee46d8a5 AL	463
	464	id = qemu_opts_id(opts);
	465	if (id) {
	466	qdev->id = id;
b2d4b3f7 AL	467	}
	468	if (qemu_opt_foreach(opts, set_property, qdev, 1) != 0) {
	469	qdev_free(qdev);
	470	return NULL;
	471	}
b2d4b3f7	472	if (qdev->id) {
57c9fafe AL	473	object_property_add_child(qdev_get_peripheral(), qdev->id,
57c9fafe AL	474	OBJECT(qdev), NULL);
ee46d8a5 AL	475	} else {
	476	static int anon_count;
	477	gchar *name = g_strdup_printf("device[%d]", anon_count++);
57c9fafe AL	478	object_property_add_child(qdev_get_peripheral_anon(), name,
57c9fafe AL	479	OBJECT(qdev), NULL);
ee46d8a5 AL	480	g_free(name);
ee46d8a5 AL	481	}
f424d5c4 PB	482	if (qdev_init(qdev) < 0) {
	483	qerror_report(QERR_DEVICE_INIT_FAILED, driver);
	484	return NULL;
	485	}
ee46d8a5 AL	486	qdev->opts = opts;
	487	return qdev;
	488	}
	489
	490
	491	#define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
	492	static void qbus_print(Monitor mon, BusState bus, int indent);
	493
	494	static void qdev_print_props(Monitor mon, DeviceState dev, Property *props,
bce54474	495	int indent)
ee46d8a5	496	{
ee46d8a5 AL	497	if (!props)
ee46d8a5 AL	498	return;
d822979b PB	499	for (; props->name; props++) {
	500	Error *err = NULL;
	501	char *value;
	502	char *legacy_name = g_strdup_printf("legacy-%s", props->name);
	503	if (object_property_get_type(OBJECT(dev), legacy_name, NULL)) {
	504	value = object_property_get_str(OBJECT(dev), legacy_name, &err);
	505	} else {
8185bfc1	506	value = object_property_print(OBJECT(dev), props->name, &err);
d822979b PB	507	}
	508	g_free(legacy_name);
	509
	510	if (err) {
	511	error_free(err);
	512	continue;
ee46d8a5	513	}
bce54474	514	qdev_printf("%s = %s\n", props->name,
d822979b PB	515	value && *value ? value : "<null>");
d822979b PB	516	g_free(value);
ee46d8a5 AL	517	}
	518	}
	519
0d936928 AL	520	static void bus_print_dev(BusState bus, Monitor mon, DeviceState *dev, int indent)
	521	{
	522	BusClass *bc = BUS_GET_CLASS(bus);
	523
	524	if (bc->print_dev) {
	525	bc->print_dev(mon, dev, indent);
	526	}
	527	}
	528
ee46d8a5 AL	529	static void qdev_print(Monitor mon, DeviceState dev, int indent)
ee46d8a5 AL	530	{
bce54474	531	ObjectClass *class;
ee46d8a5 AL	532	BusState *child;
	533	qdev_printf("dev: %s, id \"%s\"\n", object_get_typename(OBJECT(dev)),
	534	dev->id ? dev->id : "");
	535	indent += 2;
	536	if (dev->num_gpio_in) {
	537	qdev_printf("gpio-in %d\n", dev->num_gpio_in);
	538	}
	539	if (dev->num_gpio_out) {
	540	qdev_printf("gpio-out %d\n", dev->num_gpio_out);
	541	}
bce54474 PB	542	class = object_get_class(OBJECT(dev));
	543	do {
	544	qdev_print_props(mon, dev, DEVICE_CLASS(class)->props, indent);
	545	class = object_class_get_parent(class);
	546	} while (class != object_class_by_name(TYPE_DEVICE));
da9fbe76	547	bus_print_dev(dev->parent_bus, mon, dev, indent);
ee46d8a5 AL	548	QLIST_FOREACH(child, &dev->child_bus, sibling) {
	549	qbus_print(mon, child, indent);
	550	}
	551	}
	552
	553	static void qbus_print(Monitor mon, BusState bus, int indent)
	554	{
0866aca1	555	BusChild *kid;
ee46d8a5 AL	556
	557	qdev_printf("bus: %s\n", bus->name);
	558	indent += 2;
0d936928	559	qdev_printf("type %s\n", object_get_typename(OBJECT(bus)));
0866aca1 AL	560	QTAILQ_FOREACH(kid, &bus->children, sibling) {
0866aca1 AL	561	DeviceState *dev = kid->child;
ee46d8a5 AL	562	qdev_print(mon, dev, indent);
	563	}
	564	}
	565	#undef qdev_printf
	566
	567	void do_info_qtree(Monitor *mon)
	568	{
	569	if (sysbus_get_default())
	570	qbus_print(mon, sysbus_get_default(), 0);
	571	}
	572
	573	void do_info_qdm(Monitor *mon)
	574	{
	575	object_class_foreach(qdev_print_devinfo, TYPE_DEVICE, false, NULL);
	576	}
	577
	578	int do_device_add(Monitor mon, const QDict qdict, QObject **ret_data)
	579	{
4e89978e	580	Error *local_err = NULL;
ee46d8a5 AL	581	QemuOpts *opts;
ee46d8a5 AL	582
4e89978e LC	583	opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, &local_err);
	584	if (error_is_set(&local_err)) {
	585	qerror_report_err(local_err);
	586	error_free(local_err);
ee46d8a5 AL	587	return -1;
	588	}
	589	if (!monitor_cur_is_qmp() && qdev_device_help(opts)) {
	590	qemu_opts_del(opts);
	591	return 0;
	592	}
	593	if (!qdev_device_add(opts)) {
	594	qemu_opts_del(opts);
	595	return -1;
	596	}
	597	return 0;
	598	}
	599
a15fef21	600	void qmp_device_del(const char id, Error *errp)
ee46d8a5	601	{
ee46d8a5 AL	602	DeviceState *dev;
	603
	604	dev = qdev_find_recursive(sysbus_get_default(), id);
	605	if (NULL == dev) {
a15fef21 LC	606	error_set(errp, QERR_DEVICE_NOT_FOUND, id);
a15fef21 LC	607	return;
56f9107e LC	608	}
56f9107e LC	609
a15fef21	610	qdev_unplug(dev, errp);
ee46d8a5 AL	611	}
	612
	613	void qdev_machine_init(void)
	614	{
	615	qdev_get_peripheral_anon();
	616	qdev_get_peripheral();
	617	}