[mirror_qemu.git] / hw / core / qdev-properties-system.c

/*
 * qdev property parsing and global properties
 * (parts specific for qemu-system-*)
 *
 * This file is based on code from hw/qdev-properties.c from
 * commit 074a86fccd185616469dfcdc0e157f438aebba18,
 * Copyright (c) Gerd Hoffmann <kraxel@redhat.com> and other contributors.
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 */

#include "net/net.h"
#include "hw/qdev.h"
#include "qapi/qmp/qerror.h"
#include "sysemu/blockdev.h"
#include "hw/block/block.h"
#include "net/hub.h"
#include "qapi/visitor.h"
#include "sysemu/char.h"
#include "sysemu/iothread.h"

static void get_pointer(Object *obj, Visitor *v, Property *prop,
                        char *(*print)(void *ptr),
                        const char *name, Error **errp)
{
    DeviceState *dev = DEVICE(obj);
    void **ptr = qdev_get_prop_ptr(dev, prop);
    char *p;

    p = *ptr ? print(*ptr) : g_strdup("");
    visit_type_str(v, &p, name, errp);
    g_free(p);
}

static void set_pointer(Object *obj, Visitor *v, Property *prop,
                        int (*parse)(DeviceState *dev, const char *str,
                                     void **ptr),
                        const char *name, Error **errp)
{
    DeviceState *dev = DEVICE(obj);
    Error *local_err = NULL;
    void **ptr = qdev_get_prop_ptr(dev, prop);
    char *str;
    int ret;

    if (dev->realized) {
        qdev_prop_set_after_realize(dev, name, errp);
        return;
    }

    visit_type_str(v, &str, name, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        return;
    }
    if (!*str) {
        g_free(str);
        *ptr = NULL;
        return;
    }
    ret = parse(dev, str, ptr);
    error_set_from_qdev_prop_error(errp, ret, dev, prop, str);
    g_free(str);
}

/* --- drive --- */

static int parse_drive(DeviceState *dev, const char *str, void **ptr)
{
    BlockDriverState *bs;

    bs = bdrv_find(str);
    if (bs == NULL) {
        return -ENOENT;
    }
    if (bdrv_attach_dev(bs, dev) < 0) {
        return -EEXIST;
    }
    *ptr = bs;
    return 0;
}

static void release_drive(Object *obj, const char *name, void *opaque)
{
    DeviceState *dev = DEVICE(obj);
    Property *prop = opaque;
    BlockDriverState **ptr = qdev_get_prop_ptr(dev, prop);

    if (*ptr) {
        bdrv_detach_dev(*ptr, dev);
        blockdev_auto_del(*ptr);
    }
}

static char *print_drive(void *ptr)
{
    return g_strdup(bdrv_get_device_name(ptr));
}

static void get_drive(Object *obj, Visitor *v, void *opaque,
                      const char *name, Error **errp)
{
    get_pointer(obj, v, opaque, print_drive, name, errp);
}

static void set_drive(Object *obj, Visitor *v, void *opaque,
                      const char *name, Error **errp)
{
    set_pointer(obj, v, opaque, parse_drive, name, errp);
}

PropertyInfo qdev_prop_drive = {
    .name  = "str",
    .legacy_name  = "drive",
    .get   = get_drive,
    .set   = set_drive,
    .release = release_drive,
};

/* --- character device --- */

static int parse_chr(DeviceState *dev, const char *str, void **ptr)
{
    CharDriverState *chr = qemu_chr_find(str);
    if (chr == NULL) {
        return -ENOENT;
    }
    if (qemu_chr_fe_claim(chr) != 0) {
        return -EEXIST;
    }
    *ptr = chr;
    return 0;
}

static void release_chr(Object *obj, const char *name, void *opaque)
{
    DeviceState *dev = DEVICE(obj);
    Property *prop = opaque;
    CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);
    CharDriverState *chr = *ptr;

    if (chr) {
        qemu_chr_add_handlers(chr, NULL, NULL, NULL, NULL);
        qemu_chr_fe_release(chr);
    }
}


static char *print_chr(void *ptr)
{
    CharDriverState *chr = ptr;
    const char *val = chr->label ? chr->label : "";

    return g_strdup(val);
}

