system/qemu
system/qemu
1
0
Fork 0
mirror of https://gitlab.com/qemu-project/qemu synced 2024-07-08 20:17:27 +00:00
Code Issues Projects Releases Wiki Activity

qapi: More complex uses of QAPI_LIST_APPEND

Browse Source 
These cases require a bit more thought to review; in each case, the
code was appending to a list, but not with a FOOList **tail variable.

Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20210113221013.390592-6-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
[Flawed change to qmp_guest_network_get_interfaces() dropped]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
This commit is contained in:
Eric Blake 2021-01-13 16:10:13 -06:00 committed by Markus Armbruster
parent c3033fd372
commit 95b3a8c8a8
13 changed files with 141 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
block/gluster.c
View File

@ -514,7 +514,7 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
{ {
QemuOpts *opts; QemuOpts *opts;
SocketAddress *gsconf = NULL; SocketAddress *gsconf = NULL;
SocketAddressList *curr = NULL; SocketAddressList **tail;
QDict *backing_options = NULL; QDict *backing_options = NULL;
Error *local_err = NULL; Error *local_err = NULL;
char *str = NULL; char *str = NULL;
@ -547,6 +547,7 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
} }
gconf->path = g_strdup(ptr); gconf->path = g_strdup(ptr);
qemu_opts_del(opts); qemu_opts_del(opts);
tail = &gconf->server;
for (i = 0; i < num_servers; i++) { for (i = 0; i < num_servers; i++) {
str = g_strdup_printf(GLUSTER_OPT_SERVER_PATTERN"%d.", i); str = g_strdup_printf(GLUSTER_OPT_SERVER_PATTERN"%d.", i);
@ -655,15 +656,7 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
qemu_opts_del(opts); qemu_opts_del(opts);
} }
if (gconf->server == NULL) { QAPI_LIST_APPEND(tail, gsconf);
gconf->server = g_new0(SocketAddressList, 1);
gconf->server->value = gsconf;
curr = gconf->server;
} else {
curr->next = g_new0(SocketAddressList, 1);
curr->next->value = gsconf;
curr = curr->next;
}
gsconf = NULL; gsconf = NULL;
qobject_unref(backing_options); qobject_unref(backing_options);

14
block/qapi.c
View File

