static void acpi_get_cpu_info(AcpiCpuInfo *cpu) { Object *root = object_get_root(); memset(cpu->found_cpus, 0, sizeof cpu->found_cpus); object_child_foreach(root, acpi_add_cpu_info, cpu); }
/* * inquire NVDIMM devices and link them into the list which is * returned to the caller. * * Note: it is the caller's responsibility to free the list to avoid * memory leak. */ static GSList *nvdimm_get_device_list(void) { GSList *list = NULL; object_child_foreach(qdev_get_machine(), nvdimm_device_list, &list); return list; }
int pc_dimm_get_free_slot(const int *hint, int max_slots, Error **errp) { unsigned long *bitmap = bitmap_new(max_slots); int slot = 0; object_child_foreach(qdev_get_machine(), pc_dimm_slot2bitmap, bitmap); /* check if requested slot is not occupied */ if (hint) { if (*hint >= max_slots) { error_setg(errp, "invalid slot# %d, should be less than %d", *hint, max_slots); } else if (!test_bit(*hint, bitmap)) { slot = *hint; } else { error_setg(errp, "slot %d is busy", *hint); } goto out; } /* search for free slot */ slot = find_first_zero_bit(bitmap, max_slots); if (slot == max_slots) { error_setg(errp, "no free slots available"); } out: g_free(bitmap); return slot; }
static unsigned spapr_phb_get_active_win_num(sPAPRPHBState *sphb) { unsigned ret = 0; object_child_foreach(OBJECT(sphb), spapr_phb_get_active_win_num_cb, &ret); return ret; }
static unsigned spapr_phb_get_free_liobn(sPAPRPHBState *sphb) { uint32_t liobn = 0; object_child_foreach(OBJECT(sphb), spapr_phb_get_free_liobn_cb, &liobn); return liobn; }
PRManagerInfoList *qmp_query_pr_managers(Error **errp) { PRManagerInfoList *head = NULL; PRManagerInfoList **prev = &head; Object *container = container_get(object_get_root(), PR_MANAGER_PATH); object_child_foreach(container, query_one_pr_manager, &prev); return head; }
uint64_t pc_dimm_get_free_addr(uint64_t address_space_start, uint64_t address_space_size, uint64_t *hint, uint64_t size, Error **errp) { GSList *list = NULL, *item; uint64_t new_addr, ret = 0; uint64_t address_space_end = address_space_start + address_space_size; if (!address_space_size) { error_setg(errp, "memory hotplug is not enabled, " "please add maxmem option"); goto out; } assert(address_space_end > address_space_start); object_child_foreach(qdev_get_machine(), pc_dimm_built_list, &list); if (hint) { new_addr = *hint; } else { new_addr = address_space_start; } /* find address range that will fit new DIMM */ for (item = list; item; item = g_slist_next(item)) { PCDIMMDevice *dimm = item->data; uint64_t dimm_size = object_property_get_int(OBJECT(dimm), PC_DIMM_SIZE_PROP, errp); if (errp && *errp) { goto out; } if (ranges_overlap(dimm->addr, dimm_size, new_addr, size)) { if (hint) { DeviceState *d = DEVICE(dimm); error_setg(errp, "address range conflicts with '%s'", d->id); goto out; } new_addr = dimm->addr + dimm_size; } } ret = new_addr; if (new_addr < address_space_start) { error_setg(errp, "can't add memory [0x%" PRIx64 ":0x%" PRIx64 "] at 0x%" PRIx64, new_addr, size, address_space_start); } else if ((new_addr + size) > address_space_end) { error_setg(errp, "can't add memory [0x%" PRIx64 ":0x%" PRIx64 "] beyond 0x%" PRIx64, new_addr, size, address_space_end); } out: g_slist_free(list); return ret; }
IOThreadInfoList *qmp_query_iothreads(Error **errp) { IOThreadInfoList *head = NULL; IOThreadInfoList **prev = &head; Object *container = object_get_objects_root(); object_child_foreach(container, query_one_iothread, &prev); return head; }
static int nvdimm_device_list(Object *obj, void *opaque) { GSList **list = opaque; if (object_dynamic_cast(obj, TYPE_NVDIMM)) { *list = g_slist_append(*list, DEVICE(obj)); } object_child_foreach(obj, nvdimm_device_list, opaque); return 0; }
static int build_dimm_list(Object *obj, void *opaque) { GSList **list = opaque; if (object_dynamic_cast(obj, TYPE_PC_DIMM)) { DeviceState *dev = DEVICE(obj); if (dev->realized) { /* only realized DIMMs matter */ *list = g_slist_prepend(*list, dev); } } object_child_foreach(obj, build_dimm_list, opaque); return 0; }
static int pc_dimm_built_list(Object *obj, void *opaque) { GSList **list = opaque; if (object_dynamic_cast(obj, TYPE_PC_DIMM)) { DeviceState *dev = DEVICE(obj); if (dev->realized) { /* only realized DIMMs matter */ *list = g_slist_insert_sorted(*list, dev, pc_dimm_addr_sort); } } object_child_foreach(obj, pc_dimm_built_list, opaque); return 0; }
static int nvdimm_plugged_device_list(Object *obj, void *opaque) { GSList **list = opaque; if (object_dynamic_cast(obj, TYPE_NVDIMM)) { DeviceState *dev = DEVICE(obj); if (dev->realized) { /* only realized NVDIMMs matter */ *list = g_slist_append(*list, DEVICE(obj)); } } object_child_foreach(obj, nvdimm_plugged_device_list, opaque); return 0; }
static int pc_dimm_slot2bitmap(Object *obj, void *opaque) { unsigned long *bitmap = opaque; if (object_dynamic_cast(obj, TYPE_PC_DIMM)) { DeviceState *dev = DEVICE(obj); if (dev->realized) { /* count only realized DIMMs */ PCDIMMDevice *d = PC_DIMM(obj); set_bit(d->slot, bitmap); } } object_child_foreach(obj, pc_dimm_slot2bitmap, opaque); return 0; }
static int acpi_add_cpu_info(Object *o, void *opaque) { AcpiCpuInfo *cpu = opaque; uint64_t apic_id; if (object_dynamic_cast(o, TYPE_CPU)) { apic_id = object_property_get_int(o, "apic-id", NULL); assert(apic_id <= MAX_CPUMASK_BITS); set_bit(apic_id, cpu->found_cpus); } object_child_foreach(o, acpi_add_cpu_info, opaque); return 0; }
/* Run func() for every sysbus device, traverse the tree for everything else */ static int find_sysbus_device(Object *obj, void *opaque) { SysBusFind *find = opaque; Object *dev; SysBusDevice *sbdev; dev = object_dynamic_cast(obj, TYPE_SYS_BUS_DEVICE); sbdev = (SysBusDevice *)dev; if (!sbdev) { /* Container, traverse it for children */ return object_child_foreach(obj, find_sysbus_device, opaque); } find->func(sbdev, find->opaque); return 0; }
void iothread_stop_all(void) { Object *container = object_get_objects_root(); BlockDriverState *bs; BdrvNextIterator it; for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) { AioContext *ctx = bdrv_get_aio_context(bs); if (ctx == qemu_get_aio_context()) { continue; } aio_context_acquire(ctx); bdrv_set_aio_context(bs, qemu_get_aio_context()); aio_context_release(ctx); } object_child_foreach(container, iothread_stop, NULL); }
static int pc_existing_dimms_capacity_internal(Object *obj, void *opaque) { pc_dimms_capacity *cap = opaque; uint64_t *size = &cap->size; if (object_dynamic_cast(obj, TYPE_PC_DIMM)) { DeviceState *dev = DEVICE(obj); if (dev->realized) { (*size) += object_property_get_uint(obj, PC_DIMM_SIZE_PROP, cap->errp); } if (cap->errp && *cap->errp) { return 1; } } object_child_foreach(obj, pc_existing_dimms_capacity_internal, opaque); return 0; }
MemdevList *qmp_query_memdev(Error **errp) { Object *obj; MemdevList *list = NULL; obj = object_resolve_path("/objects", NULL); if (obj == NULL) { return NULL; } if (object_child_foreach(obj, query_memdev, &list) != 0) { goto error; } return list; error: qapi_free_MemdevList(list); return NULL; }
int qmp_pc_dimm_device_list(Object *obj, void *opaque) { MemoryDeviceInfoList ***prev = opaque; if (object_dynamic_cast(obj, TYPE_PC_DIMM)) { DeviceState *dev = DEVICE(obj); if (dev->realized) { MemoryDeviceInfoList *elem = g_new0(MemoryDeviceInfoList, 1); MemoryDeviceInfo *info = g_new0(MemoryDeviceInfo, 1); PCDIMMDeviceInfo *di = g_new0(PCDIMMDeviceInfo, 1); DeviceClass *dc = DEVICE_GET_CLASS(obj); PCDIMMDevice *dimm = PC_DIMM(obj); if (dev->id) { di->has_id = true; di->id = g_strdup(dev->id); } di->hotplugged = dev->hotplugged; di->hotpluggable = dc->hotpluggable; di->addr = dimm->addr; di->slot = dimm->slot; di->node = dimm->node; di->size = object_property_get_uint(OBJECT(dimm), PC_DIMM_SIZE_PROP, NULL); di->memdev = object_get_canonical_path(OBJECT(dimm->hostmem)); info->u.dimm.data = di; elem->value = info; elem->next = NULL; **prev = elem; *prev = &elem->next; } } object_child_foreach(obj, qmp_pc_dimm_device_list, opaque); return 0; }
static void muxes_realize_done(Notifier *notifier, void *unused) { muxes_realized = true; object_child_foreach(get_chardevs_root(), open_muxes, NULL); }
static void nmi_children(Object *o, struct do_nmi_s *ns) { object_child_foreach(o, do_nmi, ns); }