static void get_chr(Object *obj, Visitor *v, void *opaque,
                    const char *name, Error **errp)
{
    get_pointer(obj, v, opaque, print_chr, name, errp);
}

static void set_chr(Object *obj, Visitor *v, void *opaque,
                    const char *name, Error **errp)
{
    set_pointer(obj, v, opaque, parse_chr, name, errp);
}

PropertyInfo qdev_prop_chr = {
    .name  = "str",
    .legacy_name  = "chr",
    .get   = get_chr,
    .set   = set_chr,
    .release = release_chr,
};

/* --- netdev device --- */

static int parse_netdev(DeviceState *dev, const char *str, void **ptr)
{
    NICPeers *peers_ptr = (NICPeers *)ptr;
    NICConf *conf = container_of(peers_ptr, NICConf, peers);
    NetClientState **ncs = peers_ptr->ncs;
    NetClientState *peers[MAX_QUEUE_NUM];
    int queues, i = 0;
    int ret;

    queues = qemu_find_net_clients_except(str, peers,
                                          NET_CLIENT_OPTIONS_KIND_NIC,
                                          MAX_QUEUE_NUM);
    if (queues == 0) {
        ret = -ENOENT;
        goto err;
    }

    if (queues > MAX_QUEUE_NUM) {
        ret = -E2BIG;
        goto err;
    }

    for (i = 0; i < queues; i++) {
        if (peers[i] == NULL) {
            ret = -ENOENT;
            goto err;
        }

        if (peers[i]->peer) {
            ret = -EEXIST;
            goto err;
        }

        if (ncs[i]) {
            ret = -EINVAL;
            goto err;
        }

        ncs[i] = peers[i];
        ncs[i]->queue_index = i;
    }

    conf->queues = queues;

    return 0;

err:
    return ret;
}

static char *print_netdev(void *ptr)
{
    NetClientState *netdev = ptr;
    const char *val = netdev->name ? netdev->name : "";

    return g_strdup(val);
}

static void get_netdev(Object *obj, Visitor *v, void *opaque,
                       const char *name, Error **errp)
{
    get_pointer(obj, v, opaque, print_netdev, name, errp);
}

static void set_netdev(Object *obj, Visitor *v, void *opaque,
                       const char *name, Error **errp)
{
    set_pointer(obj, v, opaque, parse_netdev, name, errp);
}

PropertyInfo qdev_prop_netdev = {
    .name  = "str",
    .legacy_name  = "netdev",
    .get   = get_netdev,
    .set   = set_netdev,
};

/* --- vlan --- */

static int print_vlan(DeviceState *dev, Property *prop, char *dest, size_t len)
{
    NetClientState **ptr = qdev_get_prop_ptr(dev, prop);

    if (*ptr) {
        int id;
        if (!net_hub_id_for_client(*ptr, &id)) {
            return snprintf(dest, len, "%d", id);
        }
    }

    return snprintf(dest, len, "<null>");
}

static void get_vlan(Object *obj, Visitor *v, void *opaque,
                     const char *name, Error **errp)
{
    DeviceState *dev = DEVICE(obj);
    Property *prop = opaque;
    NetClientState **ptr = qdev_get_prop_ptr(dev, prop);
    int32_t id = -1;

    if (*ptr) {
        int hub_id;
        if (!net_hub_id_for_client(*ptr, &hub_id)) {
            id = hub_id;
        }
    }

    visit_type_int32(v, &id, name, errp);
}

static void set_vlan(Object *obj, Visitor *v, void *opaque,
                     const char *name, Error **errp)
{
    DeviceState *dev = DEVICE(obj);
    Property *prop = opaque;
    NICPeers *peers_ptr = qdev_get_prop_ptr(dev, prop);
    NetClientState **ptr = &peers_ptr->ncs[0];
    Error *local_err = NULL;
    int32_t id;
    NetClientState *hubport;

    if (dev->realized) {
        qdev_prop_set_after_realize(dev, name, errp);
        return;
    }

    visit_type_int32(v, &id, name, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        return;
    }
    if (id == -1) {
        *ptr = NULL;
        return;
    }
    if (*ptr) {
        error_set_from_qdev_prop_error(errp, -EINVAL, dev, prop, name);
        return;
    }

    hubport = net_hub_port_find(id);
    if (!hubport) {
        error_set(errp, QERR_INVALID_PARAMETER_VALUE,
                  name, prop->info->name);
        return;
    }
    *ptr = hubport;
}

