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