[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 <[email protected]> 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/block-backend.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)
{
    BlockBackend *blk;

    blk = blk_by_name(str);
    if (!blk) {
        return -ENOENT;
    }
    if (blk_attach_dev(blk, dev) < 0) {
        return -EEXIST;
    }
    *ptr = blk;
    return 0;
}

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

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

static char *print_drive(void *ptr)
{
    return g_strdup(blk_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",
    .description = "ID of a drive to use as a backend",
    .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",
    .description = "ID of a chardev to use as a backend",
    .get   = get_chr,
    .set   = set_chr,
    .release = release_chr,
};

/* --- netdev device --- */
static void get_netdev(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);
    char *p = g_strdup(peers_ptr->ncs[0] ? peers_ptr->ncs[0]->name : "");

    visit_type_str(v, &p, name, errp);
    g_free(p);
}

static void set_netdev(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 **ncs = peers_ptr->ncs;
    NetClientState *peers[MAX_QUEUE_NUM];
    Error *local_err = NULL;
    int queues, err = 0, i = 0;
    char *str;

    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;
    }

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

    if (queues > MAX_QUEUE_NUM) {
        error_setg(errp, "queues of backend '%s'(%d) exceeds QEMU limitation(%d)",
                   str, queues, MAX_QUEUE_NUM);
        goto out;
    }

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

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

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

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

    peers_ptr->queues = queues;

out:
    error_set_from_qdev_prop_error(errp, err, dev, prop, str);
    g_free(str);
}

PropertyInfo qdev_prop_netdev = {
    .name  = "str",
    .description = "ID of a netdev to use as a backend",
    .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",
    .description = "Integer VLAN id to connect to",
    .print = print_vlan,
    .get   = get_vlan,
    .set   = set_vlan,
};