PropertyInfo qdev_prop_vlan = {
    .name  = "int32",
    .legacy_name  = "vlan",
    .print = print_vlan,
    .get   = get_vlan,
    .set   = set_vlan,
};

int qdev_prop_set_drive(DeviceState *dev, const char *name,
                        BlockDriverState *value)
{
    Error *err = NULL;
    const char *bdrv_name = value ? bdrv_get_device_name(value) : "";
    object_property_set_str(OBJECT(dev), bdrv_name,
                            name, &err);
    if (err) {
        qerror_report_err(err);
        error_free(err);
        return -1;
    }
    return 0;
}

void qdev_prop_set_drive_nofail(DeviceState *dev, const char *name,
                                BlockDriverState *value)
{
    if (qdev_prop_set_drive(dev, name, value) < 0) {
        exit(1);
    }
}
void qdev_prop_set_chr(DeviceState *dev, const char *name,
                       CharDriverState *value)
{
    assert(!value || value->label);
    object_property_set_str(OBJECT(dev),
                            value ? value->label : "", name, &error_abort);
}

void qdev_prop_set_netdev(DeviceState *dev, const char *name,
                          NetClientState *value)
{
    assert(!value || value->name);
    object_property_set_str(OBJECT(dev),
                            value ? value->name : "", name, &error_abort);
}

void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd)
{
    qdev_prop_set_macaddr(dev, "mac", nd->macaddr.a);
    if (nd->netdev) {
        qdev_prop_set_netdev(dev, "netdev", nd->netdev);
    }
    if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
        object_property_find(OBJECT(dev), "vectors", NULL)) {
        qdev_prop_set_uint32(dev, "vectors", nd->nvectors);
    }
    nd->instantiated = 1;
}

/* --- iothread --- */

static char *print_iothread(void *ptr)
{
    return iothread_get_id(ptr);
}

static int parse_iothread(DeviceState *dev, const char *str, void **ptr)
{
    IOThread *iothread;

    iothread = iothread_find(str);
    if (!iothread) {
        return -ENOENT;
    }
    object_ref(OBJECT(iothread));
    *ptr = iothread;
    return 0;
}

static void get_iothread(Object *obj, struct Visitor *v, void *opaque,
                         const char *name, Error **errp)
{
    get_pointer(obj, v, opaque, print_iothread, name, errp);
}

static void set_iothread(Object *obj, struct Visitor *v, void *opaque,
                         const char *name, Error **errp)
{
    set_pointer(obj, v, opaque, parse_iothread, name, errp);
}

static void release_iothread(Object *obj, const char *name, void *opaque)
{
    DeviceState *dev = DEVICE(obj);
    Property *prop = opaque;
    IOThread **ptr = qdev_get_prop_ptr(dev, prop);

    if (*ptr) {
        object_unref(OBJECT(*ptr));
    }
}

PropertyInfo qdev_prop_iothread = {
    .name = "iothread",
    .get = get_iothread,
    .set = set_iothread,
    .release = release_iothread,
};

static int qdev_add_one_global(QemuOpts *opts, void *opaque)
{
    GlobalProperty *g;
    ObjectClass *oc;

    g = g_malloc0(sizeof(*g));
    g->driver   = qemu_opt_get(opts, "driver");
    g->property = qemu_opt_get(opts, "property");
    g->value    = qemu_opt_get(opts, "value");
    oc = object_class_by_name(g->driver);
    if (oc) {
        DeviceClass *dc = DEVICE_CLASS(oc);

        if (dc->hotpluggable) {
            /* If hotpluggable then skip not_used checking. */
            g->not_used = false;
        } else {
            /* Maybe a typo. */
            g->not_used = true;
        }
    } else {
        /* Maybe a typo. */
        g->not_used = true;
    }
    qdev_prop_register_global(g);
    return 0;
}

