/*
- * qdev property parsing and global properties
+ * qdev property parsing
* (parts specific for qemu-system-*)
*
* This file is based on code from hw/qdev-properties.c from
* See the COPYING file in the top-level directory.
*/
+#include "qemu/osdep.h"
#include "net/net.h"
#include "hw/qdev.h"
+#include "qapi/error.h"
#include "qapi/qmp/qerror.h"
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h"
char *p;
p = *ptr ? print(*ptr) : g_strdup("");
- visit_type_str(v, &p, name, errp);
+ visit_type_str(v, name, &p, errp);
g_free(p);
}
return;
}
- visit_type_str(v, &str, name, &local_err);
+ visit_type_str(v, name, &str, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return;
const char *propname, Error **errp)
{
BlockBackend *blk;
+ bool blk_created = false;
+ int ret;
blk = blk_by_name(str);
+ if (!blk) {
+ BlockDriverState *bs = bdrv_lookup_bs(NULL, str, NULL);
+ if (bs) {
+ blk = blk_new(0, BLK_PERM_ALL);
+ blk_created = true;
+
+ ret = blk_insert_bs(blk, bs, errp);
+ if (ret < 0) {
+ goto fail;
+ }
+ }
+ }
if (!blk) {
error_setg(errp, "Property '%s.%s' can't find value '%s'",
object_get_typename(OBJECT(dev)), propname, str);
- return;
+ goto fail;
}
if (blk_attach_dev(blk, dev) < 0) {
DriveInfo *dinfo = blk_legacy_dinfo(blk);
- if (dinfo->type != IF_NONE) {
+ if (dinfo && dinfo->type != IF_NONE) {
error_setg(errp, "Drive '%s' is already in use because "
"it has been automatically connected to another "
"device (did you need 'if=none' in the drive options?)",
error_setg(errp, "Drive '%s' is already in use by another device",
str);
}
- return;
+ goto fail;
}
+
*ptr = blk;
+
+fail:
+ if (blk_created) {
+ /* If we need to keep a reference, blk_attach_dev() took it */
+ blk_unref(blk);
+ }
}
static void release_drive(Object *obj, const char *name, void *opaque)
BlockBackend **ptr = qdev_get_prop_ptr(dev, prop);
if (*ptr) {
- blk_detach_dev(*ptr, dev);
+ AioContext *ctx = blk_get_aio_context(*ptr);
+
+ aio_context_acquire(ctx);
blockdev_auto_del(*ptr);
+ blk_detach_dev(*ptr, dev);
+ aio_context_release(ctx);
}
}
static char *print_drive(void *ptr)
{
- return g_strdup(blk_name(ptr));
+ const char *name;
+
+ name = blk_name(ptr);
+ if (!*name) {
+ BlockDriverState *bs = blk_bs(ptr);
+ if (bs) {
+ name = bdrv_get_node_name(bs);
+ }
+ }
+ return g_strdup(name);
}
-static void get_drive(Object *obj, Visitor *v, void *opaque,
- const char *name, Error **errp)
+static void get_drive(Object *obj, Visitor *v, const char *name, void *opaque,
+ 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)
+static void set_drive(Object *obj, Visitor *v, const char *name, void *opaque,
+ 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",
+ .description = "Node name or ID of a block device to use as a backend",
.get = get_drive,
.set = set_drive,
.release = release_drive,
/* --- character device --- */
-static void parse_chr(DeviceState *dev, const char *str, void **ptr,
- const char *propname, Error **errp)
+static void get_chr(Object *obj, Visitor *v, const char *name, void *opaque,
+ Error **errp)
{
- CharDriverState *chr = qemu_chr_find(str);
- if (chr == NULL) {
- error_setg(errp, "Property '%s.%s' can't find value '%s'",
- object_get_typename(OBJECT(dev)), propname, str);
- return;
- }
- if (qemu_chr_fe_claim(chr) != 0) {
- error_setg(errp, "Property '%s.%s' can't take value '%s', it's in use",
- object_get_typename(OBJECT(dev)), propname, str);
- return;
- }
- *ptr = chr;
+ DeviceState *dev = DEVICE(obj);
+ CharBackend *be = qdev_get_prop_ptr(dev, opaque);
+ char *p;
+
+ p = g_strdup(be->chr && be->chr->label ? be->chr->label : "");
+ visit_type_str(v, name, &p, errp);
+ g_free(p);
}
-static void release_chr(Object *obj, const char *name, void *opaque)
+static void set_chr(Object *obj, Visitor *v, const char *name, void *opaque,
+ Error **errp)
{
DeviceState *dev = DEVICE(obj);
+ Error *local_err = NULL;
Property *prop = opaque;
- CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);
- CharDriverState *chr = *ptr;
+ CharBackend *be = qdev_get_prop_ptr(dev, prop);
+ Chardev *s;
+ char *str;
- if (chr) {
- qemu_chr_add_handlers(chr, NULL, NULL, NULL, NULL);
- qemu_chr_fe_release(chr);
+ if (dev->realized) {
+ qdev_prop_set_after_realize(dev, name, errp);
+ return;
}
-}
+ visit_type_str(v, name, &str, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return;
+ }
-static char *print_chr(void *ptr)
-{
- CharDriverState *chr = ptr;
- const char *val = chr->label ? chr->label : "";
+ if (!*str) {
+ g_free(str);
+ be->chr = NULL;
+ return;
+ }
- return g_strdup(val);
+ s = qemu_chr_find(str);
+ if (s == NULL) {
+ error_setg(errp, "Property '%s.%s' can't find value '%s'",
+ object_get_typename(obj), prop->name, str);
+ } else if (!qemu_chr_fe_init(be, s, errp)) {
+ error_prepend(errp, "Property '%s.%s' can't take value '%s': ",
+ object_get_typename(obj), prop->name, str);
+ }
+ g_free(str);
}
-static void get_chr(Object *obj, Visitor *v, void *opaque,
- const char *name, Error **errp)
+static void release_chr(Object *obj, const char *name, void *opaque)
{
- get_pointer(obj, v, opaque, print_chr, name, errp);
-}
+ DeviceState *dev = DEVICE(obj);
+ Property *prop = opaque;
+ CharBackend *be = qdev_get_prop_ptr(dev, prop);
-static void set_chr(Object *obj, Visitor *v, void *opaque,
- const char *name, Error **errp)
-{
- set_pointer(obj, v, opaque, parse_chr, name, errp);
+ qemu_chr_fe_deinit(be);
}
PropertyInfo qdev_prop_chr = {
};
/* --- netdev device --- */
-static void get_netdev(Object *obj, Visitor *v, void *opaque,
- const char *name, Error **errp)
+static void get_netdev(Object *obj, Visitor *v, const char *name,
+ void *opaque, 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);
+ visit_type_str(v, name, &p, errp);
g_free(p);
}
-static void set_netdev(Object *obj, Visitor *v, void *opaque,
- const char *name, Error **errp)
+static void set_netdev(Object *obj, Visitor *v, const char *name,
+ void *opaque, Error **errp)
{
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
return;
}
- visit_type_str(v, &str, name, &local_err);
+ visit_type_str(v, name, &str, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return;
}
queues = qemu_find_net_clients_except(str, peers,
- NET_CLIENT_OPTIONS_KIND_NIC,
+ NET_CLIENT_DRIVER_NIC,
MAX_QUEUE_NUM);
if (queues == 0) {
err = -ENOENT;
return snprintf(dest, len, "<null>");
}
-static void get_vlan(Object *obj, Visitor *v, void *opaque,
- const char *name, Error **errp)
+static void get_vlan(Object *obj, Visitor *v, const char *name, void *opaque,
+ Error **errp)
{
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
}
}
- visit_type_int32(v, &id, name, errp);
+ visit_type_int32(v, name, &id, errp);
}
-static void set_vlan(Object *obj, Visitor *v, void *opaque,
- const char *name, Error **errp)
+static void set_vlan(Object *obj, Visitor *v, const char *name, void *opaque,
+ Error **errp)
{
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
return;
}
- visit_type_int32(v, &id, name, &local_err);
+ visit_type_int32(v, name, &id, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return;
void qdev_prop_set_drive(DeviceState *dev, const char *name,
BlockBackend *value, Error **errp)
{
- object_property_set_str(OBJECT(dev), value ? blk_name(value) : "",
- name, errp);
+ const char *ref = "";
+
+ if (value) {
+ ref = blk_name(value);
+ if (!*ref) {
+ const BlockDriverState *bs = blk_bs(value);
+ if (bs) {
+ ref = bdrv_get_node_name(bs);
+ }
+ }
+ }
+
+ object_property_set_str(OBJECT(dev), ref, name, errp);
}
void qdev_prop_set_chr(DeviceState *dev, const char *name,
- CharDriverState *value)
+ Chardev *value)
{
assert(!value || value->label);
object_property_set_str(OBJECT(dev),
}
nd->instantiated = 1;
}
-
-static int qdev_add_one_global(void *opaque, QemuOpts *opts, Error **errp)
-{
- 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, NULL);
-}
projects / qemu.git / blobdiff