int qdev_prop_set_drive(DeviceState *dev, const char *name,
                        BlockBackend *value)
{
    Error *err = NULL;
    object_property_set_str(OBJECT(dev),
                            value ? blk_name(value) : "", 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,
                                BlockBackend *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;
}

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

    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");
    g->user_provided = 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 <[email protected]> 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	15	#include "qapi/qmp/qerror.h"
4be74634	16	#include "sysemu/block-backend.h"
501a7ce7	17	#include "sysemu/blockdev.h"
0d09e41a	18	#include "hw/block/block.h"
a404b612	19	#include "net/hub.h"
501a7ce7	20	#include "qapi/visitor.h"
dccfcd0e	21	#include "sysemu/char.h"
6e4a876b	22	#include "sysemu/iothread.h"
a404b612 EH	23
a404b612 EH	24	static void get_pointer(Object obj, Visitor v, Property *prop,
7d1de464	25	char (print)(void *ptr),
a404b612 EH	26	const char name, Error *errp)
	27	{
	28	DeviceState *dev = DEVICE(obj);
	29	void **ptr = qdev_get_prop_ptr(dev, prop);
	30	char *p;
	31
7d1de464	32	p = ptr ? print(ptr) : g_strdup("");
a404b612	33	visit_type_str(v, &p, name, errp);
7d1de464	34	g_free(p);
a404b612 EH	35	}
	36
	37	static void set_pointer(Object obj, Visitor v, Property *prop,
	38	int (parse)(DeviceState dev, const char *str,
	39	void **ptr),
	40	const char name, Error *errp)
	41	{
	42	DeviceState *dev = DEVICE(obj);
	43	Error *local_err = NULL;
	44	void **ptr = qdev_get_prop_ptr(dev, prop);
	45	char *str;
	46	int ret;
	47
7983c8a3	48	if (dev->realized) {
b000dfbd	49	qdev_prop_set_after_realize(dev, name, errp);
a404b612 EH	50	return;
	51	}
	52
	53	visit_type_str(v, &str, name, &local_err);
	54	if (local_err) {
	55	error_propagate(errp, local_err);
	56	return;
	57	}
	58	if (!*str) {
	59	g_free(str);
	60	*ptr = NULL;
	61	return;
	62	}
	63	ret = parse(dev, str, ptr);
	64	error_set_from_qdev_prop_error(errp, ret, dev, prop, str);
	65	g_free(str);
	66	}
	67
	68	/* --- drive --- */
	69
	70	static int parse_drive(DeviceState dev, const char str, void **ptr)
	71	{
4be74634	72	BlockBackend *blk;
a404b612	73
4be74634 MA	74	blk = blk_by_name(str);
4be74634 MA	75	if (!blk) {
a404b612 EH	76	return -ENOENT;
a404b612 EH	77	}
4be74634	78	if (blk_attach_dev(blk, dev) < 0) {
a404b612 EH	79	return -EEXIST;
a404b612 EH	80	}
4be74634	81	*ptr = blk;
a404b612 EH	82	return 0;
	83	}
	84
	85	static void release_drive(Object obj, const char name, void *opaque)
	86	{
	87	DeviceState *dev = DEVICE(obj);
	88	Property *prop = opaque;
4be74634	89	BlockBackend **ptr = qdev_get_prop_ptr(dev, prop);
a404b612 EH	90
a404b612 EH	91	if (*ptr) {
4be74634	92	blk_detach_dev(*ptr, dev);
a404b612 EH	93	blockdev_auto_del(*ptr);
	94	}
	95	}
	96
7d1de464	97	static char print_drive(void ptr)
a404b612	98	{
4be74634	99	return g_strdup(blk_name(ptr));
a404b612 EH	100	}
	101
	102	static void get_drive(Object obj, Visitor v, void *opaque,
	103	const char name, Error *errp)
	104	{
	105	get_pointer(obj, v, opaque, print_drive, name, errp);
	106	}
	107
	108	static void set_drive(Object obj, Visitor v, void *opaque,
	109	const char name, Error *errp)
	110	{
	111	set_pointer(obj, v, opaque, parse_drive, name, errp);
	112	}
	113
	114	PropertyInfo qdev_prop_drive = {
85ca1202	115	.name = "str",
51b2e8c3	116	.description = "ID of a drive to use as a backend",
a404b612 EH	117	.get = get_drive,
	118	.set = set_drive,
	119	.release = release_drive,
	120	};
	121
	122	/* --- character device --- */
	123
	124	static int parse_chr(DeviceState dev, const char str, void **ptr)
	125	{
	126	CharDriverState *chr = qemu_chr_find(str);
	127	if (chr == NULL) {
	128	return -ENOENT;
	129	}
44c473de	130	if (qemu_chr_fe_claim(chr) != 0) {
a404b612 EH	131	return -EEXIST;
	132	}
	133	*ptr = chr;
a404b612 EH	134	return 0;
	135	}
	136
	137	static void release_chr(Object obj, const char name, void *opaque)
	138	{
	139	DeviceState *dev = DEVICE(obj);
	140	Property *prop = opaque;
	141	CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);
85d91e32	142	CharDriverState chr = ptr;
a404b612	143
85d91e32 HG	144	if (chr) {
85d91e32 HG	145	qemu_chr_add_handlers(chr, NULL, NULL, NULL, NULL);
44c473de	146	qemu_chr_fe_release(chr);
a404b612 EH	147	}
	148	}
	149
	150
7d1de464	151	static char print_chr(void ptr)
a404b612 EH	152	{
a404b612 EH	153	CharDriverState *chr = ptr;
7d1de464	154	const char *val = chr->label ? chr->label : "";
a404b612	155
7d1de464	156	return g_strdup(val);
a404b612 EH	157	}
	158
	159	static void get_chr(Object obj, Visitor v, void *opaque,
	160	const char name, Error *errp)
	161	{
	162	get_pointer(obj, v, opaque, print_chr, name, errp);
	163	}
	164
	165	static void set_chr(Object obj, Visitor v, void *opaque,
	166	const char name, Error *errp)
	167	{
	168	set_pointer(obj, v, opaque, parse_chr, name, errp);
	169	}
	170
	171	PropertyInfo qdev_prop_chr = {
85ca1202	172	.name = "str",
51b2e8c3	173	.description = "ID of a chardev to use as a backend",
a404b612 EH	174	.get = get_chr,
	175	.set = set_chr,
	176	.release = release_chr,
	177	};
	178
	179	/* --- netdev device --- */
23120b13 JW	180	static void get_netdev(Object obj, Visitor v, void *opaque,
	181	const char name, Error *errp)
	182	{
	183	DeviceState *dev = DEVICE(obj);
	184	Property *prop = opaque;
	185	NICPeers *peers_ptr = qdev_get_prop_ptr(dev, prop);
	186	char *p = g_strdup(peers_ptr->ncs[0] ? peers_ptr->ncs[0]->name : "");
	187
	188	visit_type_str(v, &p, name, errp);
	189	g_free(p);
	190	}