void qemu_add_globals(void)
{
    qemu_opts_foreach(qemu_find_opts("global"), qdev_add_one_global, NULL, 0);
}
Commit	Line	Data
a404b612 EH	1	/*
	2	* qdev property parsing and global properties
	3	* (parts specific for qemu-system-*)
	4	*
	5	* This file is based on code from hw/qdev-properties.c from
	6	* commit 074a86fccd185616469dfcdc0e157f438aebba18,
	7	* Copyright (c) Gerd Hoffmann <kraxel@redhat.com> and other contributors.
	8	*
	9	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	10	* See the COPYING file in the top-level directory.
	11	*/
	12
501a7ce7	13	#include "net/net.h"
83c9f4ca	14	#include "hw/qdev.h"
501a7ce7 AF	15	#include "qapi/qmp/qerror.h"
501a7ce7 AF	16	#include "sysemu/blockdev.h"
0d09e41a	17	#include "hw/block/block.h"
a404b612	18	#include "net/hub.h"
501a7ce7	19	#include "qapi/visitor.h"
dccfcd0e	20	#include "sysemu/char.h"
6e4a876b	21	#include "sysemu/iothread.h"
a404b612 EH	22
a404b612 EH	23	static void get_pointer(Object obj, Visitor v, Property *prop,
7d1de464	24	char (print)(void *ptr),
a404b612 EH	25	const char name, Error *errp)
	26	{
	27	DeviceState *dev = DEVICE(obj);
	28	void **ptr = qdev_get_prop_ptr(dev, prop);
	29	char *p;
	30
7d1de464	31	p = ptr ? print(ptr) : g_strdup("");
a404b612	32	visit_type_str(v, &p, name, errp);
7d1de464	33	g_free(p);
a404b612 EH	34	}
	35
	36	static void set_pointer(Object obj, Visitor v, Property *prop,
	37	int (parse)(DeviceState dev, const char *str,
	38	void **ptr),
	39	const char name, Error *errp)
	40	{
	41	DeviceState *dev = DEVICE(obj);
	42	Error *local_err = NULL;
	43	void **ptr = qdev_get_prop_ptr(dev, prop);
	44	char *str;
	45	int ret;
	46
7983c8a3	47	if (dev->realized) {
b000dfbd	48	qdev_prop_set_after_realize(dev, name, errp);
a404b612 EH	49	return;
	50	}
	51
	52	visit_type_str(v, &str, name, &local_err);
	53	if (local_err) {
	54	error_propagate(errp, local_err);
	55	return;
	56	}
	57	if (!*str) {
	58	g_free(str);
	59	*ptr = NULL;
	60	return;
	61	}
	62	ret = parse(dev, str, ptr);
	63	error_set_from_qdev_prop_error(errp, ret, dev, prop, str);
	64	g_free(str);
	65	}
	66
	67	/* --- drive --- */
	68
	69	static int parse_drive(DeviceState dev, const char str, void **ptr)
	70	{
	71	BlockDriverState *bs;
	72
	73	bs = bdrv_find(str);
	74	if (bs == NULL) {
	75	return -ENOENT;
	76	}
	77	if (bdrv_attach_dev(bs, dev) < 0) {
	78	return -EEXIST;
	79	}
	80	*ptr = bs;
	81	return 0;
	82	}
	83
	84	static void release_drive(Object obj, const char name, void *opaque)
	85	{
	86	DeviceState *dev = DEVICE(obj);
	87	Property *prop = opaque;
	88	BlockDriverState **ptr = qdev_get_prop_ptr(dev, prop);
	89
	90	if (*ptr) {
	91	bdrv_detach_dev(*ptr, dev);
	92	blockdev_auto_del(*ptr);
	93	}
	94	}
	95
