1 /* 2 * QEMU Object Model 3 * 4 * Copyright IBM, Corp. 2011 5 * 6 * Authors: 7 * Anthony Liguori <aliguori@us.ibm.com> 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 "qapi/error.h" 15 #include "qom/object.h" 16 #include "qom/object_interfaces.h" 17 #include "qemu/cutils.h" 18 #include "qapi/visitor.h" 19 #include "qapi/string-input-visitor.h" 20 #include "qapi/string-output-visitor.h" 21 #include "qapi/qapi-builtin-visit.h" 22 #include "qapi/qmp/qerror.h" 23 #include "trace.h" 24 25 /* TODO: replace QObject with a simpler visitor to avoid a dependency 26 * of the QOM core on QObject? */ 27 #include "qom/qom-qobject.h" 28 #include "qapi/qmp/qbool.h" 29 #include "qapi/qmp/qnum.h" 30 #include "qapi/qmp/qstring.h" 31 #include "qemu/error-report.h" 32 33 #define MAX_INTERFACES 32 34 35 typedef struct InterfaceImpl InterfaceImpl; 36 typedef struct TypeImpl TypeImpl; 37 38 struct InterfaceImpl 39 { 40 const char *typename; 41 }; 42 43 struct TypeImpl 44 { 45 const char *name; 46 47 size_t class_size; 48 49 size_t instance_size; 50 51 void (*class_init)(ObjectClass *klass, void *data); 52 void (*class_base_init)(ObjectClass *klass, void *data); 53 54 void *class_data; 55 56 void (*instance_init)(Object *obj); 57 void (*instance_post_init)(Object *obj); 58 void (*instance_finalize)(Object *obj); 59 60 bool abstract; 61 62 const char *parent; 63 TypeImpl *parent_type; 64 65 ObjectClass *class; 66 67 int num_interfaces; 68 InterfaceImpl interfaces[MAX_INTERFACES]; 69 }; 70 71 static Type type_interface; 72 73 static GHashTable *type_table_get(void) 74 { 75 static GHashTable *type_table; 76 77 if (type_table == NULL) { 78 type_table = g_hash_table_new(g_str_hash, g_str_equal); 79 } 80 81 return type_table; 82 } 83 84 static bool enumerating_types; 85 86 static void type_table_add(TypeImpl *ti) 87 { 88 assert(!enumerating_types); 89 g_hash_table_insert(type_table_get(), (void *)ti->name, ti); 90 } 91 92 static TypeImpl *type_table_lookup(const char *name) 93 { 94 return g_hash_table_lookup(type_table_get(), name); 95 } 96 97 static TypeImpl *type_new(const TypeInfo *info) 98 { 99 TypeImpl *ti = g_malloc0(sizeof(*ti)); 100 int i; 101 102 g_assert(info->name != NULL); 103 104 if (type_table_lookup(info->name) != NULL) { 105 fprintf(stderr, "Registering `%s' which already exists\n", info->name); 106 abort(); 107 } 108 109 ti->name = g_strdup(info->name); 110 ti->parent = g_strdup(info->parent); 111 112 ti->class_size = info->class_size; 113 ti->instance_size = info->instance_size; 114 115 ti->class_init = info->class_init; 116 ti->class_base_init = info->class_base_init; 117 ti->class_data = info->class_data; 118 119 ti->instance_init = info->instance_init; 120 ti->instance_post_init = info->instance_post_init; 121 ti->instance_finalize = info->instance_finalize; 122 123 ti->abstract = info->abstract; 124 125 for (i = 0; info->interfaces && info->interfaces[i].type; i++) { 126 ti->interfaces[i].typename = g_strdup(info->interfaces[i].type); 127 } 128 ti->num_interfaces = i; 129 130 return ti; 131 } 132 133 static TypeImpl *type_register_internal(const TypeInfo *info) 134 { 135 TypeImpl *ti; 136 ti = type_new(info); 137 138 type_table_add(ti); 139 return ti; 140 } 141 142 TypeImpl *type_register(const TypeInfo *info) 143 { 144 assert(info->parent); 145 return type_register_internal(info); 146 } 147 148 TypeImpl *type_register_static(const TypeInfo *info) 149 { 150 return type_register(info); 151 } 152 153 void type_register_static_array(const TypeInfo *infos, int nr_infos) 154 { 155 int i; 156 157 for (i = 0; i < nr_infos; i++) { 158 type_register_static(&infos[i]); 159 } 160 } 161 162 static TypeImpl *type_get_by_name(const char *name) 163 { 164 if (name == NULL) { 165 return NULL; 166 } 167 168 return type_table_lookup(name); 169 } 170 171 static TypeImpl *type_get_parent(TypeImpl *type) 172 { 173 if (!type->parent_type && type->parent) { 174 type->parent_type = type_get_by_name(type->parent); 175 g_assert(type->parent_type != NULL); 176 } 177 178 return type->parent_type; 179 } 180 181 static bool type_has_parent(TypeImpl *type) 182 { 183 return (type->parent != NULL); 184 } 185 186 static size_t type_class_get_size(TypeImpl *ti) 187 { 188 if (ti->class_size) { 189 return ti->class_size; 190 } 191 192 if (type_has_parent(ti)) { 193 return type_class_get_size(type_get_parent(ti)); 194 } 195 196 return sizeof(ObjectClass); 197 } 198 199 static size_t type_object_get_size(TypeImpl *ti) 200 { 201 if (ti->instance_size) { 202 return ti->instance_size; 203 } 204 205 if (type_has_parent(ti)) { 206 return type_object_get_size(type_get_parent(ti)); 207 } 208 209 return 0; 210 } 211 212 size_t object_type_get_instance_size(const char *typename) 213 { 214 TypeImpl *type = type_get_by_name(typename); 215 216 g_assert(type != NULL); 217 return type_object_get_size(type); 218 } 219 220 static bool type_is_ancestor(TypeImpl *type, TypeImpl *target_type) 221 { 222 assert(target_type); 223 224 /* Check if target_type is a direct ancestor of type */ 225 while (type) { 226 if (type == target_type) { 227 return true; 228 } 229 230 type = type_get_parent(type); 231 } 232 233 return false; 234 } 235 236 static void type_initialize(TypeImpl *ti); 237 238 static void type_initialize_interface(TypeImpl *ti, TypeImpl *interface_type, 239 TypeImpl *parent_type) 240 { 241 InterfaceClass *new_iface; 242 TypeInfo info = { }; 243 TypeImpl *iface_impl; 244 245 info.parent = parent_type->name; 246 info.name = g_strdup_printf("%s::%s", ti->name, interface_type->name); 247 info.abstract = true; 248 249 iface_impl = type_new(&info); 250 iface_impl->parent_type = parent_type; 251 type_initialize(iface_impl); 252 g_free((char *)info.name); 253 254 new_iface = (InterfaceClass *)iface_impl->class; 255 new_iface->concrete_class = ti->class; 256 new_iface->interface_type = interface_type; 257 258 ti->class->interfaces = g_slist_append(ti->class->interfaces, 259 iface_impl->class); 260 } 261 262 static void object_property_free(gpointer data) 263 { 264 ObjectProperty *prop = data; 265 266 g_free(prop->name); 267 g_free(prop->type); 268 g_free(prop->description); 269 g_free(prop); 270 } 271 272 static void type_initialize(TypeImpl *ti) 273 { 274 TypeImpl *parent; 275 276 if (ti->class) { 277 return; 278 } 279 280 ti->class_size = type_class_get_size(ti); 281 ti->instance_size = type_object_get_size(ti); 282 /* Any type with zero instance_size is implicitly abstract. 283 * This means interface types are all abstract. 284 */ 285 if (ti->instance_size == 0) { 286 ti->abstract = true; 287 } 288 if (type_is_ancestor(ti, type_interface)) { 289 assert(ti->instance_size == 0); 290 assert(ti->abstract); 291 assert(!ti->instance_init); 292 assert(!ti->instance_post_init); 293 assert(!ti->instance_finalize); 294 assert(!ti->num_interfaces); 295 } 296 ti->class = g_malloc0(ti->class_size); 297 298 parent = type_get_parent(ti); 299 if (parent) { 300 type_initialize(parent); 301 GSList *e; 302 int i; 303 304 g_assert(parent->class_size <= ti->class_size); 305 memcpy(ti->class, parent->class, parent->class_size); 306 ti->class->interfaces = NULL; 307 ti->class->properties = g_hash_table_new_full( 308 g_str_hash, g_str_equal, g_free, object_property_free); 309 310 for (e = parent->class->interfaces; e; e = e->next) { 311 InterfaceClass *iface = e->data; 312 ObjectClass *klass = OBJECT_CLASS(iface); 313 314 type_initialize_interface(ti, iface->interface_type, klass->type); 315 } 316 317 for (i = 0; i < ti->num_interfaces; i++) { 318 TypeImpl *t = type_get_by_name(ti->interfaces[i].typename); 319 for (e = ti->class->interfaces; e; e = e->next) { 320 TypeImpl *target_type = OBJECT_CLASS(e->data)->type; 321 322 if (type_is_ancestor(target_type, t)) { 323 break; 324 } 325 } 326 327 if (e) { 328 continue; 329 } 330 331 type_initialize_interface(ti, t, t); 332 } 333 } else { 334 ti->class->properties = g_hash_table_new_full( 335 g_str_hash, g_str_equal, g_free, object_property_free); 336 } 337 338 ti->class->type = ti; 339 340 while (parent) { 341 if (parent->class_base_init) { 342 parent->class_base_init(ti->class, ti->class_data); 343 } 344 parent = type_get_parent(parent); 345 } 346 347 if (ti->class_init) { 348 ti->class_init(ti->class, ti->class_data); 349 } 350 } 351 352 static void object_init_with_type(Object *obj, TypeImpl *ti) 353 { 354 if (type_has_parent(ti)) { 355 object_init_with_type(obj, type_get_parent(ti)); 356 } 357 358 if (ti->instance_init) { 359 ti->instance_init(obj); 360 } 361 } 362 363 static void object_post_init_with_type(Object *obj, TypeImpl *ti) 364 { 365 if (ti->instance_post_init) { 366 ti->instance_post_init(obj); 367 } 368 369 if (type_has_parent(ti)) { 370 object_post_init_with_type(obj, type_get_parent(ti)); 371 } 372 } 373 374 void object_apply_global_props(Object *obj, const GPtrArray *props, Error **errp) 375 { 376 int i; 377 378 if (!props) { 379 return; 380 } 381 382 for (i = 0; i < props->len; i++) { 383 GlobalProperty *p = g_ptr_array_index(props, i); 384 Error *err = NULL; 385 386 if (object_dynamic_cast(obj, p->driver) == NULL) { 387 continue; 388 } 389 if (p->optional && !object_property_find(obj, p->property, NULL)) { 390 continue; 391 } 392 p->used = true; 393 object_property_parse(obj, p->value, p->property, &err); 394 if (err != NULL) { 395 error_prepend(&err, "can't apply global %s.%s=%s: ", 396 p->driver, p->property, p->value); 397 /* 398 * If errp != NULL, propagate error and return. 399 * If errp == NULL, report a warning, but keep going 400 * with the remaining globals. 401 */ 402 if (errp) { 403 error_propagate(errp, err); 404 return; 405 } else { 406 warn_report_err(err); 407 } 408 } 409 } 410 } 411 412 /* 413 * Global property defaults 414 * Slot 0: accelerator's global property defaults 415 * Slot 1: machine's global property defaults 416 * Each is a GPtrArray of of GlobalProperty. 417 * Applied in order, later entries override earlier ones. 418 */ 419 static GPtrArray *object_compat_props[2]; 420 421 /* 422 * Set machine's global property defaults to @compat_props. 423 * May be called at most once. 424 */ 425 void object_set_machine_compat_props(GPtrArray *compat_props) 426 { 427 assert(!object_compat_props[1]); 428 object_compat_props[1] = compat_props; 429 } 430 431 /* 432 * Set accelerator's global property defaults to @compat_props. 433 * May be called at most once. 434 */ 435 void object_set_accelerator_compat_props(GPtrArray *compat_props) 436 { 437 assert(!object_compat_props[0]); 438 object_compat_props[0] = compat_props; 439 } 440 441 void object_apply_compat_props(Object *obj) 442 { 443 int i; 444 445 for (i = 0; i < ARRAY_SIZE(object_compat_props); i++) { 446 object_apply_global_props(obj, object_compat_props[i], 447 &error_abort); 448 } 449 } 450 451 static void object_initialize_with_type(void *data, size_t size, TypeImpl *type) 452 { 453 Object *obj = data; 454 455 type_initialize(type); 456 457 g_assert(type->instance_size >= sizeof(Object)); 458 g_assert(type->abstract == false); 459 g_assert(size >= type->instance_size); 460 461 memset(obj, 0, type->instance_size); 462 obj->class = type->class; 463 object_ref(obj); 464 obj->properties = g_hash_table_new_full(g_str_hash, g_str_equal, 465 NULL, object_property_free); 466 object_init_with_type(obj, type); 467 object_post_init_with_type(obj, type); 468 } 469 470 void object_initialize(void *data, size_t size, const char *typename) 471 { 472 TypeImpl *type = type_get_by_name(typename); 473 474 if (!type) { 475 error_report("missing object type '%s'", typename); 476 abort(); 477 } 478 479 object_initialize_with_type(data, size, type); 480 } 481 482 void object_initialize_child(Object *parentobj, const char *propname, 483 void *childobj, size_t size, const char *type, 484 Error **errp, ...) 485 { 486 va_list vargs; 487 488 va_start(vargs, errp); 489 object_initialize_childv(parentobj, propname, childobj, size, type, errp, 490 vargs); 491 va_end(vargs); 492 } 493 494 void object_initialize_childv(Object *parentobj, const char *propname, 495 void *childobj, size_t size, const char *type, 496 Error **errp, va_list vargs) 497 { 498 Error *local_err = NULL; 499 Object *obj; 500 UserCreatable *uc; 501 502 object_initialize(childobj, size, type); 503 obj = OBJECT(childobj); 504 505 object_set_propv(obj, &local_err, vargs); 506 if (local_err) { 507 goto out; 508 } 509 510 object_property_add_child(parentobj, propname, obj, &local_err); 511 if (local_err) { 512 goto out; 513 } 514 515 uc = (UserCreatable *)object_dynamic_cast(obj, TYPE_USER_CREATABLE); 516 if (uc) { 517 user_creatable_complete(uc, &local_err); 518 if (local_err) { 519 object_unparent(obj); 520 goto out; 521 } 522 } 523 524 /* 525 * Since object_property_add_child added a reference to the child object, 526 * we can drop the reference added by object_initialize(), so the child 527 * property will own the only reference to the object. 528 */ 529 object_unref(obj); 530 531 out: 532 if (local_err) { 533 error_propagate(errp, local_err); 534 object_unref(obj); 535 } 536 } 537 538 static inline bool object_property_is_child(ObjectProperty *prop) 539 { 540 return strstart(prop->type, "child<", NULL); 541 } 542 543 static void object_property_del_all(Object *obj) 544 { 545 ObjectProperty *prop; 546 GHashTableIter iter; 547 gpointer key, value; 548 bool released; 549 550 do { 551 released = false; 552 g_hash_table_iter_init(&iter, obj->properties); 553 while (g_hash_table_iter_next(&iter, &key, &value)) { 554 prop = value; 555 if (prop->release) { 556 prop->release(obj, prop->name, prop->opaque); 557 prop->release = NULL; 558 released = true; 559 break; 560 } 561 g_hash_table_iter_remove(&iter); 562 } 563 } while (released); 564 565 g_hash_table_unref(obj->properties); 566 } 567 568 static void object_property_del_child(Object *obj, Object *child, Error **errp) 569 { 570 ObjectProperty *prop; 571 GHashTableIter iter; 572 gpointer key, value; 573 574 g_hash_table_iter_init(&iter, obj->properties); 575 while (g_hash_table_iter_next(&iter, &key, &value)) { 576 prop = value; 577 if (object_property_is_child(prop) && prop->opaque == child) { 578 if (prop->release) { 579 prop->release(obj, prop->name, prop->opaque); 580 prop->release = NULL; 581 } 582 break; 583 } 584 } 585 g_hash_table_iter_init(&iter, obj->properties); 586 while (g_hash_table_iter_next(&iter, &key, &value)) { 587 prop = value; 588 if (object_property_is_child(prop) && prop->opaque == child) { 589 g_hash_table_iter_remove(&iter); 590 break; 591 } 592 } 593 } 594 595 void object_unparent(Object *obj) 596 { 597 if (obj->parent) { 598 object_property_del_child(obj->parent, obj, NULL); 599 } 600 } 601 602 static void object_deinit(Object *obj, TypeImpl *type) 603 { 604 if (type->instance_finalize) { 605 type->instance_finalize(obj); 606 } 607 608 if (type_has_parent(type)) { 609 object_deinit(obj, type_get_parent(type)); 610 } 611 } 612 613 static void object_finalize(void *data) 614 { 615 Object *obj = data; 616 TypeImpl *ti = obj->class->type; 617 618 object_property_del_all(obj); 619 object_deinit(obj, ti); 620 621 g_assert(obj->ref == 0); 622 if (obj->free) { 623 obj->free(obj); 624 } 625 } 626 627 static Object *object_new_with_type(Type type) 628 { 629 Object *obj; 630 631 g_assert(type != NULL); 632 type_initialize(type); 633 634 obj = g_malloc(type->instance_size); 635 object_initialize_with_type(obj, type->instance_size, type); 636 obj->free = g_free; 637 638 return obj; 639 } 640 641 Object *object_new(const char *typename) 642 { 643 TypeImpl *ti = type_get_by_name(typename); 644 645 return object_new_with_type(ti); 646 } 647 648 649 Object *object_new_with_props(const char *typename, 650 Object *parent, 651 const char *id, 652 Error **errp, 653 ...) 654 { 655 va_list vargs; 656 Object *obj; 657 658 va_start(vargs, errp); 659 obj = object_new_with_propv(typename, parent, id, errp, vargs); 660 va_end(vargs); 661 662 return obj; 663 } 664 665 666 Object *object_new_with_propv(const char *typename, 667 Object *parent, 668 const char *id, 669 Error **errp, 670 va_list vargs) 671 { 672 Object *obj; 673 ObjectClass *klass; 674 Error *local_err = NULL; 675 UserCreatable *uc; 676 677 klass = object_class_by_name(typename); 678 if (!klass) { 679 error_setg(errp, "invalid object type: %s", typename); 680 return NULL; 681 } 682 683 if (object_class_is_abstract(klass)) { 684 error_setg(errp, "object type '%s' is abstract", typename); 685 return NULL; 686 } 687 obj = object_new_with_type(klass->type); 688 689 if (object_set_propv(obj, &local_err, vargs) < 0) { 690 goto error; 691 } 692 693 if (id != NULL) { 694 object_property_add_child(parent, id, obj, &local_err); 695 if (local_err) { 696 goto error; 697 } 698 } 699 700 uc = (UserCreatable *)object_dynamic_cast(obj, TYPE_USER_CREATABLE); 701 if (uc) { 702 user_creatable_complete(uc, &local_err); 703 if (local_err) { 704 if (id != NULL) { 705 object_unparent(obj); 706 } 707 goto error; 708 } 709 } 710 711 object_unref(OBJECT(obj)); 712 return obj; 713 714 error: 715 error_propagate(errp, local_err); 716 object_unref(obj); 717 return NULL; 718 } 719 720 721 int object_set_props(Object *obj, 722 Error **errp, 723 ...) 724 { 725 va_list vargs; 726 int ret; 727 728 va_start(vargs, errp); 729 ret = object_set_propv(obj, errp, vargs); 730 va_end(vargs); 731 732 return ret; 733 } 734 735 736 int object_set_propv(Object *obj, 737 Error **errp, 738 va_list vargs) 739 { 740 const char *propname; 741 Error *local_err = NULL; 742 743 propname = va_arg(vargs, char *); 744 while (propname != NULL) { 745 const char *value = va_arg(vargs, char *); 746 747 g_assert(value != NULL); 748 object_property_parse(obj, value, propname, &local_err); 749 if (local_err) { 750 error_propagate(errp, local_err); 751 return -1; 752 } 753 propname = va_arg(vargs, char *); 754 } 755 756 return 0; 757 } 758 759 760 Object *object_dynamic_cast(Object *obj, const char *typename) 761 { 762 if (obj && object_class_dynamic_cast(object_get_class(obj), typename)) { 763 return obj; 764 } 765 766 return NULL; 767 } 768 769 Object *object_dynamic_cast_assert(Object *obj, const char *typename, 770 const char *file, int line, const char *func) 771 { 772 trace_object_dynamic_cast_assert(obj ? obj->class->type->name : "(null)", 773 typename, file, line, func); 774 775 #ifdef CONFIG_QOM_CAST_DEBUG 776 int i; 777 Object *inst; 778 779 for (i = 0; obj && i < OBJECT_CLASS_CAST_CACHE; i++) { 780 if (atomic_read(&obj->class->object_cast_cache[i]) == typename) { 781 goto out; 782 } 783 } 784 785 inst = object_dynamic_cast(obj, typename); 786 787 if (!inst && obj) { 788 fprintf(stderr, "%s:%d:%s: Object %p is not an instance of type %s\n", 789 file, line, func, obj, typename); 790 abort(); 791 } 792 793 assert(obj == inst); 794 795 if (obj && obj == inst) { 796 for (i = 1; i < OBJECT_CLASS_CAST_CACHE; i++) { 797 atomic_set(&obj->class->object_cast_cache[i - 1], 798 atomic_read(&obj->class->object_cast_cache[i])); 799 } 800 atomic_set(&obj->class->object_cast_cache[i - 1], typename); 801 } 802 803 out: 804 #endif 805 return obj; 806 } 807 808 ObjectClass *object_class_dynamic_cast(ObjectClass *class, 809 const char *typename) 810 { 811 ObjectClass *ret = NULL; 812 TypeImpl *target_type; 813 TypeImpl *type; 814 815 if (!class) { 816 return NULL; 817 } 818 819 /* A simple fast path that can trigger a lot for leaf classes. */ 820 type = class->type; 821 if (type->name == typename) { 822 return class; 823 } 824 825 target_type = type_get_by_name(typename); 826 if (!target_type) { 827 /* target class type unknown, so fail the cast */ 828 return NULL; 829 } 830 831 if (type->class->interfaces && 832 type_is_ancestor(target_type, type_interface)) { 833 int found = 0; 834 GSList *i; 835 836 for (i = class->interfaces; i; i = i->next) { 837 ObjectClass *target_class = i->data; 838 839 if (type_is_ancestor(target_class->type, target_type)) { 840 ret = target_class; 841 found++; 842 } 843 } 844 845 /* The match was ambiguous, don't allow a cast */ 846 if (found > 1) { 847 ret = NULL; 848 } 849 } else if (type_is_ancestor(type, target_type)) { 850 ret = class; 851 } 852 853 return ret; 854 } 855 856 ObjectClass *object_class_dynamic_cast_assert(ObjectClass *class, 857 const char *typename, 858 const char *file, int line, 859 const char *func) 860 { 861 ObjectClass *ret; 862 863 trace_object_class_dynamic_cast_assert(class ? class->type->name : "(null)", 864 typename, file, line, func); 865 866 #ifdef CONFIG_QOM_CAST_DEBUG 867 int i; 868 869 for (i = 0; class && i < OBJECT_CLASS_CAST_CACHE; i++) { 870 if (atomic_read(&class->class_cast_cache[i]) == typename) { 871 ret = class; 872 goto out; 873 } 874 } 875 #else 876 if (!class || !class->interfaces) { 877 return class; 878 } 879 #endif 880 881 ret = object_class_dynamic_cast(class, typename); 882 if (!ret && class) { 883 fprintf(stderr, "%s:%d:%s: Object %p is not an instance of type %s\n", 884 file, line, func, class, typename); 885 abort(); 886 } 887 888 #ifdef CONFIG_QOM_CAST_DEBUG 889 if (class && ret == class) { 890 for (i = 1; i < OBJECT_CLASS_CAST_CACHE; i++) { 891 atomic_set(&class->class_cast_cache[i - 1], 892 atomic_read(&class->class_cast_cache[i])); 893 } 894 atomic_set(&class->class_cast_cache[i - 1], typename); 895 } 896 out: 897 #endif 898 return ret; 899 } 900 901 const char *object_get_typename(const Object *obj) 902 { 903 return obj->class->type->name; 904 } 905 906 ObjectClass *object_get_class(Object *obj) 907 { 908 return obj->class; 909 } 910 911 bool object_class_is_abstract(ObjectClass *klass) 912 { 913 return klass->type->abstract; 914 } 915 916 const char *object_class_get_name(ObjectClass *klass) 917 { 918 return klass->type->name; 919 } 920 921 ObjectClass *object_class_by_name(const char *typename) 922 { 923 TypeImpl *type = type_get_by_name(typename); 924 925 if (!type) { 926 return NULL; 927 } 928 929 type_initialize(type); 930 931 return type->class; 932 } 933 934 ObjectClass *object_class_get_parent(ObjectClass *class) 935 { 936 TypeImpl *type = type_get_parent(class->type); 937 938 if (!type) { 939 return NULL; 940 } 941 942 type_initialize(type); 943 944 return type->class; 945 } 946 947 typedef struct OCFData 948 { 949 void (*fn)(ObjectClass *klass, void *opaque); 950 const char *implements_type; 951 bool include_abstract; 952 void *opaque; 953 } OCFData; 954 955 static void object_class_foreach_tramp(gpointer key, gpointer value, 956 gpointer opaque) 957 { 958 OCFData *data = opaque; 959 TypeImpl *type = value; 960 ObjectClass *k; 961 962 type_initialize(type); 963 k = type->class; 964 965 if (!data->include_abstract && type->abstract) { 966 return; 967 } 968 969 if (data->implements_type && 970 !object_class_dynamic_cast(k, data->implements_type)) { 971 return; 972 } 973 974 data->fn(k, data->opaque); 975 } 976 977 void object_class_foreach(void (*fn)(ObjectClass *klass, void *opaque), 978 const char *implements_type, bool include_abstract, 979 void *opaque) 980 { 981 OCFData data = { fn, implements_type, include_abstract, opaque }; 982 983 enumerating_types = true; 984 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp, &data); 985 enumerating_types = false; 986 } 987 988 static int do_object_child_foreach(Object *obj, 989 int (*fn)(Object *child, void *opaque), 990 void *opaque, bool recurse) 991 { 992 GHashTableIter iter; 993 ObjectProperty *prop; 994 int ret = 0; 995 996 g_hash_table_iter_init(&iter, obj->properties); 997 while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) { 998 if (object_property_is_child(prop)) { 999 Object *child = prop->opaque; 1000 1001 ret = fn(child, opaque); 1002 if (ret != 0) { 1003 break; 1004 } 1005 if (recurse) { 1006 do_object_child_foreach(child, fn, opaque, true); 1007 } 1008 } 1009 } 1010 return ret; 1011 } 1012 1013 int object_child_foreach(Object *obj, int (*fn)(Object *child, void *opaque), 1014 void *opaque) 1015 { 1016 return do_object_child_foreach(obj, fn, opaque, false); 1017 } 1018 1019 int object_child_foreach_recursive(Object *obj, 1020 int (*fn)(Object *child, void *opaque), 1021 void *opaque) 1022 { 1023 return do_object_child_foreach(obj, fn, opaque, true); 1024 } 1025 1026 static void object_class_get_list_tramp(ObjectClass *klass, void *opaque) 1027 { 1028 GSList **list = opaque; 1029 1030 *list = g_slist_prepend(*list, klass); 1031 } 1032 1033 GSList *object_class_get_list(const char *implements_type, 1034 bool include_abstract) 1035 { 1036 GSList *list = NULL; 1037 1038 object_class_foreach(object_class_get_list_tramp, 1039 implements_type, include_abstract, &list); 1040 return list; 1041 } 1042 1043 static gint object_class_cmp(gconstpointer a, gconstpointer b) 1044 { 1045 return strcasecmp(object_class_get_name((ObjectClass *)a), 1046 object_class_get_name((ObjectClass *)b)); 1047 } 1048 1049 GSList *object_class_get_list_sorted(const char *implements_type, 1050 bool include_abstract) 1051 { 1052 return g_slist_sort(object_class_get_list(implements_type, include_abstract), 1053 object_class_cmp); 1054 } 1055 1056 void object_ref(Object *obj) 1057 { 1058 if (!obj) { 1059 return; 1060 } 1061 atomic_inc(&obj->ref); 1062 } 1063 1064 void object_unref(Object *obj) 1065 { 1066 if (!obj) { 1067 return; 1068 } 1069 g_assert(obj->ref > 0); 1070 1071 /* parent always holds a reference to its children */ 1072 if (atomic_fetch_dec(&obj->ref) == 1) { 1073 object_finalize(obj); 1074 } 1075 } 1076 1077 ObjectProperty * 1078 object_property_add(Object *obj, const char *name, const char *type, 1079 ObjectPropertyAccessor *get, 1080 ObjectPropertyAccessor *set, 1081 ObjectPropertyRelease *release, 1082 void *opaque, Error **errp) 1083 { 1084 ObjectProperty *prop; 1085 size_t name_len = strlen(name); 1086 1087 if (name_len >= 3 && !memcmp(name + name_len - 3, "[*]", 4)) { 1088 int i; 1089 ObjectProperty *ret; 1090 char *name_no_array = g_strdup(name); 1091 1092 name_no_array[name_len - 3] = '\0'; 1093 for (i = 0; ; ++i) { 1094 char *full_name = g_strdup_printf("%s[%d]", name_no_array, i); 1095 1096 ret = object_property_add(obj, full_name, type, get, set, 1097 release, opaque, NULL); 1098 g_free(full_name); 1099 if (ret) { 1100 break; 1101 } 1102 } 1103 g_free(name_no_array); 1104 return ret; 1105 } 1106 1107 if (object_property_find(obj, name, NULL) != NULL) { 1108 error_setg(errp, "attempt to add duplicate property '%s'" 1109 " to object (type '%s')", name, 1110 object_get_typename(obj)); 1111 return NULL; 1112 } 1113 1114 prop = g_malloc0(sizeof(*prop)); 1115 1116 prop->name = g_strdup(name); 1117 prop->type = g_strdup(type); 1118 1119 prop->get = get; 1120 prop->set = set; 1121 prop->release = release; 1122 prop->opaque = opaque; 1123 1124 g_hash_table_insert(obj->properties, prop->name, prop); 1125 return prop; 1126 } 1127 1128 ObjectProperty * 1129 object_class_property_add(ObjectClass *klass, 1130 const char *name, 1131 const char *type, 1132 ObjectPropertyAccessor *get, 1133 ObjectPropertyAccessor *set, 1134 ObjectPropertyRelease *release, 1135 void *opaque, 1136 Error **errp) 1137 { 1138 ObjectProperty *prop; 1139 1140 if (object_class_property_find(klass, name, NULL) != NULL) { 1141 error_setg(errp, "attempt to add duplicate property '%s'" 1142 " to object (type '%s')", name, 1143 object_class_get_name(klass)); 1144 return NULL; 1145 } 1146 1147 prop = g_malloc0(sizeof(*prop)); 1148 1149 prop->name = g_strdup(name); 1150 prop->type = g_strdup(type); 1151 1152 prop->get = get; 1153 prop->set = set; 1154 prop->release = release; 1155 prop->opaque = opaque; 1156 1157 g_hash_table_insert(klass->properties, g_strdup(name), prop); 1158 1159 return prop; 1160 } 1161 1162 ObjectProperty *object_property_find(Object *obj, const char *name, 1163 Error **errp) 1164 { 1165 ObjectProperty *prop; 1166 ObjectClass *klass = object_get_class(obj); 1167 1168 prop = object_class_property_find(klass, name, NULL); 1169 if (prop) { 1170 return prop; 1171 } 1172 1173 prop = g_hash_table_lookup(obj->properties, name); 1174 if (prop) { 1175 return prop; 1176 } 1177 1178 error_setg(errp, "Property '.%s' not found", name); 1179 return NULL; 1180 } 1181 1182 void object_property_iter_init(ObjectPropertyIterator *iter, 1183 Object *obj) 1184 { 1185 g_hash_table_iter_init(&iter->iter, obj->properties); 1186 iter->nextclass = object_get_class(obj); 1187 } 1188 1189 ObjectProperty *object_property_iter_next(ObjectPropertyIterator *iter) 1190 { 1191 gpointer key, val; 1192 while (!g_hash_table_iter_next(&iter->iter, &key, &val)) { 1193 if (!iter->nextclass) { 1194 return NULL; 1195 } 1196 g_hash_table_iter_init(&iter->iter, iter->nextclass->properties); 1197 iter->nextclass = object_class_get_parent(iter->nextclass); 1198 } 1199 return val; 1200 } 1201 1202 void object_class_property_iter_init(ObjectPropertyIterator *iter, 1203 ObjectClass *klass) 1204 { 1205 g_hash_table_iter_init(&iter->iter, klass->properties); 1206 iter->nextclass = object_class_get_parent(klass); 1207 } 1208 1209 ObjectProperty *object_class_property_find(ObjectClass *klass, const char *name, 1210 Error **errp) 1211 { 1212 ObjectProperty *prop; 1213 ObjectClass *parent_klass; 1214 1215 parent_klass = object_class_get_parent(klass); 1216 if (parent_klass) { 1217 prop = object_class_property_find(parent_klass, name, NULL); 1218 if (prop) { 1219 return prop; 1220 } 1221 } 1222 1223 prop = g_hash_table_lookup(klass->properties, name); 1224 if (!prop) { 1225 error_setg(errp, "Property '.%s' not found", name); 1226 } 1227 return prop; 1228 } 1229 1230 void object_property_del(Object *obj, const char *name, Error **errp) 1231 { 1232 ObjectProperty *prop = g_hash_table_lookup(obj->properties, name); 1233 1234 if (!prop) { 1235 error_setg(errp, "Property '.%s' not found", name); 1236 return; 1237 } 1238 1239 if (prop->release) { 1240 prop->release(obj, name, prop->opaque); 1241 } 1242 g_hash_table_remove(obj->properties, name); 1243 } 1244 1245 void object_property_get(Object *obj, Visitor *v, const char *name, 1246 Error **errp) 1247 { 1248 ObjectProperty *prop = object_property_find(obj, name, errp); 1249 if (prop == NULL) { 1250 return; 1251 } 1252 1253 if (!prop->get) { 1254 error_setg(errp, QERR_PERMISSION_DENIED); 1255 } else { 1256 prop->get(obj, v, name, prop->opaque, errp); 1257 } 1258 } 1259 1260 void object_property_set(Object *obj, Visitor *v, const char *name, 1261 Error **errp) 1262 { 1263 ObjectProperty *prop = object_property_find(obj, name, errp); 1264 if (prop == NULL) { 1265 return; 1266 } 1267 1268 if (!prop->set) { 1269 error_setg(errp, QERR_PERMISSION_DENIED); 1270 } else { 1271 prop->set(obj, v, name, prop->opaque, errp); 1272 } 1273 } 1274 1275 void object_property_set_str(Object *obj, const char *value, 1276 const char *name, Error **errp) 1277 { 1278 QString *qstr = qstring_from_str(value); 1279 object_property_set_qobject(obj, QOBJECT(qstr), name, errp); 1280 1281 qobject_unref(qstr); 1282 } 1283 1284 char *object_property_get_str(Object *obj, const char *name, 1285 Error **errp) 1286 { 1287 QObject *ret = object_property_get_qobject(obj, name, errp); 1288 char *retval; 1289 1290 if (!ret) { 1291 return NULL; 1292 } 1293 1294 retval = g_strdup(qobject_get_try_str(ret)); 1295 if (!retval) { 1296 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "string"); 1297 } 1298 1299 qobject_unref(ret); 1300 return retval; 1301 } 1302 1303 void object_property_set_link(Object *obj, Object *value, 1304 const char *name, Error **errp) 1305 { 1306 if (value) { 1307 gchar *path = object_get_canonical_path(value); 1308 object_property_set_str(obj, path, name, errp); 1309 g_free(path); 1310 } else { 1311 object_property_set_str(obj, "", name, errp); 1312 } 1313 } 1314 1315 Object *object_property_get_link(Object *obj, const char *name, 1316 Error **errp) 1317 { 1318 char *str = object_property_get_str(obj, name, errp); 1319 Object *target = NULL; 1320 1321 if (str && *str) { 1322 target = object_resolve_path(str, NULL); 1323 if (!target) { 1324 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, 1325 "Device '%s' not found", str); 1326 } 1327 } 1328 1329 g_free(str); 1330 return target; 1331 } 1332 1333 void object_property_set_bool(Object *obj, bool value, 1334 const char *name, Error **errp) 1335 { 1336 QBool *qbool = qbool_from_bool(value); 1337 object_property_set_qobject(obj, QOBJECT(qbool), name, errp); 1338 1339 qobject_unref(qbool); 1340 } 1341 1342 bool object_property_get_bool(Object *obj, const char *name, 1343 Error **errp) 1344 { 1345 QObject *ret = object_property_get_qobject(obj, name, errp); 1346 QBool *qbool; 1347 bool retval; 1348 1349 if (!ret) { 1350 return false; 1351 } 1352 qbool = qobject_to(QBool, ret); 1353 if (!qbool) { 1354 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "boolean"); 1355 retval = false; 1356 } else { 1357 retval = qbool_get_bool(qbool); 1358 } 1359 1360 qobject_unref(ret); 1361 return retval; 1362 } 1363 1364 void object_property_set_int(Object *obj, int64_t value, 1365 const char *name, Error **errp) 1366 { 1367 QNum *qnum = qnum_from_int(value); 1368 object_property_set_qobject(obj, QOBJECT(qnum), name, errp); 1369 1370 qobject_unref(qnum); 1371 } 1372 1373 int64_t object_property_get_int(Object *obj, const char *name, 1374 Error **errp) 1375 { 1376 QObject *ret = object_property_get_qobject(obj, name, errp); 1377 QNum *qnum; 1378 int64_t retval; 1379 1380 if (!ret) { 1381 return -1; 1382 } 1383 1384 qnum = qobject_to(QNum, ret); 1385 if (!qnum || !qnum_get_try_int(qnum, &retval)) { 1386 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "int"); 1387 retval = -1; 1388 } 1389 1390 qobject_unref(ret); 1391 return retval; 1392 } 1393 1394 void object_property_set_uint(Object *obj, uint64_t value, 1395 const char *name, Error **errp) 1396 { 1397 QNum *qnum = qnum_from_uint(value); 1398 1399 object_property_set_qobject(obj, QOBJECT(qnum), name, errp); 1400 qobject_unref(qnum); 1401 } 1402 1403 uint64_t object_property_get_uint(Object *obj, const char *name, 1404 Error **errp) 1405 { 1406 QObject *ret = object_property_get_qobject(obj, name, errp); 1407 QNum *qnum; 1408 uint64_t retval; 1409 1410 if (!ret) { 1411 return 0; 1412 } 1413 qnum = qobject_to(QNum, ret); 1414 if (!qnum || !qnum_get_try_uint(qnum, &retval)) { 1415 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "uint"); 1416 retval = 0; 1417 } 1418 1419 qobject_unref(ret); 1420 return retval; 1421 } 1422 1423 typedef struct EnumProperty { 1424 const QEnumLookup *lookup; 1425 int (*get)(Object *, Error **); 1426 void (*set)(Object *, int, Error **); 1427 } EnumProperty; 1428 1429 int object_property_get_enum(Object *obj, const char *name, 1430 const char *typename, Error **errp) 1431 { 1432 Error *err = NULL; 1433 Visitor *v; 1434 char *str; 1435 int ret; 1436 ObjectProperty *prop = object_property_find(obj, name, errp); 1437 EnumProperty *enumprop; 1438 1439 if (prop == NULL) { 1440 return 0; 1441 } 1442 1443 if (!g_str_equal(prop->type, typename)) { 1444 error_setg(errp, "Property %s on %s is not '%s' enum type", 1445 name, object_class_get_name( 1446 object_get_class(obj)), typename); 1447 return 0; 1448 } 1449 1450 enumprop = prop->opaque; 1451 1452 v = string_output_visitor_new(false, &str); 1453 object_property_get(obj, v, name, &err); 1454 if (err) { 1455 error_propagate(errp, err); 1456 visit_free(v); 1457 return 0; 1458 } 1459 visit_complete(v, &str); 1460 visit_free(v); 1461 v = string_input_visitor_new(str); 1462 visit_type_enum(v, name, &ret, enumprop->lookup, errp); 1463 1464 g_free(str); 1465 visit_free(v); 1466 1467 return ret; 1468 } 1469 1470 void object_property_get_uint16List(Object *obj, const char *name, 1471 uint16List **list, Error **errp) 1472 { 1473 Error *err = NULL; 1474 Visitor *v; 1475 char *str; 1476 1477 v = string_output_visitor_new(false, &str); 1478 object_property_get(obj, v, name, &err); 1479 if (err) { 1480 error_propagate(errp, err); 1481 goto out; 1482 } 1483 visit_complete(v, &str); 1484 visit_free(v); 1485 v = string_input_visitor_new(str); 1486 visit_type_uint16List(v, NULL, list, errp); 1487 1488 g_free(str); 1489 out: 1490 visit_free(v); 1491 } 1492 1493 void object_property_parse(Object *obj, const char *string, 1494 const char *name, Error **errp) 1495 { 1496 Visitor *v = string_input_visitor_new(string); 1497 object_property_set(obj, v, name, errp); 1498 visit_free(v); 1499 } 1500 1501 char *object_property_print(Object *obj, const char *name, bool human, 1502 Error **errp) 1503 { 1504 Visitor *v; 1505 char *string = NULL; 1506 Error *local_err = NULL; 1507 1508 v = string_output_visitor_new(human, &string); 1509 object_property_get(obj, v, name, &local_err); 1510 if (local_err) { 1511 error_propagate(errp, local_err); 1512 goto out; 1513 } 1514 1515 visit_complete(v, &string); 1516 1517 out: 1518 visit_free(v); 1519 return string; 1520 } 1521 1522 const char *object_property_get_type(Object *obj, const char *name, Error **errp) 1523 { 1524 ObjectProperty *prop = object_property_find(obj, name, errp); 1525 if (prop == NULL) { 1526 return NULL; 1527 } 1528 1529 return prop->type; 1530 } 1531 1532 Object *object_get_root(void) 1533 { 1534 static Object *root; 1535 1536 if (!root) { 1537 root = object_new("container"); 1538 } 1539 1540 return root; 1541 } 1542 1543 Object *object_get_objects_root(void) 1544 { 1545 return container_get(object_get_root(), "/objects"); 1546 } 1547 1548 Object *object_get_internal_root(void) 1549 { 1550 static Object *internal_root; 1551 1552 if (!internal_root) { 1553 internal_root = object_new("container"); 1554 } 1555 1556 return internal_root; 1557 } 1558 1559 static void object_get_child_property(Object *obj, Visitor *v, 1560 const char *name, void *opaque, 1561 Error **errp) 1562 { 1563 Object *child = opaque; 1564 gchar *path; 1565 1566 path = object_get_canonical_path(child); 1567 visit_type_str(v, name, &path, errp); 1568 g_free(path); 1569 } 1570 1571 static Object *object_resolve_child_property(Object *parent, void *opaque, const gchar *part) 1572 { 1573 return opaque; 1574 } 1575 1576 static void object_finalize_child_property(Object *obj, const char *name, 1577 void *opaque) 1578 { 1579 Object *child = opaque; 1580 1581 if (child->class->unparent) { 1582 (child->class->unparent)(child); 1583 } 1584 child->parent = NULL; 1585 object_unref(child); 1586 } 1587 1588 void object_property_add_child(Object *obj, const char *name, 1589 Object *child, Error **errp) 1590 { 1591 Error *local_err = NULL; 1592 gchar *type; 1593 ObjectProperty *op; 1594 1595 if (child->parent != NULL) { 1596 error_setg(errp, "child object is already parented"); 1597 return; 1598 } 1599 1600 type = g_strdup_printf("child<%s>", object_get_typename(OBJECT(child))); 1601 1602 op = object_property_add(obj, name, type, object_get_child_property, NULL, 1603 object_finalize_child_property, child, &local_err); 1604 if (local_err) { 1605 error_propagate(errp, local_err); 1606 goto out; 1607 } 1608 1609 op->resolve = object_resolve_child_property; 1610 object_ref(child); 1611 child->parent = obj; 1612 1613 out: 1614 g_free(type); 1615 } 1616 1617 void object_property_allow_set_link(const Object *obj, const char *name, 1618 Object *val, Error **errp) 1619 { 1620 /* Allow the link to be set, always */ 1621 } 1622 1623 typedef struct { 1624 Object **child; 1625 void (*check)(const Object *, const char *, Object *, Error **); 1626 ObjectPropertyLinkFlags flags; 1627 } LinkProperty; 1628 1629 static void object_get_link_property(Object *obj, Visitor *v, 1630 const char *name, void *opaque, 1631 Error **errp) 1632 { 1633 LinkProperty *lprop = opaque; 1634 Object **child = lprop->child; 1635 gchar *path; 1636 1637 if (*child) { 1638 path = object_get_canonical_path(*child); 1639 visit_type_str(v, name, &path, errp); 1640 g_free(path); 1641 } else { 1642 path = (gchar *)""; 1643 visit_type_str(v, name, &path, errp); 1644 } 1645 } 1646 1647 /* 1648 * object_resolve_link: 1649 * 1650 * Lookup an object and ensure its type matches the link property type. This 1651 * is similar to object_resolve_path() except type verification against the 1652 * link property is performed. 1653 * 1654 * Returns: The matched object or NULL on path lookup failures. 1655 */ 1656 static Object *object_resolve_link(Object *obj, const char *name, 1657 const char *path, Error **errp) 1658 { 1659 const char *type; 1660 gchar *target_type; 1661 bool ambiguous = false; 1662 Object *target; 1663 1664 /* Go from link<FOO> to FOO. */ 1665 type = object_property_get_type(obj, name, NULL); 1666 target_type = g_strndup(&type[5], strlen(type) - 6); 1667 target = object_resolve_path_type(path, target_type, &ambiguous); 1668 1669 if (ambiguous) { 1670 error_setg(errp, "Path '%s' does not uniquely identify an object", 1671 path); 1672 } else if (!target) { 1673 target = object_resolve_path(path, &ambiguous); 1674 if (target || ambiguous) { 1675 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, target_type); 1676 } else { 1677 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, 1678 "Device '%s' not found", path); 1679 } 1680 target = NULL; 1681 } 1682 g_free(target_type); 1683 1684 return target; 1685 } 1686 1687 static void object_set_link_property(Object *obj, Visitor *v, 1688 const char *name, void *opaque, 1689 Error **errp) 1690 { 1691 Error *local_err = NULL; 1692 LinkProperty *prop = opaque; 1693 Object **child = prop->child; 1694 Object *old_target = *child; 1695 Object *new_target = NULL; 1696 char *path = NULL; 1697 1698 visit_type_str(v, name, &path, &local_err); 1699 1700 if (!local_err && strcmp(path, "") != 0) { 1701 new_target = object_resolve_link(obj, name, path, &local_err); 1702 } 1703 1704 g_free(path); 1705 if (local_err) { 1706 error_propagate(errp, local_err); 1707 return; 1708 } 1709 1710 prop->check(obj, name, new_target, &local_err); 1711 if (local_err) { 1712 error_propagate(errp, local_err); 1713 return; 1714 } 1715 1716 *child = new_target; 1717 if (prop->flags == OBJ_PROP_LINK_STRONG) { 1718 object_ref(new_target); 1719 object_unref(old_target); 1720 } 1721 } 1722 1723 static Object *object_resolve_link_property(Object *parent, void *opaque, const gchar *part) 1724 { 1725 LinkProperty *lprop = opaque; 1726 1727 return *lprop->child; 1728 } 1729 1730 static void object_release_link_property(Object *obj, const char *name, 1731 void *opaque) 1732 { 1733 LinkProperty *prop = opaque; 1734 1735 if ((prop->flags & OBJ_PROP_LINK_STRONG) && *prop->child) { 1736 object_unref(*prop->child); 1737 } 1738 g_free(prop); 1739 } 1740 1741 void object_property_add_link(Object *obj, const char *name, 1742 const char *type, Object **child, 1743 void (*check)(const Object *, const char *, 1744 Object *, Error **), 1745 ObjectPropertyLinkFlags flags, 1746 Error **errp) 1747 { 1748 Error *local_err = NULL; 1749 LinkProperty *prop = g_malloc(sizeof(*prop)); 1750 gchar *full_type; 1751 ObjectProperty *op; 1752 1753 prop->child = child; 1754 prop->check = check; 1755 prop->flags = flags; 1756 1757 full_type = g_strdup_printf("link<%s>", type); 1758 1759 op = object_property_add(obj, name, full_type, 1760 object_get_link_property, 1761 check ? object_set_link_property : NULL, 1762 object_release_link_property, 1763 prop, 1764 &local_err); 1765 if (local_err) { 1766 error_propagate(errp, local_err); 1767 g_free(prop); 1768 goto out; 1769 } 1770 1771 op->resolve = object_resolve_link_property; 1772 1773 out: 1774 g_free(full_type); 1775 } 1776 1777 void object_property_add_const_link(Object *obj, const char *name, 1778 Object *target, Error **errp) 1779 { 1780 char *link_type; 1781 ObjectProperty *op; 1782 1783 link_type = g_strdup_printf("link<%s>", object_get_typename(target)); 1784 op = object_property_add(obj, name, link_type, 1785 object_get_child_property, NULL, 1786 NULL, target, errp); 1787 if (op != NULL) { 1788 op->resolve = object_resolve_child_property; 1789 } 1790 g_free(link_type); 1791 } 1792 1793 gchar *object_get_canonical_path_component(Object *obj) 1794 { 1795 ObjectProperty *prop = NULL; 1796 GHashTableIter iter; 1797 1798 if (obj->parent == NULL) { 1799 return NULL; 1800 } 1801 1802 g_hash_table_iter_init(&iter, obj->parent->properties); 1803 while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) { 1804 if (!object_property_is_child(prop)) { 1805 continue; 1806 } 1807 1808 if (prop->opaque == obj) { 1809 return g_strdup(prop->name); 1810 } 1811 } 1812 1813 /* obj had a parent but was not a child, should never happen */ 1814 g_assert_not_reached(); 1815 return NULL; 1816 } 1817 1818 gchar *object_get_canonical_path(Object *obj) 1819 { 1820 Object *root = object_get_root(); 1821 char *newpath, *path = NULL; 1822 1823 if (obj == root) { 1824 return g_strdup("/"); 1825 } 1826 1827 do { 1828 char *component = object_get_canonical_path_component(obj); 1829 1830 if (!component) { 1831 /* A canonical path must be complete, so discard what was 1832 * collected so far. 1833 */ 1834 g_free(path); 1835 return NULL; 1836 } 1837 1838 newpath = g_strdup_printf("/%s%s", component, path ? path : ""); 1839 g_free(path); 1840 g_free(component); 1841 path = newpath; 1842 obj = obj->parent; 1843 } while (obj != root); 1844 1845 return path; 1846 } 1847 1848 Object *object_resolve_path_component(Object *parent, const gchar *part) 1849 { 1850 ObjectProperty *prop = object_property_find(parent, part, NULL); 1851 if (prop == NULL) { 1852 return NULL; 1853 } 1854 1855 if (prop->resolve) { 1856 return prop->resolve(parent, prop->opaque, part); 1857 } else { 1858 return NULL; 1859 } 1860 } 1861 1862 static Object *object_resolve_abs_path(Object *parent, 1863 gchar **parts, 1864 const char *typename, 1865 int index) 1866 { 1867 Object *child; 1868 1869 if (parts[index] == NULL) { 1870 return object_dynamic_cast(parent, typename); 1871 } 1872 1873 if (strcmp(parts[index], "") == 0) { 1874 return object_resolve_abs_path(parent, parts, typename, index + 1); 1875 } 1876 1877 child = object_resolve_path_component(parent, parts[index]); 1878 if (!child) { 1879 return NULL; 1880 } 1881 1882 return object_resolve_abs_path(child, parts, typename, index + 1); 1883 } 1884 1885 static Object *object_resolve_partial_path(Object *parent, 1886 gchar **parts, 1887 const char *typename, 1888 bool *ambiguous) 1889 { 1890 Object *obj; 1891 GHashTableIter iter; 1892 ObjectProperty *prop; 1893 1894 obj = object_resolve_abs_path(parent, parts, typename, 0); 1895 1896 g_hash_table_iter_init(&iter, parent->properties); 1897 while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) { 1898 Object *found; 1899 1900 if (!object_property_is_child(prop)) { 1901 continue; 1902 } 1903 1904 found = object_resolve_partial_path(prop->opaque, parts, 1905 typename, ambiguous); 1906 if (found) { 1907 if (obj) { 1908 *ambiguous = true; 1909 return NULL; 1910 } 1911 obj = found; 1912 } 1913 1914 if (*ambiguous) { 1915 return NULL; 1916 } 1917 } 1918 1919 return obj; 1920 } 1921 1922 Object *object_resolve_path_type(const char *path, const char *typename, 1923 bool *ambiguousp) 1924 { 1925 Object *obj; 1926 gchar **parts; 1927 1928 parts = g_strsplit(path, "/", 0); 1929 assert(parts); 1930 1931 if (parts[0] == NULL || strcmp(parts[0], "") != 0) { 1932 bool ambiguous = false; 1933 obj = object_resolve_partial_path(object_get_root(), parts, 1934 typename, &ambiguous); 1935 if (ambiguousp) { 1936 *ambiguousp = ambiguous; 1937 } 1938 } else { 1939 obj = object_resolve_abs_path(object_get_root(), parts, typename, 1); 1940 } 1941 1942 g_strfreev(parts); 1943 1944 return obj; 1945 } 1946 1947 Object *object_resolve_path(const char *path, bool *ambiguous) 1948 { 1949 return object_resolve_path_type(path, TYPE_OBJECT, ambiguous); 1950 } 1951 1952 typedef struct StringProperty 1953 { 1954 char *(*get)(Object *, Error **); 1955 void (*set)(Object *, const char *, Error **); 1956 } StringProperty; 1957 1958 static void property_get_str(Object *obj, Visitor *v, const char *name, 1959 void *opaque, Error **errp) 1960 { 1961 StringProperty *prop = opaque; 1962 char *value; 1963 Error *err = NULL; 1964 1965 value = prop->get(obj, &err); 1966 if (err) { 1967 error_propagate(errp, err); 1968 return; 1969 } 1970 1971 visit_type_str(v, name, &value, errp); 1972 g_free(value); 1973 } 1974 1975 static void property_set_str(Object *obj, Visitor *v, const char *name, 1976 void *opaque, Error **errp) 1977 { 1978 StringProperty *prop = opaque; 1979 char *value; 1980 Error *local_err = NULL; 1981 1982 visit_type_str(v, name, &value, &local_err); 1983 if (local_err) { 1984 error_propagate(errp, local_err); 1985 return; 1986 } 1987 1988 prop->set(obj, value, errp); 1989 g_free(value); 1990 } 1991 1992 static void property_release_str(Object *obj, const char *name, 1993 void *opaque) 1994 { 1995 StringProperty *prop = opaque; 1996 g_free(prop); 1997 } 1998 1999 void object_property_add_str(Object *obj, const char *name, 2000 char *(*get)(Object *, Error **), 2001 void (*set)(Object *, const char *, Error **), 2002 Error **errp) 2003 { 2004 Error *local_err = NULL; 2005 StringProperty *prop = g_malloc0(sizeof(*prop)); 2006 2007 prop->get = get; 2008 prop->set = set; 2009 2010 object_property_add(obj, name, "string", 2011 get ? property_get_str : NULL, 2012 set ? property_set_str : NULL, 2013 property_release_str, 2014 prop, &local_err); 2015 if (local_err) { 2016 error_propagate(errp, local_err); 2017 g_free(prop); 2018 } 2019 } 2020 2021 void object_class_property_add_str(ObjectClass *klass, const char *name, 2022 char *(*get)(Object *, Error **), 2023 void (*set)(Object *, const char *, 2024 Error **), 2025 Error **errp) 2026 { 2027 Error *local_err = NULL; 2028 StringProperty *prop = g_malloc0(sizeof(*prop)); 2029 2030 prop->get = get; 2031 prop->set = set; 2032 2033 object_class_property_add(klass, name, "string", 2034 get ? property_get_str : NULL, 2035 set ? property_set_str : NULL, 2036 property_release_str, 2037 prop, &local_err); 2038 if (local_err) { 2039 error_propagate(errp, local_err); 2040 g_free(prop); 2041 } 2042 } 2043 2044 typedef struct BoolProperty 2045 { 2046 bool (*get)(Object *, Error **); 2047 void (*set)(Object *, bool, Error **); 2048 } BoolProperty; 2049 2050 static void property_get_bool(Object *obj, Visitor *v, const char *name, 2051 void *opaque, Error **errp) 2052 { 2053 BoolProperty *prop = opaque; 2054 bool value; 2055 Error *err = NULL; 2056 2057 value = prop->get(obj, &err); 2058 if (err) { 2059 error_propagate(errp, err); 2060 return; 2061 } 2062 2063 visit_type_bool(v, name, &value, errp); 2064 } 2065 2066 static void property_set_bool(Object *obj, Visitor *v, const char *name, 2067 void *opaque, Error **errp) 2068 { 2069 BoolProperty *prop = opaque; 2070 bool value; 2071 Error *local_err = NULL; 2072 2073 visit_type_bool(v, name, &value, &local_err); 2074 if (local_err) { 2075 error_propagate(errp, local_err); 2076 return; 2077 } 2078 2079 prop->set(obj, value, errp); 2080 } 2081 2082 static void property_release_bool(Object *obj, const char *name, 2083 void *opaque) 2084 { 2085 BoolProperty *prop = opaque; 2086 g_free(prop); 2087 } 2088 2089 void object_property_add_bool(Object *obj, const char *name, 2090 bool (*get)(Object *, Error **), 2091 void (*set)(Object *, bool, Error **), 2092 Error **errp) 2093 { 2094 Error *local_err = NULL; 2095 BoolProperty *prop = g_malloc0(sizeof(*prop)); 2096 2097 prop->get = get; 2098 prop->set = set; 2099 2100 object_property_add(obj, name, "bool", 2101 get ? property_get_bool : NULL, 2102 set ? property_set_bool : NULL, 2103 property_release_bool, 2104 prop, &local_err); 2105 if (local_err) { 2106 error_propagate(errp, local_err); 2107 g_free(prop); 2108 } 2109 } 2110 2111 void object_class_property_add_bool(ObjectClass *klass, const char *name, 2112 bool (*get)(Object *, Error **), 2113 void (*set)(Object *, bool, Error **), 2114 Error **errp) 2115 { 2116 Error *local_err = NULL; 2117 BoolProperty *prop = g_malloc0(sizeof(*prop)); 2118 2119 prop->get = get; 2120 prop->set = set; 2121 2122 object_class_property_add(klass, name, "bool", 2123 get ? property_get_bool : NULL, 2124 set ? property_set_bool : NULL, 2125 property_release_bool, 2126 prop, &local_err); 2127 if (local_err) { 2128 error_propagate(errp, local_err); 2129 g_free(prop); 2130 } 2131 } 2132 2133 static void property_get_enum(Object *obj, Visitor *v, const char *name, 2134 void *opaque, Error **errp) 2135 { 2136 EnumProperty *prop = opaque; 2137 int value; 2138 Error *err = NULL; 2139 2140 value = prop->get(obj, &err); 2141 if (err) { 2142 error_propagate(errp, err); 2143 return; 2144 } 2145 2146 visit_type_enum(v, name, &value, prop->lookup, errp); 2147 } 2148 2149 static void property_set_enum(Object *obj, Visitor *v, const char *name, 2150 void *opaque, Error **errp) 2151 { 2152 EnumProperty *prop = opaque; 2153 int value; 2154 Error *err = NULL; 2155 2156 visit_type_enum(v, name, &value, prop->lookup, &err); 2157 if (err) { 2158 error_propagate(errp, err); 2159 return; 2160 } 2161 prop->set(obj, value, errp); 2162 } 2163 2164 static void property_release_enum(Object *obj, const char *name, 2165 void *opaque) 2166 { 2167 EnumProperty *prop = opaque; 2168 g_free(prop); 2169 } 2170 2171 void object_property_add_enum(Object *obj, const char *name, 2172 const char *typename, 2173 const QEnumLookup *lookup, 2174 int (*get)(Object *, Error **), 2175 void (*set)(Object *, int, Error **), 2176 Error **errp) 2177 { 2178 Error *local_err = NULL; 2179 EnumProperty *prop = g_malloc(sizeof(*prop)); 2180 2181 prop->lookup = lookup; 2182 prop->get = get; 2183 prop->set = set; 2184 2185 object_property_add(obj, name, typename, 2186 get ? property_get_enum : NULL, 2187 set ? property_set_enum : NULL, 2188 property_release_enum, 2189 prop, &local_err); 2190 if (local_err) { 2191 error_propagate(errp, local_err); 2192 g_free(prop); 2193 } 2194 } 2195 2196 void object_class_property_add_enum(ObjectClass *klass, const char *name, 2197 const char *typename, 2198 const QEnumLookup *lookup, 2199 int (*get)(Object *, Error **), 2200 void (*set)(Object *, int, Error **), 2201 Error **errp) 2202 { 2203 Error *local_err = NULL; 2204 EnumProperty *prop = g_malloc(sizeof(*prop)); 2205 2206 prop->lookup = lookup; 2207 prop->get = get; 2208 prop->set = set; 2209 2210 object_class_property_add(klass, name, typename, 2211 get ? property_get_enum : NULL, 2212 set ? property_set_enum : NULL, 2213 property_release_enum, 2214 prop, &local_err); 2215 if (local_err) { 2216 error_propagate(errp, local_err); 2217 g_free(prop); 2218 } 2219 } 2220 2221 typedef struct TMProperty { 2222 void (*get)(Object *, struct tm *, Error **); 2223 } TMProperty; 2224 2225 static void property_get_tm(Object *obj, Visitor *v, const char *name, 2226 void *opaque, Error **errp) 2227 { 2228 TMProperty *prop = opaque; 2229 Error *err = NULL; 2230 struct tm value; 2231 2232 prop->get(obj, &value, &err); 2233 if (err) { 2234 goto out; 2235 } 2236 2237 visit_start_struct(v, name, NULL, 0, &err); 2238 if (err) { 2239 goto out; 2240 } 2241 visit_type_int32(v, "tm_year", &value.tm_year, &err); 2242 if (err) { 2243 goto out_end; 2244 } 2245 visit_type_int32(v, "tm_mon", &value.tm_mon, &err); 2246 if (err) { 2247 goto out_end; 2248 } 2249 visit_type_int32(v, "tm_mday", &value.tm_mday, &err); 2250 if (err) { 2251 goto out_end; 2252 } 2253 visit_type_int32(v, "tm_hour", &value.tm_hour, &err); 2254 if (err) { 2255 goto out_end; 2256 } 2257 visit_type_int32(v, "tm_min", &value.tm_min, &err); 2258 if (err) { 2259 goto out_end; 2260 } 2261 visit_type_int32(v, "tm_sec", &value.tm_sec, &err); 2262 if (err) { 2263 goto out_end; 2264 } 2265 visit_check_struct(v, &err); 2266 out_end: 2267 visit_end_struct(v, NULL); 2268 out: 2269 error_propagate(errp, err); 2270 2271 } 2272 2273 static void property_release_tm(Object *obj, const char *name, 2274 void *opaque) 2275 { 2276 TMProperty *prop = opaque; 2277 g_free(prop); 2278 } 2279 2280 void object_property_add_tm(Object *obj, const char *name, 2281 void (*get)(Object *, struct tm *, Error **), 2282 Error **errp) 2283 { 2284 Error *local_err = NULL; 2285 TMProperty *prop = g_malloc0(sizeof(*prop)); 2286 2287 prop->get = get; 2288 2289 object_property_add(obj, name, "struct tm", 2290 get ? property_get_tm : NULL, NULL, 2291 property_release_tm, 2292 prop, &local_err); 2293 if (local_err) { 2294 error_propagate(errp, local_err); 2295 g_free(prop); 2296 } 2297 } 2298 2299 void object_class_property_add_tm(ObjectClass *klass, const char *name, 2300 void (*get)(Object *, struct tm *, Error **), 2301 Error **errp) 2302 { 2303 Error *local_err = NULL; 2304 TMProperty *prop = g_malloc0(sizeof(*prop)); 2305 2306 prop->get = get; 2307 2308 object_class_property_add(klass, name, "struct tm", 2309 get ? property_get_tm : NULL, NULL, 2310 property_release_tm, 2311 prop, &local_err); 2312 if (local_err) { 2313 error_propagate(errp, local_err); 2314 g_free(prop); 2315 } 2316 } 2317 2318 static char *qdev_get_type(Object *obj, Error **errp) 2319 { 2320 return g_strdup(object_get_typename(obj)); 2321 } 2322 2323 static void property_get_uint8_ptr(Object *obj, Visitor *v, const char *name, 2324 void *opaque, Error **errp) 2325 { 2326 uint8_t value = *(uint8_t *)opaque; 2327 visit_type_uint8(v, name, &value, errp); 2328 } 2329 2330 static void property_get_uint16_ptr(Object *obj, Visitor *v, const char *name, 2331 void *opaque, Error **errp) 2332 { 2333 uint16_t value = *(uint16_t *)opaque; 2334 visit_type_uint16(v, name, &value, errp); 2335 } 2336 2337 static void property_get_uint32_ptr(Object *obj, Visitor *v, const char *name, 2338 void *opaque, Error **errp) 2339 { 2340 uint32_t value = *(uint32_t *)opaque; 2341 visit_type_uint32(v, name, &value, errp); 2342 } 2343 2344 static void property_get_uint64_ptr(Object *obj, Visitor *v, const char *name, 2345 void *opaque, Error **errp) 2346 { 2347 uint64_t value = *(uint64_t *)opaque; 2348 visit_type_uint64(v, name, &value, errp); 2349 } 2350 2351 void object_property_add_uint8_ptr(Object *obj, const char *name, 2352 const uint8_t *v, Error **errp) 2353 { 2354 object_property_add(obj, name, "uint8", property_get_uint8_ptr, 2355 NULL, NULL, (void *)v, errp); 2356 } 2357 2358 void object_class_property_add_uint8_ptr(ObjectClass *klass, const char *name, 2359 const uint8_t *v, Error **errp) 2360 { 2361 object_class_property_add(klass, name, "uint8", property_get_uint8_ptr, 2362 NULL, NULL, (void *)v, errp); 2363 } 2364 2365 void object_property_add_uint16_ptr(Object *obj, const char *name, 2366 const uint16_t *v, Error **errp) 2367 { 2368 object_property_add(obj, name, "uint16", property_get_uint16_ptr, 2369 NULL, NULL, (void *)v, errp); 2370 } 2371 2372 void object_class_property_add_uint16_ptr(ObjectClass *klass, const char *name, 2373 const uint16_t *v, Error **errp) 2374 { 2375 object_class_property_add(klass, name, "uint16", property_get_uint16_ptr, 2376 NULL, NULL, (void *)v, errp); 2377 } 2378 2379 void object_property_add_uint32_ptr(Object *obj, const char *name, 2380 const uint32_t *v, Error **errp) 2381 { 2382 object_property_add(obj, name, "uint32", property_get_uint32_ptr, 2383 NULL, NULL, (void *)v, errp); 2384 } 2385 2386 void object_class_property_add_uint32_ptr(ObjectClass *klass, const char *name, 2387 const uint32_t *v, Error **errp) 2388 { 2389 object_class_property_add(klass, name, "uint32", property_get_uint32_ptr, 2390 NULL, NULL, (void *)v, errp); 2391 } 2392 2393 void object_property_add_uint64_ptr(Object *obj, const char *name, 2394 const uint64_t *v, Error **errp) 2395 { 2396 object_property_add(obj, name, "uint64", property_get_uint64_ptr, 2397 NULL, NULL, (void *)v, errp); 2398 } 2399 2400 void object_class_property_add_uint64_ptr(ObjectClass *klass, const char *name, 2401 const uint64_t *v, Error **errp) 2402 { 2403 object_class_property_add(klass, name, "uint64", property_get_uint64_ptr, 2404 NULL, NULL, (void *)v, errp); 2405 } 2406 2407 typedef struct { 2408 Object *target_obj; 2409 char *target_name; 2410 } AliasProperty; 2411 2412 static void property_get_alias(Object *obj, Visitor *v, const char *name, 2413 void *opaque, Error **errp) 2414 { 2415 AliasProperty *prop = opaque; 2416 2417 object_property_get(prop->target_obj, v, prop->target_name, errp); 2418 } 2419 2420 static void property_set_alias(Object *obj, Visitor *v, const char *name, 2421 void *opaque, Error **errp) 2422 { 2423 AliasProperty *prop = opaque; 2424 2425 object_property_set(prop->target_obj, v, prop->target_name, errp); 2426 } 2427 2428 static Object *property_resolve_alias(Object *obj, void *opaque, 2429 const gchar *part) 2430 { 2431 AliasProperty *prop = opaque; 2432 2433 return object_resolve_path_component(prop->target_obj, prop->target_name); 2434 } 2435 2436 static void property_release_alias(Object *obj, const char *name, void *opaque) 2437 { 2438 AliasProperty *prop = opaque; 2439 2440 g_free(prop->target_name); 2441 g_free(prop); 2442 } 2443 2444 void object_property_add_alias(Object *obj, const char *name, 2445 Object *target_obj, const char *target_name, 2446 Error **errp) 2447 { 2448 AliasProperty *prop; 2449 ObjectProperty *op; 2450 ObjectProperty *target_prop; 2451 gchar *prop_type; 2452 Error *local_err = NULL; 2453 2454 target_prop = object_property_find(target_obj, target_name, errp); 2455 if (!target_prop) { 2456 return; 2457 } 2458 2459 if (object_property_is_child(target_prop)) { 2460 prop_type = g_strdup_printf("link%s", 2461 target_prop->type + strlen("child")); 2462 } else { 2463 prop_type = g_strdup(target_prop->type); 2464 } 2465 2466 prop = g_malloc(sizeof(*prop)); 2467 prop->target_obj = target_obj; 2468 prop->target_name = g_strdup(target_name); 2469 2470 op = object_property_add(obj, name, prop_type, 2471 property_get_alias, 2472 property_set_alias, 2473 property_release_alias, 2474 prop, &local_err); 2475 if (local_err) { 2476 error_propagate(errp, local_err); 2477 g_free(prop); 2478 goto out; 2479 } 2480 op->resolve = property_resolve_alias; 2481 2482 object_property_set_description(obj, op->name, 2483 target_prop->description, 2484 &error_abort); 2485 2486 out: 2487 g_free(prop_type); 2488 } 2489 2490 void object_property_set_description(Object *obj, const char *name, 2491 const char *description, Error **errp) 2492 { 2493 ObjectProperty *op; 2494 2495 op = object_property_find(obj, name, errp); 2496 if (!op) { 2497 return; 2498 } 2499 2500 g_free(op->description); 2501 op->description = g_strdup(description); 2502 } 2503 2504 void object_class_property_set_description(ObjectClass *klass, 2505 const char *name, 2506 const char *description, 2507 Error **errp) 2508 { 2509 ObjectProperty *op; 2510 2511 op = g_hash_table_lookup(klass->properties, name); 2512 if (!op) { 2513 error_setg(errp, "Property '.%s' not found", name); 2514 return; 2515 } 2516 2517 g_free(op->description); 2518 op->description = g_strdup(description); 2519 } 2520 2521 static void object_class_init(ObjectClass *klass, void *data) 2522 { 2523 object_class_property_add_str(klass, "type", qdev_get_type, 2524 NULL, &error_abort); 2525 } 2526 2527 static void register_types(void) 2528 { 2529 static TypeInfo interface_info = { 2530 .name = TYPE_INTERFACE, 2531 .class_size = sizeof(InterfaceClass), 2532 .abstract = true, 2533 }; 2534 2535 static TypeInfo object_info = { 2536 .name = TYPE_OBJECT, 2537 .instance_size = sizeof(Object), 2538 .class_init = object_class_init, 2539 .abstract = true, 2540 }; 2541 2542 type_interface = type_register_internal(&interface_info); 2543 type_register_internal(&object_info); 2544 } 2545 2546 type_init(register_types) 2547