1 /* 2 * qdev property parsing 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 13 #include "qemu/osdep.h" 14 #include "net/net.h" 15 #include "hw/qdev.h" 16 #include "qapi/error.h" 17 #include "qapi/qmp/qerror.h" 18 #include "sysemu/block-backend.h" 19 #include "sysemu/blockdev.h" 20 #include "hw/block/block.h" 21 #include "net/hub.h" 22 #include "qapi/visitor.h" 23 #include "sysemu/char.h" 24 #include "sysemu/iothread.h" 25 26 static void get_pointer(Object *obj, Visitor *v, Property *prop, 27 char *(*print)(void *ptr), 28 const char *name, Error **errp) 29 { 30 DeviceState *dev = DEVICE(obj); 31 void **ptr = qdev_get_prop_ptr(dev, prop); 32 char *p; 33 34 p = *ptr ? print(*ptr) : g_strdup(""); 35 visit_type_str(v, name, &p, errp); 36 g_free(p); 37 } 38 39 static void set_pointer(Object *obj, Visitor *v, Property *prop, 40 void (*parse)(DeviceState *dev, const char *str, 41 void **ptr, const char *propname, 42 Error **errp), 43 const char *name, Error **errp) 44 { 45 DeviceState *dev = DEVICE(obj); 46 Error *local_err = NULL; 47 void **ptr = qdev_get_prop_ptr(dev, prop); 48 char *str; 49 50 if (dev->realized) { 51 qdev_prop_set_after_realize(dev, name, errp); 52 return; 53 } 54 55 visit_type_str(v, name, &str, &local_err); 56 if (local_err) { 57 error_propagate(errp, local_err); 58 return; 59 } 60 if (!*str) { 61 g_free(str); 62 *ptr = NULL; 63 return; 64 } 65 parse(dev, str, ptr, prop->name, errp); 66 g_free(str); 67 } 68 69 /* --- drive --- */ 70 71 static void parse_drive(DeviceState *dev, const char *str, void **ptr, 72 const char *propname, Error **errp) 73 { 74 BlockBackend *blk; 75 bool blk_created = false; 76 int ret; 77 78 blk = blk_by_name(str); 79 if (!blk) { 80 BlockDriverState *bs = bdrv_lookup_bs(NULL, str, NULL); 81 if (bs) { 82 blk = blk_new(0, BLK_PERM_ALL); 83 blk_created = true; 84 85 ret = blk_insert_bs(blk, bs, errp); 86 if (ret < 0) { 87 goto fail; 88 } 89 } 90 } 91 if (!blk) { 92 error_setg(errp, "Property '%s.%s' can't find value '%s'", 93 object_get_typename(OBJECT(dev)), propname, str); 94 goto fail; 95 } 96 if (blk_attach_dev(blk, dev) < 0) { 97 DriveInfo *dinfo = blk_legacy_dinfo(blk); 98 99 if (dinfo && dinfo->type != IF_NONE) { 100 error_setg(errp, "Drive '%s' is already in use because " 101 "it has been automatically connected to another " 102 "device (did you need 'if=none' in the drive options?)", 103 str); 104 } else { 105 error_setg(errp, "Drive '%s' is already in use by another device", 106 str); 107 } 108 goto fail; 109 } 110 111 *ptr = blk; 112 113 fail: 114 if (blk_created) { 115 /* If we need to keep a reference, blk_attach_dev() took it */ 116 blk_unref(blk); 117 } 118 } 119 120 static void release_drive(Object *obj, const char *name, void *opaque) 121 { 122 DeviceState *dev = DEVICE(obj); 123 Property *prop = opaque; 124 BlockBackend **ptr = qdev_get_prop_ptr(dev, prop); 125 126 if (*ptr) { 127 blockdev_auto_del(*ptr); 128 blk_detach_dev(*ptr, dev); 129 } 130 } 131 132 static char *print_drive(void *ptr) 133 { 134 const char *name; 135 136 name = blk_name(ptr); 137 if (!*name) { 138 BlockDriverState *bs = blk_bs(ptr); 139 if (bs) { 140 name = bdrv_get_node_name(bs); 141 } 142 } 143 return g_strdup(name); 144 } 145 146 static void get_drive(Object *obj, Visitor *v, const char *name, void *opaque, 147 Error **errp) 148 { 149 get_pointer(obj, v, opaque, print_drive, name, errp); 150 } 151 152 static void set_drive(Object *obj, Visitor *v, const char *name, void *opaque, 153 Error **errp) 154 { 155 set_pointer(obj, v, opaque, parse_drive, name, errp); 156 } 157 158 PropertyInfo qdev_prop_drive = { 159 .name = "str", 160 .description = "Node name or ID of a block device to use as a backend", 161 .get = get_drive, 162 .set = set_drive, 163 .release = release_drive, 164 }; 165 166 /* --- character device --- */ 167 168 static void get_chr(Object *obj, Visitor *v, const char *name, void *opaque, 169 Error **errp) 170 { 171 DeviceState *dev = DEVICE(obj); 172 CharBackend *be = qdev_get_prop_ptr(dev, opaque); 173 char *p; 174 175 p = g_strdup(be->chr && be->chr->label ? be->chr->label : ""); 176 visit_type_str(v, name, &p, errp); 177 g_free(p); 178 } 179 180 static void set_chr(Object *obj, Visitor *v, const char *name, void *opaque, 181 Error **errp) 182 { 183 DeviceState *dev = DEVICE(obj); 184 Error *local_err = NULL; 185 Property *prop = opaque; 186 CharBackend *be = qdev_get_prop_ptr(dev, prop); 187 Chardev *s; 188 char *str; 189 190 if (dev->realized) { 191 qdev_prop_set_after_realize(dev, name, errp); 192 return; 193 } 194 195 visit_type_str(v, name, &str, &local_err); 196 if (local_err) { 197 error_propagate(errp, local_err); 198 return; 199 } 200 201 if (!*str) { 202 g_free(str); 203 be->chr = NULL; 204 return; 205 } 206 207 s = qemu_chr_find(str); 208 if (s == NULL) { 209 error_setg(errp, "Property '%s.%s' can't find value '%s'", 210 object_get_typename(obj), prop->name, str); 211 } else if (!qemu_chr_fe_init(be, s, errp)) { 212 error_prepend(errp, "Property '%s.%s' can't take value '%s': ", 213 object_get_typename(obj), prop->name, str); 214 } 215 g_free(str); 216 } 217 218 static void release_chr(Object *obj, const char *name, void *opaque) 219 { 220 DeviceState *dev = DEVICE(obj); 221 Property *prop = opaque; 222 CharBackend *be = qdev_get_prop_ptr(dev, prop); 223 224 qemu_chr_fe_deinit(be); 225 } 226 227 PropertyInfo qdev_prop_chr = { 228 .name = "str", 229 .description = "ID of a chardev to use as a backend", 230 .get = get_chr, 231 .set = set_chr, 232 .release = release_chr, 233 }; 234 235 /* --- netdev device --- */ 236 static void get_netdev(Object *obj, Visitor *v, const char *name, 237 void *opaque, Error **errp) 238 { 239 DeviceState *dev = DEVICE(obj); 240 Property *prop = opaque; 241 NICPeers *peers_ptr = qdev_get_prop_ptr(dev, prop); 242 char *p = g_strdup(peers_ptr->ncs[0] ? peers_ptr->ncs[0]->name : ""); 243 244 visit_type_str(v, name, &p, errp); 245 g_free(p); 246 } 247 248 static void set_netdev(Object *obj, Visitor *v, const char *name, 249 void *opaque, Error **errp) 250 { 251 DeviceState *dev = DEVICE(obj); 252 Property *prop = opaque; 253 NICPeers *peers_ptr = qdev_get_prop_ptr(dev, prop); 254 NetClientState **ncs = peers_ptr->ncs; 255 NetClientState *peers[MAX_QUEUE_NUM]; 256 Error *local_err = NULL; 257 int queues, err = 0, i = 0; 258 char *str; 259 260 if (dev->realized) { 261 qdev_prop_set_after_realize(dev, name, errp); 262 return; 263 } 264 265 visit_type_str(v, name, &str, &local_err); 266 if (local_err) { 267 error_propagate(errp, local_err); 268 return; 269 } 270 271 queues = qemu_find_net_clients_except(str, peers, 272 NET_CLIENT_DRIVER_NIC, 273 MAX_QUEUE_NUM); 274 if (queues == 0) { 275 err = -ENOENT; 276 goto out; 277 } 278 279 if (queues > MAX_QUEUE_NUM) { 280 error_setg(errp, "queues of backend '%s'(%d) exceeds QEMU limitation(%d)", 281 str, queues, MAX_QUEUE_NUM); 282 goto out; 283 } 284 285 for (i = 0; i < queues; i++) { 286 if (peers[i] == NULL) { 287 err = -ENOENT; 288 goto out; 289 } 290 291 if (peers[i]->peer) { 292 err = -EEXIST; 293 goto out; 294 } 295 296 if (ncs[i]) { 297 err = -EINVAL; 298 goto out; 299 } 300 301 ncs[i] = peers[i]; 302 ncs[i]->queue_index = i; 303 } 304 305 peers_ptr->queues = queues; 306 307 out: 308 error_set_from_qdev_prop_error(errp, err, dev, prop, str); 309 g_free(str); 310 } 311 312 PropertyInfo qdev_prop_netdev = { 313 .name = "str", 314 .description = "ID of a netdev to use as a backend", 315 .get = get_netdev, 316 .set = set_netdev, 317 }; 318 319 /* --- vlan --- */ 320 321 static int print_vlan(DeviceState *dev, Property *prop, char *dest, size_t len) 322 { 323 NetClientState **ptr = qdev_get_prop_ptr(dev, prop); 324 325 if (*ptr) { 326 int id; 327 if (!net_hub_id_for_client(*ptr, &id)) { 328 return snprintf(dest, len, "%d", id); 329 } 330 } 331 332 return snprintf(dest, len, "<null>"); 333 } 334 335 static void get_vlan(Object *obj, Visitor *v, const char *name, void *opaque, 336 Error **errp) 337 { 338 DeviceState *dev = DEVICE(obj); 339 Property *prop = opaque; 340 NetClientState **ptr = qdev_get_prop_ptr(dev, prop); 341 int32_t id = -1; 342 343 if (*ptr) { 344 int hub_id; 345 if (!net_hub_id_for_client(*ptr, &hub_id)) { 346 id = hub_id; 347 } 348 } 349 350 visit_type_int32(v, name, &id, errp); 351 } 352 353 static void set_vlan(Object *obj, Visitor *v, const char *name, void *opaque, 354 Error **errp) 355 { 356 DeviceState *dev = DEVICE(obj); 357 Property *prop = opaque; 358 NICPeers *peers_ptr = qdev_get_prop_ptr(dev, prop); 359 NetClientState **ptr = &peers_ptr->ncs[0]; 360 Error *local_err = NULL; 361 int32_t id; 362 NetClientState *hubport; 363 364 if (dev->realized) { 365 qdev_prop_set_after_realize(dev, name, errp); 366 return; 367 } 368 369 visit_type_int32(v, name, &id, &local_err); 370 if (local_err) { 371 error_propagate(errp, local_err); 372 return; 373 } 374 if (id == -1) { 375 *ptr = NULL; 376 return; 377 } 378 if (*ptr) { 379 error_set_from_qdev_prop_error(errp, -EINVAL, dev, prop, name); 380 return; 381 } 382 383 hubport = net_hub_port_find(id); 384 if (!hubport) { 385 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 386 name, prop->info->name); 387 return; 388 } 389 *ptr = hubport; 390 } 391 392 PropertyInfo qdev_prop_vlan = { 393 .name = "int32", 394 .description = "Integer VLAN id to connect to", 395 .print = print_vlan, 396 .get = get_vlan, 397 .set = set_vlan, 398 }; 399 400 void qdev_prop_set_drive(DeviceState *dev, const char *name, 401 BlockBackend *value, Error **errp) 402 { 403 const char *ref = ""; 404 405 if (value) { 406 ref = blk_name(value); 407 if (!*ref) { 408 BlockDriverState *bs = blk_bs(value); 409 if (bs) { 410 ref = bdrv_get_node_name(bs); 411 } 412 } 413 } 414 415 object_property_set_str(OBJECT(dev), ref, name, errp); 416 } 417 418 void qdev_prop_set_chr(DeviceState *dev, const char *name, 419 Chardev *value) 420 { 421 assert(!value || value->label); 422 object_property_set_str(OBJECT(dev), 423 value ? value->label : "", name, &error_abort); 424 } 425 426 void qdev_prop_set_netdev(DeviceState *dev, const char *name, 427 NetClientState *value) 428 { 429 assert(!value || value->name); 430 object_property_set_str(OBJECT(dev), 431 value ? value->name : "", name, &error_abort); 432 } 433 434 void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd) 435 { 436 qdev_prop_set_macaddr(dev, "mac", nd->macaddr.a); 437 if (nd->netdev) { 438 qdev_prop_set_netdev(dev, "netdev", nd->netdev); 439 } 440 if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED && 441 object_property_find(OBJECT(dev), "vectors", NULL)) { 442 qdev_prop_set_uint32(dev, "vectors", nd->nvectors); 443 } 444 nd->instantiated = 1; 445 } 446