7d1de464	96	static char print_drive(void ptr)
a404b612	97	{
7d1de464	98	return g_strdup(bdrv_get_device_name(ptr));
a404b612 EH	99	}
	100
	101	static void get_drive(Object obj, Visitor v, void *opaque,
	102	const char name, Error *errp)
	103	{
	104	get_pointer(obj, v, opaque, print_drive, name, errp);
	105	}
	106
	107	static void set_drive(Object obj, Visitor v, void *opaque,
	108	const char name, Error *errp)
	109	{
	110	set_pointer(obj, v, opaque, parse_drive, name, errp);
	111	}
	112
	113	PropertyInfo qdev_prop_drive = {
85ca1202 PB	114	.name = "str",
85ca1202 PB	115	.legacy_name = "drive",
a404b612 EH	116	.get = get_drive,
	117	.set = set_drive,
	118	.release = release_drive,
	119	};
	120
	121	/* --- character device --- */
	122
	123	static int parse_chr(DeviceState dev, const char str, void **ptr)
	124	{
	125	CharDriverState *chr = qemu_chr_find(str);
	126	if (chr == NULL) {
	127	return -ENOENT;
	128	}
44c473de	129	if (qemu_chr_fe_claim(chr) != 0) {
a404b612 EH	130	return -EEXIST;
	131	}
	132	*ptr = chr;
a404b612 EH	133	return 0;
	134	}
	135
	136	static void release_chr(Object obj, const char name, void *opaque)
	137	{
	138	DeviceState *dev = DEVICE(obj);
	139	Property *prop = opaque;
	140	CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);
85d91e32	141	CharDriverState chr = ptr;
a404b612	142
85d91e32 HG	143	if (chr) {
85d91e32 HG	144	qemu_chr_add_handlers(chr, NULL, NULL, NULL, NULL);
44c473de	145	qemu_chr_fe_release(chr);
a404b612 EH	146	}
	147	}
	148
	149
