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/object.h" 14 #include "qemu-common.h" 15 #include "qapi/qapi-visit-core.h" 16 #include "qapi/string-input-visitor.h" 17 #include "qapi/string-output-visitor.h" 18 19 /* TODO: replace QObject with a simpler visitor to avoid a dependency 20 * of the QOM core on QObject? */ 21 #include "qemu/qom-qobject.h" 22 #include "qobject.h" 23 #include "qbool.h" 24 #include "qint.h" 25 #include "qstring.h" 26 27 #define MAX_INTERFACES 32 28 29 typedef struct InterfaceImpl InterfaceImpl; 30 typedef struct TypeImpl TypeImpl; 31 32 struct InterfaceImpl 33 { 34 const char *typename; 35 }; 36 37 struct TypeImpl 38 { 39 const char *name; 40 41 size_t class_size; 42 43 size_t instance_size; 44 45 void (*class_init)(ObjectClass *klass, void *data); 46 void (*class_base_init)(ObjectClass *klass, void *data); 47 void (*class_finalize)(ObjectClass *klass, void *data); 48 49 void *class_data; 50 51 void (*instance_init)(Object *obj); 52 void (*instance_finalize)(Object *obj); 53 54 bool abstract; 55 56 const char *parent; 57 TypeImpl *parent_type; 58 59 ObjectClass *class; 60 61 int num_interfaces; 62 InterfaceImpl interfaces[MAX_INTERFACES]; 63 }; 64 65 static Type type_interface; 66 67 static GHashTable *type_table_get(void) 68 { 69 static GHashTable *type_table; 70 71 if (type_table == NULL) { 72 type_table = g_hash_table_new(g_str_hash, g_str_equal); 73 } 74 75 return type_table; 76 } 77 78 static void type_table_add(TypeImpl *ti) 79 { 80 g_hash_table_insert(type_table_get(), (void *)ti->name, ti); 81 } 82 83 static TypeImpl *type_table_lookup(const char *name) 84 { 85 return g_hash_table_lookup(type_table_get(), name); 86 } 87 88 static TypeImpl *type_register_internal(const TypeInfo *info) 89 { 90 TypeImpl *ti = g_malloc0(sizeof(*ti)); 91 int i; 92 93 g_assert(info->name != NULL); 94 95 if (type_table_lookup(info->name) != NULL) { 96 fprintf(stderr, "Registering `%s' which already exists\n", info->name); 97 abort(); 98 } 99 100 ti->name = g_strdup(info->name); 101 ti->parent = g_strdup(info->parent); 102 103 ti->class_size = info->class_size; 104 ti->instance_size = info->instance_size; 105 106 ti->class_init = info->class_init; 107 ti->class_base_init = info->class_base_init; 108 ti->class_finalize = info->class_finalize; 109 ti->class_data = info->class_data; 110 111 ti->instance_init = info->instance_init; 112 ti->instance_finalize = info->instance_finalize; 113 114 ti->abstract = info->abstract; 115 116 for (i = 0; info->interfaces && info->interfaces[i].type; i++) { 117 ti->interfaces[i].typename = g_strdup(info->interfaces[i].type); 118 } 119 ti->num_interfaces = i; 120 121 type_table_add(ti); 122 123 return ti; 124 } 125 126 TypeImpl *type_register(const TypeInfo *info) 127 { 128 assert(info->parent); 129 return type_register_internal(info); 130 } 131 132 TypeImpl *type_register_static(const TypeInfo *info) 133 { 134 return type_register(info); 135 } 136 137 static TypeImpl *type_get_by_name(const char *name) 138 { 139 if (name == NULL) { 140 return NULL; 141 } 142 143 return type_table_lookup(name); 144 } 145 146 static TypeImpl *type_get_parent(TypeImpl *type) 147 { 148 if (!type->parent_type && type->parent) { 149 type->parent_type = type_get_by_name(type->parent); 150 g_assert(type->parent_type != NULL); 151 } 152 153 return type->parent_type; 154 } 155 156 static bool type_has_parent(TypeImpl *type) 157 { 158 return (type->parent != NULL); 159 } 160 161 static size_t type_class_get_size(TypeImpl *ti) 162 { 163 if (ti->class_size) { 164 return ti->class_size; 165 } 166 167 if (type_has_parent(ti)) { 168 return type_class_get_size(type_get_parent(ti)); 169 } 170 171 return sizeof(ObjectClass); 172 } 173 174 static size_t type_object_get_size(TypeImpl *ti) 175 { 176 if (ti->instance_size) { 177 return ti->instance_size; 178 } 179 180 if (type_has_parent(ti)) { 181 return type_object_get_size(type_get_parent(ti)); 182 } 183 184 return 0; 185 } 186 187 static bool type_is_ancestor(TypeImpl *type, TypeImpl *target_type) 188 { 189 assert(target_type); 190 191 /* Check if typename is a direct ancestor of type */ 192 while (type) { 193 if (type == target_type) { 194 return true; 195 } 196 197 type = type_get_parent(type); 198 } 199 200 return false; 201 } 202 203 static void type_initialize(TypeImpl *ti); 204 205 static void type_initialize_interface(TypeImpl *ti, const char *parent) 206 { 207 InterfaceClass *new_iface; 208 TypeInfo info = { }; 209 TypeImpl *iface_impl; 210 211 info.parent = parent; 212 info.name = g_strdup_printf("%s::%s", ti->name, info.parent); 213 info.abstract = true; 214 215 iface_impl = type_register(&info); 216 type_initialize(iface_impl); 217 g_free((char *)info.name); 218 219 new_iface = (InterfaceClass *)iface_impl->class; 220 new_iface->concrete_class = ti->class; 221 222 ti->class->interfaces = g_slist_append(ti->class->interfaces, 223 iface_impl->class); 224 } 225 226 static void type_initialize(TypeImpl *ti) 227 { 228 TypeImpl *parent; 229 230 if (ti->class) { 231 return; 232 } 233 234 ti->class_size = type_class_get_size(ti); 235 ti->instance_size = type_object_get_size(ti); 236 237 ti->class = g_malloc0(ti->class_size); 238 239 parent = type_get_parent(ti); 240 if (parent) { 241 type_initialize(parent); 242 GSList *e; 243 int i; 244 245 g_assert(parent->class_size <= ti->class_size); 246 memcpy(ti->class, parent->class, parent->class_size); 247 248 for (e = parent->class->interfaces; e; e = e->next) { 249 ObjectClass *iface = e->data; 250 type_initialize_interface(ti, object_class_get_name(iface)); 251 } 252 253 for (i = 0; i < ti->num_interfaces; i++) { 254 TypeImpl *t = type_get_by_name(ti->interfaces[i].typename); 255 for (e = ti->class->interfaces; e; e = e->next) { 256 TypeImpl *target_type = OBJECT_CLASS(e->data)->type; 257 258 if (type_is_ancestor(target_type, t)) { 259 break; 260 } 261 } 262 263 if (e) { 264 continue; 265 } 266 267 type_initialize_interface(ti, ti->interfaces[i].typename); 268 } 269 } 270 271 ti->class->type = ti; 272 273 while (parent) { 274 if (parent->class_base_init) { 275 parent->class_base_init(ti->class, ti->class_data); 276 } 277 parent = type_get_parent(parent); 278 } 279 280 if (ti->class_init) { 281 ti->class_init(ti->class, ti->class_data); 282 } 283 284 285 } 286 287 static void object_init_with_type(Object *obj, TypeImpl *ti) 288 { 289 if (type_has_parent(ti)) { 290 object_init_with_type(obj, type_get_parent(ti)); 291 } 292 293 if (ti->instance_init) { 294 ti->instance_init(obj); 295 } 296 } 297 298 void object_initialize_with_type(void *data, TypeImpl *type) 299 { 300 Object *obj = data; 301 302 g_assert(type != NULL); 303 type_initialize(type); 304 305 g_assert(type->instance_size >= sizeof(Object)); 306 g_assert(type->abstract == false); 307 308 memset(obj, 0, type->instance_size); 309 obj->class = type->class; 310 QTAILQ_INIT(&obj->properties); 311 object_init_with_type(obj, type); 312 } 313 314 void object_initialize(void *data, const char *typename) 315 { 316 TypeImpl *type = type_get_by_name(typename); 317 318 object_initialize_with_type(data, type); 319 } 320 321 static inline bool object_property_is_child(ObjectProperty *prop) 322 { 323 return strstart(prop->type, "child<", NULL); 324 } 325 326 static inline bool object_property_is_link(ObjectProperty *prop) 327 { 328 return strstart(prop->type, "link<", NULL); 329 } 330 331 static void object_property_del_all(Object *obj) 332 { 333 while (!QTAILQ_EMPTY(&obj->properties)) { 334 ObjectProperty *prop = QTAILQ_FIRST(&obj->properties); 335 336 QTAILQ_REMOVE(&obj->properties, prop, node); 337 338 if (prop->release) { 339 prop->release(obj, prop->name, prop->opaque); 340 } 341 342 g_free(prop->name); 343 g_free(prop->type); 344 g_free(prop); 345 } 346 } 347 348 static void object_property_del_child(Object *obj, Object *child, Error **errp) 349 { 350 ObjectProperty *prop; 351 352 QTAILQ_FOREACH(prop, &obj->properties, node) { 353 if (object_property_is_child(prop) && prop->opaque == child) { 354 object_property_del(obj, prop->name, errp); 355 break; 356 } 357 } 358 } 359 360 void object_unparent(Object *obj) 361 { 362 if (obj->parent) { 363 object_property_del_child(obj->parent, obj, NULL); 364 } 365 } 366 367 static void object_deinit(Object *obj, TypeImpl *type) 368 { 369 if (type->instance_finalize) { 370 type->instance_finalize(obj); 371 } 372 373 if (type_has_parent(type)) { 374 object_deinit(obj, type_get_parent(type)); 375 } 376 } 377 378 void object_finalize(void *data) 379 { 380 Object *obj = data; 381 TypeImpl *ti = obj->class->type; 382 383 object_deinit(obj, ti); 384 object_property_del_all(obj); 385 386 g_assert(obj->ref == 0); 387 } 388 389 Object *object_new_with_type(Type type) 390 { 391 Object *obj; 392 393 g_assert(type != NULL); 394 type_initialize(type); 395 396 obj = g_malloc(type->instance_size); 397 object_initialize_with_type(obj, type); 398 object_ref(obj); 399 400 return obj; 401 } 402 403 Object *object_new(const char *typename) 404 { 405 TypeImpl *ti = type_get_by_name(typename); 406 407 return object_new_with_type(ti); 408 } 409 410 void object_delete(Object *obj) 411 { 412 object_unparent(obj); 413 g_assert(obj->ref == 1); 414 object_unref(obj); 415 g_free(obj); 416 } 417 418 Object *object_dynamic_cast(Object *obj, const char *typename) 419 { 420 if (object_class_dynamic_cast(object_get_class(obj), typename)) { 421 return obj; 422 } 423 424 return NULL; 425 } 426 427 Object *object_dynamic_cast_assert(Object *obj, const char *typename) 428 { 429 Object *inst; 430 431 inst = object_dynamic_cast(obj, typename); 432 433 if (!inst) { 434 fprintf(stderr, "Object %p is not an instance of type %s\n", 435 obj, typename); 436 abort(); 437 } 438 439 return inst; 440 } 441 442 ObjectClass *object_class_dynamic_cast(ObjectClass *class, 443 const char *typename) 444 { 445 TypeImpl *target_type = type_get_by_name(typename); 446 TypeImpl *type = class->type; 447 ObjectClass *ret = NULL; 448 449 if (type->num_interfaces && type_is_ancestor(target_type, type_interface)) { 450 int found = 0; 451 GSList *i; 452 453 for (i = class->interfaces; i; i = i->next) { 454 ObjectClass *target_class = i->data; 455 456 if (type_is_ancestor(target_class->type, target_type)) { 457 ret = target_class; 458 found++; 459 } 460 } 461 462 /* The match was ambiguous, don't allow a cast */ 463 if (found > 1) { 464 ret = NULL; 465 } 466 } else if (type_is_ancestor(type, target_type)) { 467 ret = class; 468 } 469 470 return ret; 471 } 472 473 ObjectClass *object_class_dynamic_cast_assert(ObjectClass *class, 474 const char *typename) 475 { 476 ObjectClass *ret = object_class_dynamic_cast(class, typename); 477 478 if (!ret) { 479 fprintf(stderr, "Object %p is not an instance of type %s\n", 480 class, typename); 481 abort(); 482 } 483 484 return ret; 485 } 486 487 const char *object_get_typename(Object *obj) 488 { 489 return obj->class->type->name; 490 } 491 492 ObjectClass *object_get_class(Object *obj) 493 { 494 return obj->class; 495 } 496 497 const char *object_class_get_name(ObjectClass *klass) 498 { 499 return klass->type->name; 500 } 501 502 ObjectClass *object_class_by_name(const char *typename) 503 { 504 TypeImpl *type = type_get_by_name(typename); 505 506 if (!type) { 507 return NULL; 508 } 509 510 type_initialize(type); 511 512 return type->class; 513 } 514 515 ObjectClass *object_class_get_parent(ObjectClass *class) 516 { 517 TypeImpl *type = type_get_parent(class->type); 518 519 if (!type) { 520 return NULL; 521 } 522 523 type_initialize(type); 524 525 return type->class; 526 } 527 528 typedef struct OCFData 529 { 530 void (*fn)(ObjectClass *klass, void *opaque); 531 const char *implements_type; 532 bool include_abstract; 533 void *opaque; 534 } OCFData; 535 536 static void object_class_foreach_tramp(gpointer key, gpointer value, 537 gpointer opaque) 538 { 539 OCFData *data = opaque; 540 TypeImpl *type = value; 541 ObjectClass *k; 542 543 type_initialize(type); 544 k = type->class; 545 546 if (!data->include_abstract && type->abstract) { 547 return; 548 } 549 550 if (data->implements_type && 551 !object_class_dynamic_cast(k, data->implements_type)) { 552 return; 553 } 554 555 data->fn(k, data->opaque); 556 } 557 558 void object_class_foreach(void (*fn)(ObjectClass *klass, void *opaque), 559 const char *implements_type, bool include_abstract, 560 void *opaque) 561 { 562 OCFData data = { fn, implements_type, include_abstract, opaque }; 563 564 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp, &data); 565 } 566 567 int object_child_foreach(Object *obj, int (*fn)(Object *child, void *opaque), 568 void *opaque) 569 { 570 ObjectProperty *prop; 571 int ret = 0; 572 573 QTAILQ_FOREACH(prop, &obj->properties, node) { 574 if (object_property_is_child(prop)) { 575 ret = fn(prop->opaque, opaque); 576 if (ret != 0) { 577 break; 578 } 579 } 580 } 581 return ret; 582 } 583 584 static void object_class_get_list_tramp(ObjectClass *klass, void *opaque) 585 { 586 GSList **list = opaque; 587 588 *list = g_slist_prepend(*list, klass); 589 } 590 591 GSList *object_class_get_list(const char *implements_type, 592 bool include_abstract) 593 { 594 GSList *list = NULL; 595 596 object_class_foreach(object_class_get_list_tramp, 597 implements_type, include_abstract, &list); 598 return list; 599 } 600 601 void object_ref(Object *obj) 602 { 603 obj->ref++; 604 } 605 606 void object_unref(Object *obj) 607 { 608 g_assert(obj->ref > 0); 609 obj->ref--; 610 611 /* parent always holds a reference to its children */ 612 if (obj->ref == 0) { 613 object_finalize(obj); 614 } 615 } 616 617 void object_property_add(Object *obj, const char *name, const char *type, 618 ObjectPropertyAccessor *get, 619 ObjectPropertyAccessor *set, 620 ObjectPropertyRelease *release, 621 void *opaque, Error **errp) 622 { 623 ObjectProperty *prop = g_malloc0(sizeof(*prop)); 624 625 prop->name = g_strdup(name); 626 prop->type = g_strdup(type); 627 628 prop->get = get; 629 prop->set = set; 630 prop->release = release; 631 prop->opaque = opaque; 632 633 QTAILQ_INSERT_TAIL(&obj->properties, prop, node); 634 } 635 636 ObjectProperty *object_property_find(Object *obj, const char *name, 637 Error **errp) 638 { 639 ObjectProperty *prop; 640 641 QTAILQ_FOREACH(prop, &obj->properties, node) { 642 if (strcmp(prop->name, name) == 0) { 643 return prop; 644 } 645 } 646 647 error_set(errp, QERR_PROPERTY_NOT_FOUND, "", name); 648 return NULL; 649 } 650 651 void object_property_del(Object *obj, const char *name, Error **errp) 652 { 653 ObjectProperty *prop = object_property_find(obj, name, errp); 654 if (prop == NULL) { 655 return; 656 } 657 658 if (prop->release) { 659 prop->release(obj, name, prop->opaque); 660 } 661 662 QTAILQ_REMOVE(&obj->properties, prop, node); 663 664 g_free(prop->name); 665 g_free(prop->type); 666 g_free(prop); 667 } 668 669 void object_property_get(Object *obj, Visitor *v, const char *name, 670 Error **errp) 671 { 672 ObjectProperty *prop = object_property_find(obj, name, errp); 673 if (prop == NULL) { 674 return; 675 } 676 677 if (!prop->get) { 678 error_set(errp, QERR_PERMISSION_DENIED); 679 } else { 680 prop->get(obj, v, prop->opaque, name, errp); 681 } 682 } 683 684 void object_property_set(Object *obj, Visitor *v, const char *name, 685 Error **errp) 686 { 687 ObjectProperty *prop = object_property_find(obj, name, errp); 688 if (prop == NULL) { 689 return; 690 } 691 692 if (!prop->set) { 693 error_set(errp, QERR_PERMISSION_DENIED); 694 } else { 695 prop->set(obj, v, prop->opaque, name, errp); 696 } 697 } 698 699 void object_property_set_str(Object *obj, const char *value, 700 const char *name, Error **errp) 701 { 702 QString *qstr = qstring_from_str(value); 703 object_property_set_qobject(obj, QOBJECT(qstr), name, errp); 704 705 QDECREF(qstr); 706 } 707 708 char *object_property_get_str(Object *obj, const char *name, 709 Error **errp) 710 { 711 QObject *ret = object_property_get_qobject(obj, name, errp); 712 QString *qstring; 713 char *retval; 714 715 if (!ret) { 716 return NULL; 717 } 718 qstring = qobject_to_qstring(ret); 719 if (!qstring) { 720 error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, "string"); 721 retval = NULL; 722 } else { 723 retval = g_strdup(qstring_get_str(qstring)); 724 } 725 726 QDECREF(qstring); 727 return retval; 728 } 729 730 void object_property_set_link(Object *obj, Object *value, 731 const char *name, Error **errp) 732 { 733 object_property_set_str(obj, object_get_canonical_path(value), 734 name, errp); 735 } 736 737 Object *object_property_get_link(Object *obj, const char *name, 738 Error **errp) 739 { 740 char *str = object_property_get_str(obj, name, errp); 741 Object *target = NULL; 742 743 if (str && *str) { 744 target = object_resolve_path(str, NULL); 745 if (!target) { 746 error_set(errp, QERR_DEVICE_NOT_FOUND, str); 747 } 748 } 749 750 g_free(str); 751 return target; 752 } 753 754 void object_property_set_bool(Object *obj, bool value, 755 const char *name, Error **errp) 756 { 757 QBool *qbool = qbool_from_int(value); 758 object_property_set_qobject(obj, QOBJECT(qbool), name, errp); 759 760 QDECREF(qbool); 761 } 762 763 bool object_property_get_bool(Object *obj, const char *name, 764 Error **errp) 765 { 766 QObject *ret = object_property_get_qobject(obj, name, errp); 767 QBool *qbool; 768 bool retval; 769 770 if (!ret) { 771 return false; 772 } 773 qbool = qobject_to_qbool(ret); 774 if (!qbool) { 775 error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, "boolean"); 776 retval = false; 777 } else { 778 retval = qbool_get_int(qbool); 779 } 780 781 QDECREF(qbool); 782 return retval; 783 } 784 785 void object_property_set_int(Object *obj, int64_t value, 786 const char *name, Error **errp) 787 { 788 QInt *qint = qint_from_int(value); 789 object_property_set_qobject(obj, QOBJECT(qint), name, errp); 790 791 QDECREF(qint); 792 } 793 794 int64_t object_property_get_int(Object *obj, const char *name, 795 Error **errp) 796 { 797 QObject *ret = object_property_get_qobject(obj, name, errp); 798 QInt *qint; 799 int64_t retval; 800 801 if (!ret) { 802 return -1; 803 } 804 qint = qobject_to_qint(ret); 805 if (!qint) { 806 error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, "int"); 807 retval = -1; 808 } else { 809 retval = qint_get_int(qint); 810 } 811 812 QDECREF(qint); 813 return retval; 814 } 815 816 void object_property_parse(Object *obj, const char *string, 817 const char *name, Error **errp) 818 { 819 StringInputVisitor *mi; 820 mi = string_input_visitor_new(string); 821 object_property_set(obj, string_input_get_visitor(mi), name, errp); 822 823 string_input_visitor_cleanup(mi); 824 } 825 826 char *object_property_print(Object *obj, const char *name, 827 Error **errp) 828 { 829 StringOutputVisitor *mo; 830 char *string; 831 832 mo = string_output_visitor_new(); 833 object_property_get(obj, string_output_get_visitor(mo), name, errp); 834 string = string_output_get_string(mo); 835 string_output_visitor_cleanup(mo); 836 return string; 837 } 838 839 const char *object_property_get_type(Object *obj, const char *name, Error **errp) 840 { 841 ObjectProperty *prop = object_property_find(obj, name, errp); 842 if (prop == NULL) { 843 return NULL; 844 } 845 846 return prop->type; 847 } 848 849 Object *object_get_root(void) 850 { 851 static Object *root; 852 853 if (!root) { 854 root = object_new("container"); 855 } 856 857 return root; 858 } 859 860 static void object_get_child_property(Object *obj, Visitor *v, void *opaque, 861 const char *name, Error **errp) 862 { 863 Object *child = opaque; 864 gchar *path; 865 866 path = object_get_canonical_path(child); 867 visit_type_str(v, &path, name, errp); 868 g_free(path); 869 } 870 871 static void object_finalize_child_property(Object *obj, const char *name, 872 void *opaque) 873 { 874 Object *child = opaque; 875 876 object_unref(child); 877 } 878 879 void object_property_add_child(Object *obj, const char *name, 880 Object *child, Error **errp) 881 { 882 gchar *type; 883 884 type = g_strdup_printf("child<%s>", object_get_typename(OBJECT(child))); 885 886 object_property_add(obj, name, type, object_get_child_property, 887 NULL, object_finalize_child_property, child, errp); 888 889 object_ref(child); 890 g_assert(child->parent == NULL); 891 child->parent = obj; 892 893 g_free(type); 894 } 895 896 static void object_get_link_property(Object *obj, Visitor *v, void *opaque, 897 const char *name, Error **errp) 898 { 899 Object **child = opaque; 900 gchar *path; 901 902 if (*child) { 903 path = object_get_canonical_path(*child); 904 visit_type_str(v, &path, name, errp); 905 g_free(path); 906 } else { 907 path = (gchar *)""; 908 visit_type_str(v, &path, name, errp); 909 } 910 } 911 912 static void object_set_link_property(Object *obj, Visitor *v, void *opaque, 913 const char *name, Error **errp) 914 { 915 Object **child = opaque; 916 Object *old_target; 917 bool ambiguous = false; 918 const char *type; 919 char *path; 920 gchar *target_type; 921 922 type = object_property_get_type(obj, name, NULL); 923 924 visit_type_str(v, &path, name, errp); 925 926 old_target = *child; 927 *child = NULL; 928 929 if (strcmp(path, "") != 0) { 930 Object *target; 931 932 /* Go from link<FOO> to FOO. */ 933 target_type = g_strndup(&type[5], strlen(type) - 6); 934 target = object_resolve_path_type(path, target_type, &ambiguous); 935 936 if (ambiguous) { 937 error_set(errp, QERR_AMBIGUOUS_PATH, path); 938 } else if (target) { 939 object_ref(target); 940 *child = target; 941 } else { 942 target = object_resolve_path(path, &ambiguous); 943 if (target || ambiguous) { 944 error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, target_type); 945 } else { 946 error_set(errp, QERR_DEVICE_NOT_FOUND, path); 947 } 948 } 949 g_free(target_type); 950 } 951 952 g_free(path); 953 954 if (old_target != NULL) { 955 object_unref(old_target); 956 } 957 } 958 959 void object_property_add_link(Object *obj, const char *name, 960 const char *type, Object **child, 961 Error **errp) 962 { 963 gchar *full_type; 964 965 full_type = g_strdup_printf("link<%s>", type); 966 967 object_property_add(obj, name, full_type, 968 object_get_link_property, 969 object_set_link_property, 970 NULL, child, errp); 971 972 g_free(full_type); 973 } 974 975 gchar *object_get_canonical_path(Object *obj) 976 { 977 Object *root = object_get_root(); 978 char *newpath = NULL, *path = NULL; 979 980 while (obj != root) { 981 ObjectProperty *prop = NULL; 982 983 g_assert(obj->parent != NULL); 984 985 QTAILQ_FOREACH(prop, &obj->parent->properties, node) { 986 if (!object_property_is_child(prop)) { 987 continue; 988 } 989 990 if (prop->opaque == obj) { 991 if (path) { 992 newpath = g_strdup_printf("%s/%s", prop->name, path); 993 g_free(path); 994 path = newpath; 995 } else { 996 path = g_strdup(prop->name); 997 } 998 break; 999 } 1000 } 1001 1002 g_assert(prop != NULL); 1003 1004 obj = obj->parent; 1005 } 1006 1007 newpath = g_strdup_printf("/%s", path); 1008 g_free(path); 1009 1010 return newpath; 1011 } 1012 1013 Object *object_resolve_path_component(Object *parent, gchar *part) 1014 { 1015 ObjectProperty *prop = object_property_find(parent, part, NULL); 1016 if (prop == NULL) { 1017 return NULL; 1018 } 1019 1020 if (object_property_is_link(prop)) { 1021 return *(Object **)prop->opaque; 1022 } else if (object_property_is_child(prop)) { 1023 return prop->opaque; 1024 } else { 1025 return NULL; 1026 } 1027 } 1028 1029 static Object *object_resolve_abs_path(Object *parent, 1030 gchar **parts, 1031 const char *typename, 1032 int index) 1033 { 1034 Object *child; 1035 1036 if (parts[index] == NULL) { 1037 return object_dynamic_cast(parent, typename); 1038 } 1039 1040 if (strcmp(parts[index], "") == 0) { 1041 return object_resolve_abs_path(parent, parts, typename, index + 1); 1042 } 1043 1044 child = object_resolve_path_component(parent, parts[index]); 1045 if (!child) { 1046 return NULL; 1047 } 1048 1049 return object_resolve_abs_path(child, parts, typename, index + 1); 1050 } 1051 1052 static Object *object_resolve_partial_path(Object *parent, 1053 gchar **parts, 1054 const char *typename, 1055 bool *ambiguous) 1056 { 1057 Object *obj; 1058 ObjectProperty *prop; 1059 1060 obj = object_resolve_abs_path(parent, parts, typename, 0); 1061 1062 QTAILQ_FOREACH(prop, &parent->properties, node) { 1063 Object *found; 1064 1065 if (!object_property_is_child(prop)) { 1066 continue; 1067 } 1068 1069 found = object_resolve_partial_path(prop->opaque, parts, 1070 typename, ambiguous); 1071 if (found) { 1072 if (obj) { 1073 if (ambiguous) { 1074 *ambiguous = true; 1075 } 1076 return NULL; 1077 } 1078 obj = found; 1079 } 1080 1081 if (ambiguous && *ambiguous) { 1082 return NULL; 1083 } 1084 } 1085 1086 return obj; 1087 } 1088 1089 Object *object_resolve_path_type(const char *path, const char *typename, 1090 bool *ambiguous) 1091 { 1092 bool partial_path = true; 1093 Object *obj; 1094 gchar **parts; 1095 1096 parts = g_strsplit(path, "/", 0); 1097 if (parts == NULL || parts[0] == NULL) { 1098 g_strfreev(parts); 1099 return object_get_root(); 1100 } 1101 1102 if (strcmp(parts[0], "") == 0) { 1103 partial_path = false; 1104 } 1105 1106 if (partial_path) { 1107 if (ambiguous) { 1108 *ambiguous = false; 1109 } 1110 obj = object_resolve_partial_path(object_get_root(), parts, 1111 typename, ambiguous); 1112 } else { 1113 obj = object_resolve_abs_path(object_get_root(), parts, typename, 1); 1114 } 1115 1116 g_strfreev(parts); 1117 1118 return obj; 1119 } 1120 1121 Object *object_resolve_path(const char *path, bool *ambiguous) 1122 { 1123 return object_resolve_path_type(path, TYPE_OBJECT, ambiguous); 1124 } 1125 1126 typedef struct StringProperty 1127 { 1128 char *(*get)(Object *, Error **); 1129 void (*set)(Object *, const char *, Error **); 1130 } StringProperty; 1131 1132 static void property_get_str(Object *obj, Visitor *v, void *opaque, 1133 const char *name, Error **errp) 1134 { 1135 StringProperty *prop = opaque; 1136 char *value; 1137 1138 value = prop->get(obj, errp); 1139 if (value) { 1140 visit_type_str(v, &value, name, errp); 1141 g_free(value); 1142 } 1143 } 1144 1145 static void property_set_str(Object *obj, Visitor *v, void *opaque, 1146 const char *name, Error **errp) 1147 { 1148 StringProperty *prop = opaque; 1149 char *value; 1150 Error *local_err = NULL; 1151 1152 visit_type_str(v, &value, name, &local_err); 1153 if (local_err) { 1154 error_propagate(errp, local_err); 1155 return; 1156 } 1157 1158 prop->set(obj, value, errp); 1159 g_free(value); 1160 } 1161 1162 static void property_release_str(Object *obj, const char *name, 1163 void *opaque) 1164 { 1165 StringProperty *prop = opaque; 1166 g_free(prop); 1167 } 1168 1169 void object_property_add_str(Object *obj, const char *name, 1170 char *(*get)(Object *, Error **), 1171 void (*set)(Object *, const char *, Error **), 1172 Error **errp) 1173 { 1174 StringProperty *prop = g_malloc0(sizeof(*prop)); 1175 1176 prop->get = get; 1177 prop->set = set; 1178 1179 object_property_add(obj, name, "string", 1180 get ? property_get_str : NULL, 1181 set ? property_set_str : NULL, 1182 property_release_str, 1183 prop, errp); 1184 } 1185 1186 static char *qdev_get_type(Object *obj, Error **errp) 1187 { 1188 return g_strdup(object_get_typename(obj)); 1189 } 1190 1191 static void object_instance_init(Object *obj) 1192 { 1193 object_property_add_str(obj, "type", qdev_get_type, NULL, NULL); 1194 } 1195 1196 static void register_types(void) 1197 { 1198 static TypeInfo interface_info = { 1199 .name = TYPE_INTERFACE, 1200 .class_size = sizeof(InterfaceClass), 1201 .abstract = true, 1202 }; 1203 1204 static TypeInfo object_info = { 1205 .name = TYPE_OBJECT, 1206 .instance_size = sizeof(Object), 1207 .instance_init = object_instance_init, 1208 .abstract = true, 1209 }; 1210 1211 type_interface = type_register_internal(&interface_info); 1212 type_register_internal(&object_info); 1213 } 1214 1215 type_init(register_types) 1216