@ -198,7 +198,7 @@ int bdrv_query_snapshot_info_list(BlockDriverState *bs,
{ {
int i, sn_count; int i, sn_count;
QEMUSnapshotInfo *sn_tab = NULL; QEMUSnapshotInfo *sn_tab = NULL;
SnapshotInfoList *info_list, *cur_item = NULL, *head = NULL; SnapshotInfoList *head = NULL, **tail = &head;
SnapshotInfo *info; SnapshotInfo *info;
sn_count = bdrv_snapshot_list(bs, &sn_tab); sn_count = bdrv_snapshot_list(bs, &sn_tab);
@ -233,17 +233,7 @@ int bdrv_query_snapshot_info_list(BlockDriverState *bs,
info->icount = sn_tab[i].icount; info->icount = sn_tab[i].icount;
info->has_icount = sn_tab[i].icount != -1ULL; info->has_icount = sn_tab[i].icount != -1ULL;
info_list = g_new0(SnapshotInfoList, 1); QAPI_LIST_APPEND(tail, info);
info_list->value = info;
/* XXX: waiting for the qapi to support qemu-queue.h types */
if (!cur_item) {
head = cur_item = info_list;
} else {
cur_item->next = info_list;
cur_item = info_list;
}
} }
g_free(sn_tab); g_free(sn_tab);

22
dump/dump.c
View File

@ -2030,39 +2030,29 @@ void qmp_dump_guest_memory(bool paging, const char *file,
DumpGuestMemoryCapability *qmp_query_dump_guest_memory_capability(Error **errp) DumpGuestMemoryCapability *qmp_query_dump_guest_memory_capability(Error **errp)
{ {
DumpGuestMemoryFormatList *item;
DumpGuestMemoryCapability *cap = DumpGuestMemoryCapability *cap =
g_malloc0(sizeof(DumpGuestMemoryCapability)); g_malloc0(sizeof(DumpGuestMemoryCapability));
DumpGuestMemoryFormatList **tail = &cap->formats;
/* elf is always available */ /* elf is always available */
item = g_malloc0(sizeof(DumpGuestMemoryFormatList)); QAPI_LIST_APPEND(tail, DUMP_GUEST_MEMORY_FORMAT_ELF);
cap->formats = item;
item->value = DUMP_GUEST_MEMORY_FORMAT_ELF;
/* kdump-zlib is always available */ /* kdump-zlib is always available */
item->next = g_malloc0(sizeof(DumpGuestMemoryFormatList)); QAPI_LIST_APPEND(tail, DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB);
item = item->next;
item->value = DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB;
/* add new item if kdump-lzo is available */ /* add new item if kdump-lzo is available */
#ifdef CONFIG_LZO #ifdef CONFIG_LZO
item->next = g_malloc0(sizeof(DumpGuestMemoryFormatList)); QAPI_LIST_APPEND(tail, DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO);
item = item->next;
item->value = DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO;
#endif #endif
/* add new item if kdump-snappy is available */ /* add new item if kdump-snappy is available */
#ifdef CONFIG_SNAPPY #ifdef CONFIG_SNAPPY
item->next = g_malloc0(sizeof(DumpGuestMemoryFormatList)); QAPI_LIST_APPEND(tail, DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY);
item = item->next;
item->value = DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY;
#endif #endif
/* Windows dump is available only if target is x86_64 */ /* Windows dump is available only if target is x86_64 */
#ifdef TARGET_X86_64 #ifdef TARGET_X86_64
item->next = g_malloc0(sizeof(DumpGuestMemoryFormatList)); QAPI_LIST_APPEND(tail, DUMP_GUEST_MEMORY_FORMAT_WIN_DMP);
item = item->next;
item->value = DUMP_GUEST_MEMORY_FORMAT_WIN_DMP;
#endif #endif
return cap; return cap;

93
hw/core/machine-qmp-cmds.c
View File

@ -28,11 +28,11 @@ CpuInfoList *qmp_query_cpus(Error **errp)
{ {
MachineState *ms = MACHINE(qdev_get_machine()); MachineState *ms = MACHINE(qdev_get_machine());
MachineClass *mc = MACHINE_GET_CLASS(ms); MachineClass *mc = MACHINE_GET_CLASS(ms);
CpuInfoList *head = NULL, *cur_item = NULL; CpuInfoList *head = NULL, **tail = &head;
CPUState *cpu; CPUState *cpu;
CPU_FOREACH(cpu) { CPU_FOREACH(cpu) {
CpuInfoList *info; CpuInfo *value;
#if defined(TARGET_I386) #if defined(TARGET_I386)
X86CPU *x86_cpu = X86_CPU(cpu); X86CPU *x86_cpu = X86_CPU(cpu);
CPUX86State *env = &x86_cpu->env; CPUX86State *env = &x86_cpu->env;
@ -58,53 +58,46 @@ CpuInfoList *qmp_query_cpus(Error **errp)
cpu_synchronize_state(cpu); cpu_synchronize_state(cpu);
info = g_malloc0(sizeof(*info)); value = g_malloc0(sizeof(*value));
info->value = g_malloc0(sizeof(*info->value)); value->CPU = cpu->cpu_index;
info->value->CPU = cpu->cpu_index; value->current = (cpu == first_cpu);
info->value->current = (cpu == first_cpu); value->halted = cpu->halted;
info->value->halted = cpu->halted; value->qom_path = object_get_canonical_path(OBJECT(cpu));
info->value->qom_path = object_get_canonical_path(OBJECT(cpu)); value->thread_id = cpu->thread_id;
info->value->thread_id = cpu->thread_id;
#if defined(TARGET_I386) #if defined(TARGET_I386)
info->value->arch = CPU_INFO_ARCH_X86; value->arch = CPU_INFO_ARCH_X86;
info->value->u.x86.pc = env->eip + env->segs[R_CS].base; value->u.x86.pc = env->eip + env->segs[R_CS].base;
#elif defined(TARGET_PPC) #elif defined(TARGET_PPC)
info->value->arch = CPU_INFO_ARCH_PPC; value->arch = CPU_INFO_ARCH_PPC;
info->value->u.ppc.nip = env->nip; value->u.ppc.nip = env->nip;
#elif defined(TARGET_SPARC) #elif defined(TARGET_SPARC)
info->value->arch = CPU_INFO_ARCH_SPARC; value->arch = CPU_INFO_ARCH_SPARC;
info->value->u.q_sparc.pc = env->pc; value->u.q_sparc.pc = env->pc;
info->value->u.q_sparc.npc = env->npc; value->u.q_sparc.npc = env->npc;
#elif defined(TARGET_MIPS) #elif defined(TARGET_MIPS)
info->value->arch = CPU_INFO_ARCH_MIPS; value->arch = CPU_INFO_ARCH_MIPS;
info->value->u.q_mips.PC = env->active_tc.PC; value->u.q_mips.PC = env->active_tc.PC;
#elif defined(TARGET_TRICORE) #elif defined(TARGET_TRICORE)
info->value->arch = CPU_INFO_ARCH_TRICORE; value->arch = CPU_INFO_ARCH_TRICORE;
info->value->u.tricore.PC = env->PC; value->u.tricore.PC = env->PC;
#elif defined(TARGET_S390X) #elif defined(TARGET_S390X)
info->value->arch = CPU_INFO_ARCH_S390; value->arch = CPU_INFO_ARCH_S390;
info->value->u.s390.cpu_state = env->cpu_state; value->u.s390.cpu_state = env->cpu_state;
#elif defined(TARGET_RISCV) #elif defined(TARGET_RISCV)
info->value->arch = CPU_INFO_ARCH_RISCV; value->arch = CPU_INFO_ARCH_RISCV;
info->value->u.riscv.pc = env->pc; value->u.riscv.pc = env->pc;
#else #else
info->value->arch = CPU_INFO_ARCH_OTHER; value->arch = CPU_INFO_ARCH_OTHER;
#endif #endif
info->value->has_props = !!mc->cpu_index_to_instance_props; value->has_props = !!mc->cpu_index_to_instance_props;
if (info->value->has_props) { if (value->has_props) {
CpuInstanceProperties *props; CpuInstanceProperties *props;
props = g_malloc0(sizeof(*props)); props = g_malloc0(sizeof(*props));
*props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index); *props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
info->value->props = props; value->props = props;
} }
/* XXX: waiting for the qapi to support GSList */ QAPI_LIST_APPEND(tail, value);
if (!cur_item) {
head = cur_item = info;
} else {
cur_item->next = info;
cur_item = info;
}
} }
return head; return head;
@ -170,39 +163,33 @@ CpuInfoFastList *qmp_query_cpus_fast(Error **errp)
{ {
MachineState *ms = MACHINE(qdev_get_machine()); MachineState *ms = MACHINE(qdev_get_machine());
MachineClass *mc = MACHINE_GET_CLASS(ms); MachineClass *mc = MACHINE_GET_CLASS(ms);
CpuInfoFastList *head = NULL, *cur_item = NULL; CpuInfoFastList *head = NULL, **tail = &head;
SysEmuTarget target = qapi_enum_parse(&SysEmuTarget_lookup, TARGET_NAME, SysEmuTarget target = qapi_enum_parse(&SysEmuTarget_lookup, TARGET_NAME,
-1, &error_abort); -1, &error_abort);
CPUState *cpu; CPUState *cpu;
CPU_FOREACH(cpu) { CPU_FOREACH(cpu) {
CpuInfoFastList *info = g_malloc0(sizeof(*info)); CpuInfoFast *value = g_malloc0(sizeof(*value));
info->value = g_malloc0(sizeof(*info->value));
info->value->cpu_index = cpu->cpu_index; value->cpu_index = cpu->cpu_index;
info->value->qom_path = object_get_canonical_path(OBJECT(cpu)); value->qom_path = object_get_canonical_path(OBJECT(cpu));
info->value->thread_id = cpu->thread_id; value->thread_id = cpu->thread_id;
info->value->has_props = !!mc->cpu_index_to_instance_props; value->has_props = !!mc->cpu_index_to_instance_props;
if (info->value->has_props) { if (value->has_props) {
CpuInstanceProperties *props; CpuInstanceProperties *props;
props = g_malloc0(sizeof(*props)); props = g_malloc0(sizeof(*props));
*props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index); *props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
info->value->props = props; value->props = props;
} }
info->value->arch = sysemu_target_to_cpuinfo_arch(target); value->arch = sysemu_target_to_cpuinfo_arch(target);
info->value->target = target; value->target = target;
if (target == SYS_EMU_TARGET_S390X) { if (target == SYS_EMU_TARGET_S390X) {
cpustate_to_cpuinfo_s390(&info->value->u.s390x, cpu); cpustate_to_cpuinfo_s390(&value->u.s390x, cpu);
} }
if (!cur_item) { QAPI_LIST_APPEND(tail, value);
head = cur_item = info;
} else {
cur_item->next = info;
cur_item = info;
}
} }
return head; return head;

12
hw/mem/memory-device.c
View File

@ -199,7 +199,7 @@ out:
MemoryDeviceInfoList *qmp_memory_device_list(void) MemoryDeviceInfoList *qmp_memory_device_list(void)
{ {
GSList *devices = NULL, *item; GSList *devices = NULL, *item;
MemoryDeviceInfoList *list = NULL, *prev = NULL; MemoryDeviceInfoList *list = NULL, **tail = &list;
object_child_foreach(qdev_get_machine(), memory_device_build_list, object_child_foreach(qdev_get_machine(), memory_device_build_list,
&devices); &devices);
@ -207,19 +207,11 @@ MemoryDeviceInfoList *qmp_memory_device_list(void)
for (item = devices; item; item = g_slist_next(item)) { for (item = devices; item; item = g_slist_next(item)) {
const MemoryDeviceState *md = MEMORY_DEVICE(item->data); const MemoryDeviceState *md = MEMORY_DEVICE(item->data);
const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(item->data); const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(item->data);
MemoryDeviceInfoList *elem = g_new0(MemoryDeviceInfoList, 1);
MemoryDeviceInfo *info = g_new0(MemoryDeviceInfo, 1); MemoryDeviceInfo *info = g_new0(MemoryDeviceInfo, 1);
mdc->fill_device_info(md, info); mdc->fill_device_info(md, info);
elem->value = info; QAPI_LIST_APPEND(tail, info);
elem->next = NULL;
if (prev) {
prev->next = elem;
} else {
list = elem;
}
prev = elem;
} }
g_slist_free(devices); g_slist_free(devices);

60
hw/pci/pci.c
View File

@ -1683,41 +1683,34 @@ static PciDeviceInfoList *qmp_query_pci_devices(PCIBus *bus, int bus_num);
static PciMemoryRegionList *qmp_query_pci_regions(const PCIDevice *dev) static PciMemoryRegionList *qmp_query_pci_regions(const PCIDevice *dev)
{ {
PciMemoryRegionList *head = NULL, *cur_item = NULL; PciMemoryRegionList *head = NULL, **tail = &head;
int i; int i;
for (i = 0; i < PCI_NUM_REGIONS; i++) { for (i = 0; i < PCI_NUM_REGIONS; i++) {
const PCIIORegion *r = &dev->io_regions[i]; const PCIIORegion *r = &dev->io_regions[i];
PciMemoryRegionList *region; PciMemoryRegion *region;
if (!r->size) { if (!r->size) {
continue; continue;
} }
region = g_malloc0(sizeof(*region)); region = g_malloc0(sizeof(*region));
region->value = g_malloc0(sizeof(*region->value));
if (r->type & PCI_BASE_ADDRESS_SPACE_IO) { if (r->type & PCI_BASE_ADDRESS_SPACE_IO) {
region->value->type = g_strdup("io"); region->type = g_strdup("io");
} else { } else {
region->value->type = g_strdup("memory"); region->type = g_strdup("memory");
region->value->has_prefetch = true; region->has_prefetch = true;
region->value->prefetch = !!(r->type & PCI_BASE_ADDRESS_MEM_PREFETCH); region->prefetch = !!(r->type & PCI_BASE_ADDRESS_MEM_PREFETCH);
region->value->has_mem_type_64 = true; region->has_mem_type_64 = true;
region->value->mem_type_64 = !!(r->type & PCI_BASE_ADDRESS_MEM_TYPE_64); region->mem_type_64 = !!(r->type & PCI_BASE_ADDRESS_MEM_TYPE_64);
} }
region->value->bar = i; region->bar = i;
region->value->address = r->addr; region->address = r->addr;
region->value->size = r->size; region->size = r->size;
/* XXX: waiting for the qapi to support GSList */ QAPI_LIST_APPEND(tail, region);
if (!cur_item) {
head = cur_item = region;
} else {
cur_item->next = region;
cur_item = region;
}
} }
return head; return head;
@ -1814,23 +1807,14 @@ static PciDeviceInfo *qmp_query_pci_device(PCIDevice *dev, PCIBus *bus,
static PciDeviceInfoList *qmp_query_pci_devices(PCIBus *bus, int bus_num) static PciDeviceInfoList *qmp_query_pci_devices(PCIBus *bus, int bus_num)
{ {
PciDeviceInfoList *info, *head = NULL, *cur_item = NULL; PciDeviceInfoList *head = NULL, **tail = &head;
PCIDevice *dev; PCIDevice *dev;
int devfn; int devfn;
for (devfn = 0; devfn < ARRAY_SIZE(bus->devices); devfn++) { for (devfn = 0; devfn < ARRAY_SIZE(bus->devices); devfn++) {
dev = bus->devices[devfn]; dev = bus->devices[devfn];
if (dev) { if (dev) {
info = g_malloc0(sizeof(*info)); QAPI_LIST_APPEND(tail, qmp_query_pci_device(dev, bus, bus_num));
info->value = qmp_query_pci_device(dev, bus, bus_num);
/* XXX: waiting for the qapi to support GSList */
if (!cur_item) {
head = cur_item = info;
} else {
cur_item->next = info;
cur_item = info;
}
} }
} }
@ -1853,21 +1837,13 @@ static PciInfo *qmp_query_pci_bus(PCIBus *bus, int bus_num)
PciInfoList *qmp_query_pci(Error **errp) PciInfoList *qmp_query_pci(Error **errp)
{ {
PciInfoList *info, *head = NULL, *cur_item = NULL; PciInfoList *head = NULL, **tail = &head;
PCIHostState *host_bridge; PCIHostState *host_bridge;
QLIST_FOREACH(host_bridge, &pci_host_bridges, next) { QLIST_FOREACH(host_bridge, &pci_host_bridges, next) {
info = g_malloc0(sizeof(*info)); QAPI_LIST_APPEND(tail,
info->value = qmp_query_pci_bus(host_bridge->bus, qmp_query_pci_bus(host_bridge->bus,
pci_bus_num(host_bridge->bus)); pci_bus_num(host_bridge->bus)));
/* XXX: waiting for the qapi to support GSList */
if (!cur_item) {
head = cur_item = info;
} else {
cur_item->next = info;
cur_item = info;
}
} }
return head; return head;

20
migration/migration.c
View File

@ -793,29 +793,21 @@ void migrate_send_rp_resume_ack(MigrationIncomingState *mis, uint32_t value)
MigrationCapabilityStatusList *qmp_query_migrate_capabilities(Error **errp) MigrationCapabilityStatusList *qmp_query_migrate_capabilities(Error **errp)
{ {
MigrationCapabilityStatusList *head = NULL; MigrationCapabilityStatusList *head = NULL, **tail = &head;
MigrationCapabilityStatusList *caps; MigrationCapabilityStatus *caps;
MigrationState *s = migrate_get_current(); MigrationState *s = migrate_get_current();
int i; int i;
caps = NULL; /* silence compiler warning */
for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) { for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
#ifndef CONFIG_LIVE_BLOCK_MIGRATION #ifndef CONFIG_LIVE_BLOCK_MIGRATION
if (i == MIGRATION_CAPABILITY_BLOCK) { if (i == MIGRATION_CAPABILITY_BLOCK) {
continue; continue;
} }
#endif #endif
if (head == NULL) { caps = g_malloc0(sizeof(*caps));
head = g_malloc0(sizeof(*caps)); caps->capability = i;
caps = head; caps->state = s->enabled_capabilities[i];
} else { QAPI_LIST_APPEND(tail, caps);
caps->next = g_malloc0(sizeof(*caps));
caps = caps->next;
}
caps->value =
g_malloc(sizeof(*caps->value));
caps->value->capability = i;
caps->value->state = s->enabled_capabilities[i];
} }
return head; return head;

25
monitor/hmp-cmds.c
View File

@ -1706,7 +1706,8 @@ void hmp_closefd(Monitor *mon, const QDict *qdict)
void hmp_sendkey(Monitor *mon, const QDict *qdict) void hmp_sendkey(Monitor *mon, const QDict *qdict)
{ {
const char *keys = qdict_get_str(qdict, "keys"); const char *keys = qdict_get_str(qdict, "keys");
KeyValueList *keylist, *head = NULL, *tmp = NULL; KeyValue *v = NULL;
KeyValueList *head = NULL, **tail = &head;
int has_hold_time = qdict_haskey(qdict, "hold-time"); int has_hold_time = qdict_haskey(qdict, "hold-time");
int hold_time = qdict_get_try_int(qdict, "hold-time", -1); int hold_time = qdict_get_try_int(qdict, "hold-time", -1);
Error *err = NULL; Error *err = NULL;
@ -1723,16 +1724,7 @@ void hmp_sendkey(Monitor *mon, const QDict *qdict)
keyname_len = 4; keyname_len = 4;
} }
keylist = g_malloc0(sizeof(*keylist)); v = g_malloc0(sizeof(*v));
keylist->value = g_malloc0(sizeof(*keylist->value));
if (!head) {
head = keylist;
}
if (tmp) {
tmp->next = keylist;
}
tmp = keylist;
if (strstart(keys, "0x", NULL)) { if (strstart(keys, "0x", NULL)) {
char *endp; char *endp;
@ -1741,16 +1733,18 @@ void hmp_sendkey(Monitor *mon, const QDict *qdict)
if (endp != keys + keyname_len) { if (endp != keys + keyname_len) {
goto err_out; goto err_out;
} }
keylist->value->type = KEY_VALUE_KIND_NUMBER; v->type = KEY_VALUE_KIND_NUMBER;
keylist->value->u.number.data = value; v->u.number.data = value;
} else { } else {
int idx = index_from_key(keys, keyname_len); int idx = index_from_key(keys, keyname_len);
if (idx == Q_KEY_CODE__MAX) { if (idx == Q_KEY_CODE__MAX) {
goto err_out; goto err_out;
} }
keylist->value->type = KEY_VALUE_KIND_QCODE; v->type = KEY_VALUE_KIND_QCODE;
keylist->value->u.qcode.data = idx; v->u.qcode.data = idx;
} }
QAPI_LIST_APPEND(tail, v);
v = NULL;
if (!*separator) { if (!*separator) {
break; break;
@ -1762,6 +1756,7 @@ void hmp_sendkey(Monitor *mon, const QDict *qdict)
hmp_handle_error(mon, err); hmp_handle_error(mon, err);
out: out:
qapi_free_KeyValue(v);
qapi_free_KeyValueList(head); qapi_free_KeyValueList(head);
return; return;

13
net/net.c
View File

@ -1213,10 +1213,9 @@ RxFilterInfoList *qmp_query_rx_filter(bool has_name, const char *name,
Error **errp) Error **errp)
{ {
NetClientState *nc; NetClientState *nc;
RxFilterInfoList *filter_list = NULL, *last_entry = NULL; RxFilterInfoList *filter_list = NULL, **tail = &filter_list;
QTAILQ_FOREACH(nc, &net_clients, next) { QTAILQ_FOREACH(nc, &net_clients, next) {
RxFilterInfoList *entry;
RxFilterInfo *info; RxFilterInfo *info;
if (has_name && strcmp(nc->name, name) != 0) { if (has_name && strcmp(nc->name, name) != 0) {
@ -1241,15 +1240,7 @@ RxFilterInfoList *qmp_query_rx_filter(bool has_name, const char *name,
if (nc->info->query_rx_filter) { if (nc->info->query_rx_filter) {
info = nc->info->query_rx_filter(nc); info = nc->info->query_rx_filter(nc);
entry = g_malloc0(sizeof(*entry)); QAPI_LIST_APPEND(tail, info);
entry->value = info;
if (!filter_list) {
filter_list = entry;
} else {
last_entry->next = entry;
}
last_entry = entry;
} else if (has_name) { } else if (has_name) {
error_setg(errp, "net client(%s) doesn't support" error_setg(errp, "net client(%s) doesn't support"
" rx-filter querying", name); " rx-filter querying", name);

19
qga/commands-posix.c
View File

@ -3138,11 +3138,10 @@ static double ga_get_login_time(struct utmpx *user_info)
GuestUserList *qmp_guest_get_users(Error **errp) GuestUserList *qmp_guest_get_users(Error **errp)
{ {
GHashTable *cache = NULL; GHashTable *cache = NULL;
GuestUserList *head = NULL, *cur_item = NULL; GuestUserList *head = NULL, **tail = &head;
struct utmpx *user_info = NULL; struct utmpx *user_info = NULL;
gpointer value = NULL; gpointer value = NULL;
GuestUser *user = NULL; GuestUser *user = NULL;
GuestUserList *item = NULL;
double login_time = 0; double login_time = 0;
cache = g_hash_table_new(g_str_hash, g_str_equal); cache = g_hash_table_new(g_str_hash, g_str_equal);
@ -3165,19 +3164,13 @@ GuestUserList *qmp_guest_get_users(Error **errp)
continue; continue;
} }
item = g_new0(GuestUserList, 1); user = g_new0(GuestUser, 1);
item->value = g_new0(GuestUser, 1); user->user = g_strdup(user_info->ut_user);
item->value->user = g_strdup(user_info->ut_user); user->login_time = ga_get_login_time(user_info);
item->value->login_time = ga_get_login_time(user_info);
g_hash_table_insert(cache, item->value->user, item->value); g_hash_table_insert(cache, user->user, user);
if (!cur_item) { QAPI_LIST_APPEND(tail, user);
head = cur_item = item;
} else {
cur_item->next = item;
cur_item = item;
}
} }
endutxent(); endutxent();
g_hash_table_destroy(cache); g_hash_table_destroy(cache);

88
qga/commands-win32.c
View File

@ -1624,11 +1624,11 @@ GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
{ {
IP_ADAPTER_ADDRESSES *adptr_addrs, *addr; IP_ADAPTER_ADDRESSES *adptr_addrs, *addr;
IP_ADAPTER_UNICAST_ADDRESS *ip_addr = NULL; IP_ADAPTER_UNICAST_ADDRESS *ip_addr = NULL;
GuestNetworkInterfaceList *head = NULL, *cur_item = NULL; GuestNetworkInterfaceList *head = NULL, **tail = &head;
GuestIpAddressList *head_addr, *cur_addr; GuestIpAddressList *head_addr, **tail_addr;
GuestNetworkInterfaceList *info; GuestNetworkInterface *info;
GuestNetworkInterfaceStat *interface_stat = NULL; GuestNetworkInterfaceStat *interface_stat = NULL;
GuestIpAddressList *address_item = NULL; GuestIpAddress *address_item = NULL;
unsigned char *mac_addr; unsigned char *mac_addr;
char *addr_str; char *addr_str;
WORD wsa_version; WORD wsa_version;
@ -1651,30 +1651,24 @@ GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
for (addr = adptr_addrs; addr; addr = addr->Next) { for (addr = adptr_addrs; addr; addr = addr->Next) {
info = g_malloc0(sizeof(*info)); info = g_malloc0(sizeof(*info));
if (cur_item == NULL) { QAPI_LIST_APPEND(tail, info);
head = cur_item = info;
} else {
cur_item->next = info;
cur_item = info;
}
info->value = g_malloc0(sizeof(*info->value)); info->name = guest_wctomb_dup(addr->FriendlyName);
info->value->name = guest_wctomb_dup(addr->FriendlyName);
if (addr->PhysicalAddressLength != 0) { if (addr->PhysicalAddressLength != 0) {
mac_addr = addr->PhysicalAddress; mac_addr = addr->PhysicalAddress;
info->value->hardware_address = info->hardware_address =
g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x", g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x",
(int) mac_addr[0], (int) mac_addr[1], (int) mac_addr[0], (int) mac_addr[1],
(int) mac_addr[2], (int) mac_addr[3], (int) mac_addr[2], (int) mac_addr[3],
(int) mac_addr[4], (int) mac_addr[5]); (int) mac_addr[4], (int) mac_addr[5]);
info->value->has_hardware_address = true; info->has_hardware_address = true;
} }
head_addr = NULL; head_addr = NULL;
cur_addr = NULL; tail_addr = &head_addr;
for (ip_addr = addr->FirstUnicastAddress; for (ip_addr = addr->FirstUnicastAddress;
ip_addr; ip_addr;
ip_addr = ip_addr->Next) { ip_addr = ip_addr->Next) {
@ -1685,37 +1679,29 @@ GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
address_item = g_malloc0(sizeof(*address_item)); address_item = g_malloc0(sizeof(*address_item));
if (!cur_addr) { QAPI_LIST_APPEND(tail_addr, address_item);
head_addr = cur_addr = address_item;
} else {
cur_addr->next = address_item;
cur_addr = address_item;
}
address_item->value = g_malloc0(sizeof(*address_item->value)); address_item->ip_address = addr_str;
address_item->value->ip_address = addr_str; address_item->prefix = guest_ip_prefix(ip_addr);
address_item->value->prefix = guest_ip_prefix(ip_addr);
if (ip_addr->Address.lpSockaddr->sa_family == AF_INET) { if (ip_addr->Address.lpSockaddr->sa_family == AF_INET) {
address_item->value->ip_address_type = address_item->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4;
GUEST_IP_ADDRESS_TYPE_IPV4;
} else if (ip_addr->Address.lpSockaddr->sa_family == AF_INET6) { } else if (ip_addr->Address.lpSockaddr->sa_family == AF_INET6) {
address_item->value->ip_address_type = address_item->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6;
GUEST_IP_ADDRESS_TYPE_IPV6;
} }
} }
if (head_addr) { if (head_addr) {
info->value->has_ip_addresses = true; info->has_ip_addresses = true;
info->value->ip_addresses = head_addr; info->ip_addresses = head_addr;
} }
if (!info->value->has_statistics) { if (!info->has_statistics) {
interface_stat = g_malloc0(sizeof(*interface_stat)); interface_stat = g_malloc0(sizeof(*interface_stat));
if (guest_get_network_stats(addr->AdapterName, if (guest_get_network_stats(addr->AdapterName,
interface_stat) == -1) { interface_stat) == -1) {
info->value->has_statistics = false; info->has_statistics = false;
g_free(interface_stat); g_free(interface_stat);
} else { } else {
info->value->statistics = interface_stat; info->statistics = interface_stat;
info->value->has_statistics = true; info->has_statistics = true;
} }
} }
} }
@ -2082,12 +2068,11 @@ GuestUserList *qmp_guest_get_users(Error **errp)
#define QGA_NANOSECONDS 10000000 #define QGA_NANOSECONDS 10000000
GHashTable *cache = NULL; GHashTable *cache = NULL;
GuestUserList *head = NULL, *cur_item = NULL; GuestUserList *head = NULL, **tail = &head;
DWORD buffer_size = 0, count = 0, i = 0; DWORD buffer_size = 0, count = 0, i = 0;
GA_WTSINFOA *info = NULL; GA_WTSINFOA *info = NULL;
WTS_SESSION_INFOA *entries = NULL; WTS_SESSION_INFOA *entries = NULL;
GuestUserList *item = NULL;
GuestUser *user = NULL; GuestUser *user = NULL;
gpointer value = NULL; gpointer value = NULL;
INT64 login = 0; INT64 login = 0;
@ -2123,23 +2108,17 @@ GuestUserList *qmp_guest_get_users(Error **errp)
user->login_time = login_time; user->login_time = login_time;
} }
} else { } else {
item = g_new0(GuestUserList, 1); user = g_new0(GuestUser, 1);
item->value = g_new0(GuestUser, 1);
item->value->user = g_strdup(info->UserName); user->user = g_strdup(info->UserName);
item->value->domain = g_strdup(info->Domain); user->domain = g_strdup(info->Domain);
item->value->has_domain = true; user->has_domain = true;
item->value->login_time = login_time; user->login_time = login_time;
g_hash_table_add(cache, item->value->user); g_hash_table_add(cache, user->user);
if (!cur_item) { QAPI_LIST_APPEND(tail, user);
head = cur_item = item;
} else {
cur_item->next = item;
cur_item = item;
}
} }
} }
WTSFreeMemory(info); WTSFreeMemory(info);
@ -2424,7 +2403,7 @@ static GStrv ga_get_hardware_ids(DEVINST devInstance)
GuestDeviceInfoList *qmp_guest_get_devices(Error **errp) GuestDeviceInfoList *qmp_guest_get_devices(Error **errp)
{ {
GuestDeviceInfoList *head = NULL, *cur_item = NULL, *item = NULL; GuestDeviceInfoList *head = NULL, **tail = &head;
HDEVINFO dev_info = INVALID_HANDLE_VALUE; HDEVINFO dev_info = INVALID_HANDLE_VALUE;
SP_DEVINFO_DATA dev_info_data; SP_DEVINFO_DATA dev_info_data;
int i, j; int i, j;
@ -2522,14 +2501,7 @@ GuestDeviceInfoList *qmp_guest_get_devices(Error **errp)
slog("driver: %s\ndriver version: %" PRId64 ",%s\n", slog("driver: %s\ndriver version: %" PRId64 ",%s\n",
device->driver_name, device->driver_date, device->driver_name, device->driver_date,
device->driver_version); device->driver_version);
item = g_new0(GuestDeviceInfoList, 1); QAPI_LIST_APPEND(tail, g_steal_pointer(&device));
item->value = g_steal_pointer(&device);
if (!cur_item) {
head = cur_item = item;
} else {
cur_item->next = item;
cur_item = item;
}
} }
if (dev_info != INVALID_HANDLE_VALUE) { if (dev_info != INVALID_HANDLE_VALUE) {

38
softmmu/tpm.c
View File

@ -196,22 +196,14 @@ int tpm_config_parse(QemuOptsList *opts_list, const char *optarg)
TPMInfoList *qmp_query_tpm(Error **errp) TPMInfoList *qmp_query_tpm(Error **errp)
{ {
TPMBackend *drv; TPMBackend *drv;
TPMInfoList *info, *head = NULL, *cur_item = NULL; TPMInfoList *head = NULL, **tail = &head;
QLIST_FOREACH(drv, &tpm_backends, list) { QLIST_FOREACH(drv, &tpm_backends, list) {
if (!drv->tpmif) { if (!drv->tpmif) {
continue; continue;
} }
info = g_new0(TPMInfoList, 1); QAPI_LIST_APPEND(tail, tpm_backend_query_tpm(drv));
info->value = tpm_backend_query_tpm(drv);
if (!cur_item) {
head = cur_item = info;
} else {
cur_item->next = info;
cur_item = info;
}
} }
return head; return head;
@ -220,44 +212,26 @@ TPMInfoList *qmp_query_tpm(Error **errp)
TpmTypeList *qmp_query_tpm_types(Error **errp) TpmTypeList *qmp_query_tpm_types(Error **errp)
{ {
unsigned int i = 0; unsigned int i = 0;
TpmTypeList *head = NULL, *prev = NULL, *cur_item; TpmTypeList *head = NULL, **tail = &head;
for (i = 0; i < TPM_TYPE__MAX; i++) { for (i = 0; i < TPM_TYPE__MAX; i++) {
if (!tpm_be_find_by_type(i)) { if (!tpm_be_find_by_type(i)) {
continue; continue;
} }
cur_item = g_new0(TpmTypeList, 1); QAPI_LIST_APPEND(tail, i);
cur_item->value = i;
if (prev) {
prev->next = cur_item;
}
if (!head) {
head = cur_item;
}
prev = cur_item;
} }
return head; return head;
} }
TpmModelList *qmp_query_tpm_models(Error **errp) TpmModelList *qmp_query_tpm_models(Error **errp)
{ {
TpmModelList *head = NULL, *prev = NULL, *cur_item; TpmModelList *head = NULL, **tail = &head;
GSList *e, *l = object_class_get_list(TYPE_TPM_IF, false); GSList *e, *l = object_class_get_list(TYPE_TPM_IF, false);
for (e = l; e; e = e->next) { for (e = l; e; e = e->next) {
TPMIfClass *c = TPM_IF_CLASS(e->data); TPMIfClass *c = TPM_IF_CLASS(e->data);
cur_item = g_new0(TpmModelList, 1); QAPI_LIST_APPEND(tail, c->model);
cur_item->value = c->model;
if (prev) {
prev->next = cur_item;
}
if (!head) {
head = cur_item;
}
prev = cur_item;
} }
g_slist_free(l); g_slist_free(l);

27
ui/spice-core.c
View File

@ -354,11 +354,11 @@ static const char *wan_compression_names[] = {
static SpiceChannelList *qmp_query_spice_channels(void) static SpiceChannelList *qmp_query_spice_channels(void)
{ {
SpiceChannelList *cur_item = NULL, *head = NULL; SpiceChannelList *head = NULL, **tail = &head;
ChannelList *item; ChannelList *item;
QTAILQ_FOREACH(item, &channel_list, link) { QTAILQ_FOREACH(item, &channel_list, link) {
SpiceChannelList *chan; SpiceChannel *chan;
char host[NI_MAXHOST], port[NI_MAXSERV]; char host[NI_MAXHOST], port[NI_MAXSERV];
struct sockaddr *paddr; struct sockaddr *paddr;
socklen_t plen; socklen_t plen;
@ -366,29 +366,22 @@ static SpiceChannelList *qmp_query_spice_channels(void)
assert(item->info->flags & SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT); assert(item->info->flags & SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT);
chan = g_malloc0(sizeof(*chan)); chan = g_malloc0(sizeof(*chan));
chan->value = g_malloc0(sizeof(*chan->value));
paddr = (struct sockaddr *)&item->info->paddr_ext; paddr = (struct sockaddr *)&item->info->paddr_ext;
plen = item->info->plen_ext; plen = item->info->plen_ext;
getnameinfo(paddr, plen, getnameinfo(paddr, plen,
host, sizeof(host), port, sizeof(port), host, sizeof(host), port, sizeof(port),
NI_NUMERICHOST | NI_NUMERICSERV); NI_NUMERICHOST | NI_NUMERICSERV);
chan->value->host = g_strdup(host); chan->host = g_strdup(host);
chan->value->port = g_strdup(port); chan->port = g_strdup(port);
chan->value->family = inet_netfamily(paddr->sa_family); chan->family = inet_netfamily(paddr->sa_family);
chan->value->connection_id = item->info->connection_id; chan->connection_id = item->info->connection_id;
chan->value->channel_type = item->info->type; chan->channel_type = item->info->type;
chan->value->channel_id = item->info->id; chan->channel_id = item->info->id;
chan->value->tls = item->info->flags & SPICE_CHANNEL_EVENT_FLAG_TLS; chan->tls = item->info->flags & SPICE_CHANNEL_EVENT_FLAG_TLS;
/* XXX: waiting for the qapi to support GSList */ QAPI_LIST_APPEND(tail, chan);
if (!cur_item) {
head = cur_item = chan;
} else {
cur_item->next = chan;
cur_item = chan;
}
} }
return head; return head;