7d1de464	150	static char print_chr(void ptr)
a404b612 EH	151	{
a404b612 EH	152	CharDriverState *chr = ptr;
7d1de464	153	const char *val = chr->label ? chr->label : "";
a404b612	154
7d1de464	155	return g_strdup(val);
a404b612 EH	156	}
	157
	158	static void get_chr(Object obj, Visitor v, void *opaque,
	159	const char name, Error *errp)
	160	{
	161	get_pointer(obj, v, opaque, print_chr, name, errp);
	162	}
	163
	164	static void set_chr(Object obj, Visitor v, void *opaque,
	165	const char name, Error *errp)
	166	{
	167	set_pointer(obj, v, opaque, parse_chr, name, errp);
	168	}
	169
	170	PropertyInfo qdev_prop_chr = {
85ca1202 PB	171	.name = "str",
85ca1202 PB	172	.legacy_name = "chr",
a404b612 EH	173	.get = get_chr,
	174	.set = set_chr,
	175	.release = release_chr,
	176	};
	177
	178	/* --- netdev device --- */
	179
	180	static int parse_netdev(DeviceState dev, const char str, void **ptr)
	181	{
1ceef9f2 JW	182	NICPeers peers_ptr = (NICPeers )ptr;
	183	NICConf *conf = container_of(peers_ptr, NICConf, peers);
	184	NetClientState **ncs = peers_ptr->ncs;
	185	NetClientState *peers[MAX_QUEUE_NUM];
	186	int queues, i = 0;
	187	int ret;
a404b612	188
1ceef9f2 JW	189	queues = qemu_find_net_clients_except(str, peers,
	190	NET_CLIENT_OPTIONS_KIND_NIC,
	191	MAX_QUEUE_NUM);
	192	if (queues == 0) {
	193	ret = -ENOENT;
	194	goto err;
a404b612	195	}
1ceef9f2 JW	196
	197	if (queues > MAX_QUEUE_NUM) {
	198	ret = -E2BIG;
	199	goto err;
	200	}
	201
	202	for (i = 0; i < queues; i++) {
	203	if (peers[i] == NULL) {
	204	ret = -ENOENT;
	205	goto err;
	206	}
	207
	208	if (peers[i]->peer) {
	209	ret = -EEXIST;
	210	goto err;
	211	}
	212
30c367ed VY	213	if (ncs[i]) {
	214	ret = -EINVAL;
	215	goto err;
	216	}
	217
1ceef9f2 JW	218	ncs[i] = peers[i];
1ceef9f2 JW	219	ncs[i]->queue_index = i;
a404b612	220	}
1ceef9f2 JW	221
	222	conf->queues = queues;
	223
a404b612	224	return 0;
1ceef9f2 JW	225
	226	err:
	227	return ret;
a404b612 EH	228	}
a404b612 EH	229
7d1de464	230	static char print_netdev(void ptr)
a404b612 EH	231	{
a404b612 EH	232	NetClientState *netdev = ptr;
7d1de464	233	const char *val = netdev->name ? netdev->name : "";
a404b612	234
7d1de464	235	return g_strdup(val);
a404b612 EH	236	}
	237
	238	static void get_netdev(Object obj, Visitor v, void *opaque,
	239	const char name, Error *errp)
	240	{
	241	get_pointer(obj, v, opaque, print_netdev, name, errp);
	242	}
	243
	244	static void set_netdev(Object obj, Visitor v, void *opaque,
	245	const char name, Error *errp)
	246	{
	247	set_pointer(obj, v, opaque, parse_netdev, name, errp);
	248	}
	249
	250	PropertyInfo qdev_prop_netdev = {
85ca1202 PB	251	.name = "str",
85ca1202 PB	252	.legacy_name = "netdev",
a404b612 EH	253	.get = get_netdev,
	254	.set = set_netdev,
	255	};
	256
	257	/* --- vlan --- */
	258
	259	static int print_vlan(DeviceState dev, Property prop, char *dest, size_t len)
	260	{
	261	NetClientState **ptr = qdev_get_prop_ptr(dev, prop);
	262
	263	if (*ptr) {
	264	int id;
	265	if (!net_hub_id_for_client(*ptr, &id)) {
	266	return snprintf(dest, len, "%d", id);
	267	}
	268	}
	269
	270	return snprintf(dest, len, "<null>");
	271	}
	272
	273	static void get_vlan(Object obj, Visitor v, void *opaque,
	274	const char name, Error *errp)
	275	{
	276	DeviceState *dev = DEVICE(obj);
	277	Property *prop = opaque;
	278	NetClientState **ptr = qdev_get_prop_ptr(dev, prop);
	279	int32_t id = -1;
	280
	281	if (*ptr) {
	282	int hub_id;
	283	if (!net_hub_id_for_client(*ptr, &hub_id)) {
	284	id = hub_id;
	285	}
	286	}
	287
	288	visit_type_int32(v, &id, name, errp);
	289	}
	290
	291	static void set_vlan(Object obj, Visitor v, void *opaque,
	292	const char name, Error *errp)
	293	{
	294	DeviceState *dev = DEVICE(obj);
	295	Property *prop = opaque;
1ceef9f2 JW	296	NICPeers *peers_ptr = qdev_get_prop_ptr(dev, prop);
1ceef9f2 JW	297	NetClientState **ptr = &peers_ptr->ncs[0];
a404b612 EH	298	Error *local_err = NULL;
	299	int32_t id;
	300	NetClientState *hubport;
	301
7983c8a3	302	if (dev->realized) {
b000dfbd	303	qdev_prop_set_after_realize(dev, name, errp);
a404b612 EH	304	return;
	305	}
	306
	307	visit_type_int32(v, &id, name, &local_err);
	308	if (local_err) {
	309	error_propagate(errp, local_err);
	310	return;
	311	}
	312	if (id == -1) {
	313	*ptr = NULL;
	314	return;
	315	}
30c367ed VY	316	if (*ptr) {
	317	error_set_from_qdev_prop_error(errp, -EINVAL, dev, prop, name);
	318	return;
	319	}
a404b612 EH	320
	321	hubport = net_hub_port_find(id);
	322	if (!hubport) {
	323	error_set(errp, QERR_INVALID_PARAMETER_VALUE,
	324	name, prop->info->name);
	325	return;
	326	}
	327	*ptr = hubport;
	328	}
	329
	330	PropertyInfo qdev_prop_vlan = {
85ca1202 PB	331	.name = "int32",
85ca1202 PB	332	.legacy_name = "vlan",
a404b612 EH	333	.print = print_vlan,
	334	.get = get_vlan,
	335	.set = set_vlan,
	336	};
	337
	338	int qdev_prop_set_drive(DeviceState dev, const char name,
	339	BlockDriverState *value)
	340	{
2f719f19	341	Error *err = NULL;
a404b612 EH	342	const char *bdrv_name = value ? bdrv_get_device_name(value) : "";
a404b612 EH	343	object_property_set_str(OBJECT(dev), bdrv_name,
2f719f19 MA	344	name, &err);
	345	if (err) {
	346	qerror_report_err(err);
	347	error_free(err);
a404b612 EH	348	return -1;
	349	}
	350	return 0;
	351	}
	352
	353	void qdev_prop_set_drive_nofail(DeviceState dev, const char name,
	354	BlockDriverState *value)
	355	{
	356	if (qdev_prop_set_drive(dev, name, value) < 0) {
	357	exit(1);
	358	}
	359	}
	360	void qdev_prop_set_chr(DeviceState dev, const char name,
	361	CharDriverState *value)
	362	{
a404b612 EH	363	assert(!value \|\| value->label);
a404b612 EH	364	object_property_set_str(OBJECT(dev),
5433a0a8	365	value ? value->label : "", name, &error_abort);
a404b612 EH	366	}
	367
	368	void qdev_prop_set_netdev(DeviceState dev, const char name,
	369	NetClientState *value)
	370	{
a404b612 EH	371	assert(!value \|\| value->name);
a404b612 EH	372	object_property_set_str(OBJECT(dev),
5433a0a8	373	value ? value->name : "", name, &error_abort);
a404b612 EH	374	}
	375
	376	void qdev_set_nic_properties(DeviceState dev, NICInfo nd)
	377	{
	378	qdev_prop_set_macaddr(dev, "mac", nd->macaddr.a);
	379	if (nd->netdev) {
	380	qdev_prop_set_netdev(dev, "netdev", nd->netdev);
	381	}
	382	if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
	383	object_property_find(OBJECT(dev), "vectors", NULL)) {
	384	qdev_prop_set_uint32(dev, "vectors", nd->nvectors);
	385	}
	386	nd->instantiated = 1;
	387	}
	388