a404b612	191
23120b13 JW	192	static void set_netdev(Object obj, Visitor v, void *opaque,
23120b13 JW	193	const char name, Error *errp)
a404b612	194	{
23120b13 JW	195	DeviceState *dev = DEVICE(obj);
	196	Property *prop = opaque;
	197	NICPeers *peers_ptr = qdev_get_prop_ptr(dev, prop);
1ceef9f2 JW	198	NetClientState **ncs = peers_ptr->ncs;
1ceef9f2 JW	199	NetClientState *peers[MAX_QUEUE_NUM];
23120b13 JW	200	Error *local_err = NULL;
	201	int queues, err = 0, i = 0;
	202	char *str;
	203
	204	if (dev->realized) {
	205	qdev_prop_set_after_realize(dev, name, errp);
	206	return;
	207	}
	208
	209	visit_type_str(v, &str, name, &local_err);
	210	if (local_err) {
	211	error_propagate(errp, local_err);
	212	return;
	213	}
a404b612	214
1ceef9f2 JW	215	queues = qemu_find_net_clients_except(str, peers,
	216	NET_CLIENT_OPTIONS_KIND_NIC,
	217	MAX_QUEUE_NUM);
	218	if (queues == 0) {
23120b13 JW	219	err = -ENOENT;
23120b13 JW	220	goto out;
a404b612	221	}
1ceef9f2 JW	222
1ceef9f2 JW	223	if (queues > MAX_QUEUE_NUM) {
23120b13 JW	224	error_setg(errp, "queues of backend '%s'(%d) exceeds QEMU limitation(%d)",
	225	str, queues, MAX_QUEUE_NUM);
	226	goto out;
1ceef9f2 JW	227	}
	228
	229	for (i = 0; i < queues; i++) {
	230	if (peers[i] == NULL) {
23120b13 JW	231	err = -ENOENT;
23120b13 JW	232	goto out;
1ceef9f2 JW	233	}
	234
	235	if (peers[i]->peer) {
23120b13 JW	236	err = -EEXIST;
23120b13 JW	237	goto out;
1ceef9f2 JW	238	}
1ceef9f2 JW	239
30c367ed	240	if (ncs[i]) {
23120b13 JW	241	err = -EINVAL;
23120b13 JW	242	goto out;
30c367ed VY	243	}
30c367ed VY	244
1ceef9f2 JW	245	ncs[i] = peers[i];
1ceef9f2 JW	246	ncs[i]->queue_index = i;
a404b612	247	}
1ceef9f2	248
575a1c0e	249	peers_ptr->queues = queues;
1ceef9f2	250
23120b13 JW	251	out:
	252	error_set_from_qdev_prop_error(errp, err, dev, prop, str);
	253	g_free(str);
a404b612 EH	254	}
	255
	256	PropertyInfo qdev_prop_netdev = {
85ca1202	257	.name = "str",
51b2e8c3	258	.description = "ID of a netdev to use as a backend",
a404b612 EH	259	.get = get_netdev,
	260	.set = set_netdev,
	261	};
	262
	263	/* --- vlan --- */
	264
	265	static int print_vlan(DeviceState dev, Property prop, char *dest, size_t len)
	266	{
	267	NetClientState **ptr = qdev_get_prop_ptr(dev, prop);
	268
	269	if (*ptr) {
	270	int id;
	271	if (!net_hub_id_for_client(*ptr, &id)) {
	272	return snprintf(dest, len, "%d", id);
	273	}
	274	}
	275
	276	return snprintf(dest, len, "<null>");
	277	}
	278
	279	static void get_vlan(Object obj, Visitor v, void *opaque,
	280	const char name, Error *errp)
	281	{
	282	DeviceState *dev = DEVICE(obj);
	283	Property *prop = opaque;
	284	NetClientState **ptr = qdev_get_prop_ptr(dev, prop);
	285	int32_t id = -1;
	286
	287	if (*ptr) {
	288	int hub_id;
	289	if (!net_hub_id_for_client(*ptr, &hub_id)) {
	290	id = hub_id;
	291	}
	292	}
	293
	294	visit_type_int32(v, &id, name, errp);
	295	}
	296
	297	static void set_vlan(Object obj, Visitor v, void *opaque,
	298	const char name, Error *errp)
	299	{
	300	DeviceState *dev = DEVICE(obj);
	301	Property *prop = opaque;
1ceef9f2 JW	302	NICPeers *peers_ptr = qdev_get_prop_ptr(dev, prop);
1ceef9f2 JW	303	NetClientState **ptr = &peers_ptr->ncs[0];
a404b612 EH	304	Error *local_err = NULL;
	305	int32_t id;
	306	NetClientState *hubport;
	307
7983c8a3	308	if (dev->realized) {
b000dfbd	309	qdev_prop_set_after_realize(dev, name, errp);
a404b612 EH	310	return;
	311	}
	312
	313	visit_type_int32(v, &id, name, &local_err);
	314	if (local_err) {
	315	error_propagate(errp, local_err);
	316	return;
	317	}
	318	if (id == -1) {
	319	*ptr = NULL;
	320	return;
	321	}
30c367ed VY	322	if (*ptr) {
	323	error_set_from_qdev_prop_error(errp, -EINVAL, dev, prop, name);
	324	return;
	325	}
a404b612 EH	326
	327	hubport = net_hub_port_find(id);
	328	if (!hubport) {
	329	error_set(errp, QERR_INVALID_PARAMETER_VALUE,
	330	name, prop->info->name);
	331	return;
	332	}
	333	*ptr = hubport;
	334	}
	335
	336	PropertyInfo qdev_prop_vlan = {
85ca1202	337	.name = "int32",
51b2e8c3	338	.description = "Integer VLAN id to connect to",
a404b612 EH	339	.print = print_vlan,
	340	.get = get_vlan,
	341	.set = set_vlan,
	342	};
	343
	344	int qdev_prop_set_drive(DeviceState dev, const char name,
4be74634	345	BlockBackend *value)
a404b612	346	{
2f719f19	347	Error *err = NULL;
4be74634 MA	348	object_property_set_str(OBJECT(dev),
4be74634 MA	349	value ? blk_name(value) : "", name, &err);
2f719f19 MA	350	if (err) {
	351	qerror_report_err(err);
	352	error_free(err);
a404b612 EH	353	return -1;
	354	}
	355	return 0;
	356	}
	357
	358	void qdev_prop_set_drive_nofail(DeviceState dev, const char name,
4be74634	359	BlockBackend *value)
a404b612 EH	360	{
	361	if (qdev_prop_set_drive(dev, name, value) < 0) {
	362	exit(1);
	363	}
	364	}
	365	void qdev_prop_set_chr(DeviceState dev, const char name,
	366	CharDriverState *value)
	367	{
a404b612 EH	368	assert(!value \|\| value->label);
a404b612 EH	369	object_property_set_str(OBJECT(dev),
5433a0a8	370	value ? value->label : "", name, &error_abort);
a404b612 EH	371	}
	372
	373	void qdev_prop_set_netdev(DeviceState dev, const char name,
	374	NetClientState *value)
	375	{
a404b612 EH	376	assert(!value \|\| value->name);
a404b612 EH	377	object_property_set_str(OBJECT(dev),
5433a0a8	378	value ? value->name : "", name, &error_abort);
a404b612 EH	379	}
	380
	381	void qdev_set_nic_properties(DeviceState dev, NICInfo nd)
	382	{
	383	qdev_prop_set_macaddr(dev, "mac", nd->macaddr.a);
	384	if (nd->netdev) {
	385	qdev_prop_set_netdev(dev, "netdev", nd->netdev);
	386	}
	387	if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
	388	object_property_find(OBJECT(dev), "vectors", NULL)) {
	389	qdev_prop_set_uint32(dev, "vectors", nd->nvectors);
	390	}
	391	nd->instantiated = 1;
	392	}
	393
	394	static int qdev_add_one_global(QemuOpts opts, void opaque)
	395	{
	396	GlobalProperty *g;
	397
	398	g = g_malloc0(sizeof(*g));
	399	g->driver = qemu_opt_get(opts, "driver");
	400	g->property = qemu_opt_get(opts, "property");
	401	g->value = qemu_opt_get(opts, "value");
b3ce84fe	402	g->user_provided = true;
a404b612 EH	403	qdev_prop_register_global(g);
	404	return 0;
	405	}
	406
	407	void qemu_add_globals(void)
	408	{
	409	qemu_opts_foreach(qemu_find_opts("global"), qdev_add_one_global, NULL, 0);
	410	}