6e4a876b SH	389	/* --- iothread --- */
	390
	391	static char print_iothread(void ptr)
	392	{
	393	return iothread_get_id(ptr);
	394	}
	395
	396	static int parse_iothread(DeviceState dev, const char str, void **ptr)
	397	{
	398	IOThread *iothread;
	399
	400	iothread = iothread_find(str);
	401	if (!iothread) {
	402	return -ENOENT;
	403	}
	404	object_ref(OBJECT(iothread));
	405	*ptr = iothread;
	406	return 0;
	407	}
	408
	409	static void get_iothread(Object obj, struct Visitor v, void *opaque,
	410	const char name, Error *errp)
	411	{
	412	get_pointer(obj, v, opaque, print_iothread, name, errp);
	413	}
	414
	415	static void set_iothread(Object obj, struct Visitor v, void *opaque,
	416	const char name, Error *errp)
	417	{
	418	set_pointer(obj, v, opaque, parse_iothread, name, errp);
	419	}
	420
	421	static void release_iothread(Object obj, const char name, void *opaque)
	422	{
	423	DeviceState *dev = DEVICE(obj);
	424	Property *prop = opaque;
	425	IOThread **ptr = qdev_get_prop_ptr(dev, prop);
	426
	427	if (*ptr) {
	428	object_unref(OBJECT(*ptr));
	429	}
	430	}
	431
	432	PropertyInfo qdev_prop_iothread = {
	433	.name = "iothread",
	434	.get = get_iothread,
	435	.set = set_iothread,
	436	.release = release_iothread,
	437	};
	438
a404b612 EH	439	static int qdev_add_one_global(QemuOpts opts, void opaque)
	440	{
	441	GlobalProperty *g;
9f9260a3	442	ObjectClass *oc;
a404b612 EH	443
	444	g = g_malloc0(sizeof(*g));
	445	g->driver = qemu_opt_get(opts, "driver");
	446	g->property = qemu_opt_get(opts, "property");
	447	g->value = qemu_opt_get(opts, "value");
9f9260a3 DS	448	oc = object_class_by_name(g->driver);
	449	if (oc) {
	450	DeviceClass *dc = DEVICE_CLASS(oc);
	451
	452	if (dc->hotpluggable) {
	453	/* If hotpluggable then skip not_used checking. */
	454	g->not_used = false;
	455	} else {
	456	/* Maybe a typo. */
	457	g->not_used = true;
	458	}
	459	} else {
	460	/* Maybe a typo. */
	461	g->not_used = true;
	462	}
a404b612 EH	463	qdev_prop_register_global(g);
	464	return 0;
	465	}
	466
	467	void qemu_add_globals(void)
	468	{
	469	qemu_opts_foreach(qemu_find_opts("global"), qdev_add_one_global, NULL, 0);
	470	}