openkylin
/
qemu
mirror of https://gitee.com/openkylin/qemu.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

qemu/queue.h: simplify reverse access to QTAILQ 

The new definition of QTAILQ does not require passing the headname,
remove it.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Paolo Bonzini 2018-12-06 13:10:34 +01:00
parent 7274f01bb8
commit eae3eb3e18
27 changed files with 49 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cpus-common.c
View File

@ -99,7 +99,7 @@ void cpu_list_remove(CPUState *cpu)
return; return;
} }
assert(!(cpu_index_auto_assigned && cpu != QTAILQ_LAST(&cpus, CPUTailQ))); assert(!(cpu_index_auto_assigned && cpu != QTAILQ_LAST(&cpus)));
QTAILQ_REMOVE_RCU(&cpus, cpu, node); QTAILQ_REMOVE_RCU(&cpus, cpu, node);
cpu->cpu_index = UNASSIGNED_CPU_INDEX; cpu->cpu_index = UNASSIGNED_CPU_INDEX;

2
dump.c
View File

@ -1557,7 +1557,7 @@ static void get_max_mapnr(DumpState *s)
{ {
GuestPhysBlock *last_block; GuestPhysBlock *last_block;
last_block = QTAILQ_LAST(&s->guest_phys_blocks.head, GuestPhysBlockHead); last_block = QTAILQ_LAST(&s->guest_phys_blocks.head);
s->max_mapnr = dump_paddr_to_pfn(s, last_block->target_end); s->max_mapnr = dump_paddr_to_pfn(s, last_block->target_end);
} }

4
hw/core/qdev.c
View File

@ -158,7 +158,7 @@ DeviceState *qdev_try_create(BusState *bus, const char *type)
return dev; return dev;
} }
static QTAILQ_HEAD(device_listeners, DeviceListener) device_listeners static QTAILQ_HEAD(, DeviceListener) device_listeners
= QTAILQ_HEAD_INITIALIZER(device_listeners); = QTAILQ_HEAD_INITIALIZER(device_listeners);
enum ListenerDirection { Forward, Reverse }; enum ListenerDirection { Forward, Reverse };
@ -177,7 +177,7 @@ enum ListenerDirection { Forward, Reverse };
break; \ break; \
case Reverse: \ case Reverse: \
QTAILQ_FOREACH_REVERSE(_listener, &device_listeners, \ QTAILQ_FOREACH_REVERSE(_listener, &device_listeners, \
device_listeners, link) { \ link) { \
if (_listener->_callback) { \ if (_listener->_callback) { \
_listener->_callback(_listener, ##_args); \ _listener->_callback(_listener, ##_args); \
} \ } \

2
hw/scsi/scsi-bus.c
View File

@ -1554,7 +1554,7 @@ SCSIDevice *scsi_device_find(SCSIBus *bus, int channel, int id, int lun)
BusChild *kid; BusChild *kid;
SCSIDevice *target_dev = NULL; SCSIDevice *target_dev = NULL;
QTAILQ_FOREACH_REVERSE(kid, &bus->qbus.children, ChildrenHead, sibling) { QTAILQ_FOREACH_REVERSE(kid, &bus->qbus.children, sibling) {
DeviceState *qdev = kid->child; DeviceState *qdev = kid->child;
SCSIDevice *dev = SCSI_DEVICE(qdev); SCSIDevice *dev = SCSI_DEVICE(qdev);

2
hw/usb/combined-packet.c
View File

@ -64,7 +64,7 @@ void usb_combined_input_packet_complete(USBDevice *dev, USBPacket *p)
status = combined->first->status; status = combined->first->status;
actual_length = combined->first->actual_length; actual_length = combined->first->actual_length;
short_not_ok = QTAILQ_LAST(&combined->packets, packets_head)->short_not_ok; short_not_ok = QTAILQ_LAST(&combined->packets)->short_not_ok;
QTAILQ_FOREACH_SAFE(p, &combined->packets, combined_entry, next) { QTAILQ_FOREACH_SAFE(p, &combined->packets, combined_entry, next) {
if (!done) { if (!done) {

4
hw/usb/dev-mtp.c
View File

@ -191,7 +191,7 @@ struct MTPState {
#ifdef CONFIG_INOTIFY1 #ifdef CONFIG_INOTIFY1
/* inotify descriptor */ /* inotify descriptor */
int inotifyfd; int inotifyfd;
QTAILQ_HEAD(events, MTPMonEntry) events; QTAILQ_HEAD(, MTPMonEntry) events;
#endif #endif
/* Responder is expecting a write operation */ /* Responder is expecting a write operation */
bool write_pending; bool write_pending;
@ -1989,7 +1989,7 @@ static void usb_mtp_handle_data(USBDevice *dev, USBPacket *p)
case EP_EVENT: case EP_EVENT:
#ifdef CONFIG_INOTIFY1 #ifdef CONFIG_INOTIFY1
if (!QTAILQ_EMPTY(&s->events)) { if (!QTAILQ_EMPTY(&s->events)) {
struct MTPMonEntry *e = QTAILQ_LAST(&s->events, events); struct MTPMonEntry *e = QTAILQ_LAST(&s->events);
uint32_t handle; uint32_t handle;
int len = sizeof(container) + sizeof(uint32_t); int len = sizeof(container) + sizeof(uint32_t);

2
hw/usb/hcd-ehci.c
View File

@ -1823,7 +1823,7 @@ static int ehci_state_fetchqtd(EHCIQueue *q)
break; break;
case EHCI_ASYNC_INFLIGHT: case EHCI_ASYNC_INFLIGHT:
/* Check if the guest has added new tds to the queue */ /* Check if the guest has added new tds to the queue */
again = ehci_fill_queue(QTAILQ_LAST(&q->packets, pkts_head)); again = ehci_fill_queue(QTAILQ_LAST(&q->packets));
/* Unfinished async handled packet, go horizontal */ /* Unfinished async handled packet, go horizontal */
ehci_set_state(q->ehci, q->async, EST_HORIZONTALQH); ehci_set_state(q->ehci, q->async, EST_HORIZONTALQH);
break; break;

2
hw/usb/hcd-ehci.h
View File

@ -247,7 +247,7 @@ struct EHCIQueue {
uint32_t qtdaddr; /* address QTD read from */ uint32_t qtdaddr; /* address QTD read from */
int last_pid; /* pid of last packet executed */ int last_pid; /* pid of last packet executed */
USBDevice *dev; USBDevice *dev;
QTAILQ_HEAD(pkts_head, EHCIPacket) packets; QTAILQ_HEAD(, EHCIPacket) packets;
}; };
typedef QTAILQ_HEAD(EHCIQueueHead, EHCIQueue) EHCIQueueHead; typedef QTAILQ_HEAD(EHCIQueueHead, EHCIQueue) EHCIQueueHead;

4
hw/usb/hcd-uhci.c
View File

@ -99,7 +99,7 @@ struct UHCIQueue {
UHCIState *uhci; UHCIState *uhci;
USBEndpoint *ep; USBEndpoint *ep;
QTAILQ_ENTRY(UHCIQueue) next; QTAILQ_ENTRY(UHCIQueue) next;
QTAILQ_HEAD(asyncs_head, UHCIAsync) asyncs; QTAILQ_HEAD(, UHCIAsync) asyncs;
int8_t valid; int8_t valid;
}; };
@ -837,7 +837,7 @@ static int uhci_handle_td(UHCIState *s, UHCIQueue *q, uint32_t qh_addr,
} }
if (!async->done) { if (!async->done) {
UHCI_TD last_td; UHCI_TD last_td;
UHCIAsync *last = QTAILQ_LAST(&async->queue->asyncs, asyncs_head); UHCIAsync *last = QTAILQ_LAST(&async->queue->asyncs);
/* /*
* While we are waiting for the current td to complete, the guest * While we are waiting for the current td to complete, the guest
* may have added more tds to the queue. Note we re-read the td * may have added more tds to the queue. Note we re-read the td

2
include/exec/memory.h
View File

@ -445,7 +445,7 @@ struct AddressSpace {
int ioeventfd_nb; int ioeventfd_nb;
struct MemoryRegionIoeventfd *ioeventfds; struct MemoryRegionIoeventfd *ioeventfds;
QTAILQ_HEAD(memory_listeners_as, MemoryListener) listeners; QTAILQ_HEAD(, MemoryListener) listeners;
QTAILQ_ENTRY(AddressSpace) address_spaces_link; QTAILQ_ENTRY(AddressSpace) address_spaces_link;
}; };

2
include/hw/qdev-core.h
View File

@ -206,7 +206,7 @@ struct BusState {
HotplugHandler *hotplug_handler; HotplugHandler *hotplug_handler;
int max_index; int max_index;
bool realized; bool realized;
QTAILQ_HEAD(ChildrenHead, BusChild) children; QTAILQ_HEAD(, BusChild) children;
QLIST_ENTRY(BusState) sibling; QLIST_ENTRY(BusState) sibling;
}; };

2
include/hw/usb.h
View File

@ -408,7 +408,7 @@ struct USBPacket {
struct USBCombinedPacket { struct USBCombinedPacket {
USBPacket *first; USBPacket *first;
QTAILQ_HEAD(packets_head, USBPacket) packets; QTAILQ_HEAD(, USBPacket) packets;
QEMUIOVector iov; QEMUIOVector iov;
}; };

2
include/net/net.h
View File

@ -97,7 +97,7 @@ struct NetClientState {
unsigned rxfilter_notify_enabled:1; unsigned rxfilter_notify_enabled:1;
int vring_enable; int vring_enable;
int vnet_hdr_len; int vnet_hdr_len;
QTAILQ_HEAD(NetFilterHead, NetFilterState) filters; QTAILQ_HEAD(, NetFilterState) filters;
}; };
typedef struct NICState { typedef struct NICState {

2
include/qemu/option_int.h
View File

@ -47,7 +47,7 @@ struct QemuOpts {
char *id; char *id;
QemuOptsList *list; QemuOptsList *list;
Location loc; Location loc;
QTAILQ_HEAD(QemuOptHead, QemuOpt) head; QTAILQ_HEAD(, QemuOpt) head;
QTAILQ_ENTRY(QemuOpts) next; QTAILQ_ENTRY(QemuOpts) next;
}; };

16
include/qemu/queue.h
View File

@ -432,14 +432,14 @@ union { \
(var) && ((next_var) = ((var)->field.tqe_next), 1); \ (var) && ((next_var) = ((var)->field.tqe_next), 1); \
(var) = (next_var)) (var) = (next_var))
#define QTAILQ_FOREACH_REVERSE(var, head, headname, field) \ #define QTAILQ_FOREACH_REVERSE(var, head, field) \
for ((var) = QTAILQ_LAST(head, headname); \ for ((var) = QTAILQ_LAST(head); \
(var); \ (var); \
(var) = QTAILQ_PREV(var, headname, field)) (var) = QTAILQ_PREV(var, field))
#define QTAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, prev_var) \ #define QTAILQ_FOREACH_REVERSE_SAFE(var, head, field, prev_var) \
for ((var) = QTAILQ_LAST(head, headname); \ for ((var) = QTAILQ_LAST(head); \
(var) && ((prev_var) = QTAILQ_PREV(var, headname, field)); \ (var) && ((prev_var) = QTAILQ_PREV(var, field)); \
(var) = (prev_var)) (var) = (prev_var))
/* /*
@ -452,9 +452,9 @@ union { \
#define QTAILQ_LINK_PREV(link) \ #define QTAILQ_LINK_PREV(link) \
((link).tql_prev->tql_prev->tql_next) ((link).tql_prev->tql_prev->tql_next)
#define QTAILQ_LAST(head, headname) \ #define QTAILQ_LAST(head) \
((typeof((head)->tqh_first)) QTAILQ_LINK_PREV((head)->tqh_circ)) ((typeof((head)->tqh_first)) QTAILQ_LINK_PREV((head)->tqh_circ))
#define QTAILQ_PREV(elm, headname, field) \ #define QTAILQ_PREV(elm, field) \
((typeof((elm)->field.tqe_next)) QTAILQ_LINK_PREV((elm)->field.tqe_circ)) ((typeof((elm)->field.tqe_next)) QTAILQ_LINK_PREV((elm)->field.tqe_circ))
#define field_at_offset(base, offset, type) \ #define field_at_offset(base, offset, type) \

2
include/sysemu/memory_mapping.h
View File

@ -36,7 +36,7 @@ typedef struct GuestPhysBlock {
/* point-in-time snapshot of guest-visible physical mappings */ /* point-in-time snapshot of guest-visible physical mappings */
typedef struct GuestPhysBlockList { typedef struct GuestPhysBlockList {
unsigned num; unsigned num;
QTAILQ_HEAD(GuestPhysBlockHead, GuestPhysBlock) head; QTAILQ_HEAD(, GuestPhysBlock) head;
} GuestPhysBlockList; } GuestPhysBlockList;
/* The physical and virtual address in the memory mapping are contiguous. */ /* The physical and virtual address in the memory mapping are contiguous. */

17
memory.c
View File

@ -39,7 +39,7 @@ static bool memory_region_update_pending;
static bool ioeventfd_update_pending; static bool ioeventfd_update_pending;
static bool global_dirty_log = false; static bool global_dirty_log = false;
static QTAILQ_HEAD(memory_listeners, MemoryListener) memory_listeners static QTAILQ_HEAD(, MemoryListener) memory_listeners
= QTAILQ_HEAD_INITIALIZER(memory_listeners); = QTAILQ_HEAD_INITIALIZER(memory_listeners);
static QTAILQ_HEAD(, AddressSpace) address_spaces static QTAILQ_HEAD(, AddressSpace) address_spaces
@ -113,8 +113,7 @@ enum ListenerDirection { Forward, Reverse };
} \ } \
break; \ break; \
case Reverse: \ case Reverse: \
QTAILQ_FOREACH_REVERSE(_listener, &memory_listeners, \ QTAILQ_FOREACH_REVERSE(_listener, &memory_listeners, link) { \
memory_listeners, link) { \
if (_listener->_callback) { \ if (_listener->_callback) { \
_listener->_callback(_listener, ##_args); \ _listener->_callback(_listener, ##_args); \
} \ } \
@ -128,19 +127,17 @@ enum ListenerDirection { Forward, Reverse };
#define MEMORY_LISTENER_CALL(_as, _callback, _direction, _section, _args...) \ #define MEMORY_LISTENER_CALL(_as, _callback, _direction, _section, _args...) \
do { \ do { \
MemoryListener *_listener; \ MemoryListener *_listener; \
struct memory_listeners_as *list = &(_as)->listeners; \
\ \
switch (_direction) { \ switch (_direction) { \
case Forward: \ case Forward: \
QTAILQ_FOREACH(_listener, list, link_as) { \ QTAILQ_FOREACH(_listener, &(_as)->listeners, link_as) { \
if (_listener->_callback) { \ if (_listener->_callback) { \
_listener->_callback(_listener, _section, ##_args); \ _listener->_callback(_listener, _section, ##_args); \
} \ } \
} \ } \
break; \ break; \
case Reverse: \ case Reverse: \
QTAILQ_FOREACH_REVERSE(_listener, list, memory_listeners_as, \ QTAILQ_FOREACH_REVERSE(_listener, &(_as)->listeners, link_as) { \
link_as) { \
if (_listener->_callback) { \ if (_listener->_callback) { \
_listener->_callback(_listener, _section, ##_args); \ _listener->_callback(_listener, _section, ##_args); \
} \ } \
@ -2691,8 +2688,7 @@ void memory_listener_register(MemoryListener *listener, AddressSpace *as)
listener->address_space = as; listener->address_space = as;
if (QTAILQ_EMPTY(&memory_listeners) if (QTAILQ_EMPTY(&memory_listeners)
|| listener->priority >= QTAILQ_LAST(&memory_listeners, || listener->priority >= QTAILQ_LAST(&memory_listeners)->priority) {
memory_listeners)->priority) {
QTAILQ_INSERT_TAIL(&memory_listeners, listener, link); QTAILQ_INSERT_TAIL(&memory_listeners, listener, link);
} else { } else {
QTAILQ_FOREACH(other, &memory_listeners, link) { QTAILQ_FOREACH(other, &memory_listeners, link) {
@ -2704,8 +2700,7 @@ void memory_listener_register(MemoryListener *listener, AddressSpace *as)
} }
if (QTAILQ_EMPTY(&as->listeners) if (QTAILQ_EMPTY(&as->listeners)
|| listener->priority >= QTAILQ_LAST(&as->listeners, || listener->priority >= QTAILQ_LAST(&as->listeners)->priority) {
memory_listeners)->priority) {
QTAILQ_INSERT_TAIL(&as->listeners, listener, link_as); QTAILQ_INSERT_TAIL(&as->listeners, listener, link_as);
} else { } else {
QTAILQ_FOREACH(other, &as->listeners, link_as) { QTAILQ_FOREACH(other, &as->listeners, link_as) {

2
memory_mapping.c
View File

@ -223,7 +223,7 @@ static void guest_phys_blocks_region_add(MemoryListener *listener,
if (!QTAILQ_EMPTY(&g->list->head)) { if (!QTAILQ_EMPTY(&g->list->head)) {
hwaddr predecessor_size; hwaddr predecessor_size;
predecessor = QTAILQ_LAST(&g->list->head, GuestPhysBlockHead); predecessor = QTAILQ_LAST(&g->list->head);
predecessor_size = predecessor->target_end - predecessor->target_start; predecessor_size = predecessor->target_end - predecessor->target_start;
/* the memory API guarantees monotonically increasing traversal */ /* the memory API guarantees monotonically increasing traversal */

2
net/filter.c
View File

@ -55,7 +55,7 @@ static NetFilterState *netfilter_next(NetFilterState *nf,
next = QTAILQ_NEXT(nf, next); next = QTAILQ_NEXT(nf, next);
} else { } else {
/* reverse order */ /* reverse order */
next = QTAILQ_PREV(nf, NetFilterHead, next); next = QTAILQ_PREV(nf, next);
} }
return next; return next;

2
net/net.c
View File

@ -563,7 +563,7 @@ static ssize_t filter_receive_iov(NetClientState *nc,
} }
} }
} else { } else {
QTAILQ_FOREACH_REVERSE(nf, &nc->filters, NetFilterHead, next) { QTAILQ_FOREACH_REVERSE(nf, &nc->filters, next) {
ret = qemu_netfilter_receive(nf, direction, sender, flags, iov, ret = qemu_netfilter_receive(nf, direction, sender, flags, iov,
iovcnt, sent_cb); iovcnt, sent_cb);
if (ret) { if (ret) {

2
qga/commands-posix.c
View File

@ -1291,7 +1291,7 @@ int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints,
/* cannot risk guest agent blocking itself on a write in this state */ /* cannot risk guest agent blocking itself on a write in this state */
ga_set_frozen(ga_state); ga_set_frozen(ga_state);
QTAILQ_FOREACH_REVERSE(mount, &mounts, FsMountList, next) { QTAILQ_FOREACH_REVERSE(mount, &mounts, next) {
/* To issue fsfreeze in the reverse order of mounts, check if the /* To issue fsfreeze in the reverse order of mounts, check if the
* mount is listed in the list here */ * mount is listed in the list here */
if (has_mountpoints) { if (has_mountpoints) {

4
tcg/tcg.c
View File

@ -2319,7 +2319,7 @@ static void reachable_code_pass(TCGContext *s)
* wait until the dead code in between them was removed. * wait until the dead code in between them was removed.
*/ */
if (label->refs == 1) { if (label->refs == 1) {
TCGOp *op_prev = QTAILQ_PREV(op, TCGOpHead, link); TCGOp *op_prev = QTAILQ_PREV(op, link);
if (op_prev->opc == INDEX_op_br && if (op_prev->opc == INDEX_op_br &&
label == arg_label(op_prev->args[0])) { label == arg_label(op_prev->args[0])) {
tcg_op_remove(s, op_prev); tcg_op_remove(s, op_prev);
@ -2481,7 +2481,7 @@ static void liveness_pass_1(TCGContext *s)
/* ??? Should be redundant with the exit_tb that ends the TB. */ /* ??? Should be redundant with the exit_tb that ends the TB. */
la_func_end(s, nb_globals, nb_temps); la_func_end(s, nb_globals, nb_temps);
QTAILQ_FOREACH_REVERSE_SAFE(op, &s->ops, TCGOpHead, link, op_prev) { QTAILQ_FOREACH_REVERSE_SAFE(op, &s->ops, link, op_prev) {
int nb_iargs, nb_oargs; int nb_iargs, nb_oargs;
TCGOpcode opc_new, opc_new2; TCGOpcode opc_new, opc_new2;
bool have_opc_new2; bool have_opc_new2;

4
tcg/tcg.h
View File

@ -719,7 +719,7 @@ struct TCGContext {
TCGTempSet free_temps[TCG_TYPE_COUNT * 2]; TCGTempSet free_temps[TCG_TYPE_COUNT * 2];
TCGTemp temps[TCG_MAX_TEMPS]; /* globals first, temps after */ TCGTemp temps[TCG_MAX_TEMPS]; /* globals first, temps after */
QTAILQ_HEAD(TCGOpHead, TCGOp) ops, free_ops; QTAILQ_HEAD(, TCGOp) ops, free_ops;
/* Tells which temporary holds a given register. /* Tells which temporary holds a given register.
It does not take into account fixed registers */ It does not take into account fixed registers */
@ -847,7 +847,7 @@ static inline void tcg_set_insn_start_param(TCGOp *op, int arg, target_ulong v)
/* The last op that was emitted. */ /* The last op that was emitted. */
static inline TCGOp *tcg_last_op(void) static inline TCGOp *tcg_last_op(void)
{ {
return QTAILQ_LAST(&tcg_ctx->ops, TCGOpHead); return QTAILQ_LAST(&tcg_ctx->ops);
} }
/* Test for whether to terminate the TB for using too many opcodes. */ /* Test for whether to terminate the TB for using too many opcodes. */

2
tests/libqos/malloc.c
View File

@ -104,7 +104,7 @@ static void mlist_coalesce(MemList *head, MemBlock *node)
do { do {
merge = 0; merge = 0;
left = QTAILQ_PREV(node, MemList, MLIST_ENTNAME); left = QTAILQ_PREV(node, MLIST_ENTNAME);
right = QTAILQ_NEXT(node, MLIST_ENTNAME); right = QTAILQ_NEXT(node, MLIST_ENTNAME);
/* clowns to the left of me */ /* clowns to the left of me */

8
tests/test-vmstate.c
View File

@ -630,7 +630,7 @@ struct TestQtailqElement {
typedef struct TestQtailq { typedef struct TestQtailq {
int16_t i16; int16_t i16;
QTAILQ_HEAD(TestQtailqHead, TestQtailqElement) q; QTAILQ_HEAD(, TestQtailqElement) q;
int32_t i32; int32_t i32;
} TestQtailq; } TestQtailq;
@ -735,9 +735,9 @@ static void test_load_q(void)
g_assert_cmpint(eof, ==, QEMU_VM_EOF); g_assert_cmpint(eof, ==, QEMU_VM_EOF);
TestQtailqElement *qele_from = QTAILQ_FIRST(&obj_q.q); TestQtailqElement *qele_from = QTAILQ_FIRST(&obj_q.q);
TestQtailqElement *qlast_from = QTAILQ_LAST(&obj_q.q, TestQtailqHead); TestQtailqElement *qlast_from = QTAILQ_LAST(&obj_q.q);
TestQtailqElement *qele_to = QTAILQ_FIRST(&tgt.q); TestQtailqElement *qele_to = QTAILQ_FIRST(&tgt.q);
TestQtailqElement *qlast_to = QTAILQ_LAST(&tgt.q, TestQtailqHead); TestQtailqElement *qlast_to = QTAILQ_LAST(&tgt.q);
while (1) { while (1) {
g_assert_cmpint(qele_to->b, ==, qele_from->b); g_assert_cmpint(qele_to->b, ==, qele_from->b);
@ -755,7 +755,7 @@ static void test_load_q(void)
/* clean up */ /* clean up */
TestQtailqElement *qele; TestQtailqElement *qele;
while (!QTAILQ_EMPTY(&tgt.q)) { while (!QTAILQ_EMPTY(&tgt.q)) {
qele = QTAILQ_LAST(&tgt.q, TestQtailqHead); qele = QTAILQ_LAST(&tgt.q);
QTAILQ_REMOVE(&tgt.q, qele, next); QTAILQ_REMOVE(&tgt.q, qele, next);
free(qele); free(qele);
qele = NULL; qele = NULL;

4
ui/console.c
View File

@ -182,7 +182,7 @@ struct DisplayState {
static DisplayState *display_state; static DisplayState *display_state;
static QemuConsole *active_console; static QemuConsole *active_console;
static QTAILQ_HEAD(consoles_head, QemuConsole) consoles = static QTAILQ_HEAD(, QemuConsole) consoles =
QTAILQ_HEAD_INITIALIZER(consoles); QTAILQ_HEAD_INITIALIZER(consoles);
static bool cursor_visible_phase; static bool cursor_visible_phase;
static QEMUTimer *cursor_timer; static QEMUTimer *cursor_timer;
@ -1303,7 +1303,7 @@ static QemuConsole *new_console(DisplayState *ds, console_type_t console_type,
s->index = 0; s->index = 0;
QTAILQ_INSERT_TAIL(&consoles, s, next); QTAILQ_INSERT_TAIL(&consoles, s, next);
} else if (console_type != GRAPHIC_CONSOLE || qdev_hotplug) { } else if (console_type != GRAPHIC_CONSOLE || qdev_hotplug) {
QemuConsole *last = QTAILQ_LAST(&consoles, consoles_head); QemuConsole *last = QTAILQ_LAST(&consoles);
s->index = last->index + 1; s->index = last->index + 1;
QTAILQ_INSERT_TAIL(&consoles, s, next); QTAILQ_INSERT_TAIL(&consoles, s, next);
} else { } else {

4
util/qemu-option.c
View File

@ -280,7 +280,7 @@ QemuOpt *qemu_opt_find(QemuOpts *opts, const char *name)
{ {
QemuOpt *opt; QemuOpt *opt;
QTAILQ_FOREACH_REVERSE(opt, &opts->head, QemuOptHead, next) { QTAILQ_FOREACH_REVERSE(opt, &opts->head, next) {
if (strcmp(opt->name, name) != 0) if (strcmp(opt->name, name) != 0)
continue; continue;
return opt; return opt;
@ -379,7 +379,7 @@ bool qemu_opt_has_help_opt(QemuOpts *opts)
{ {
QemuOpt *opt; QemuOpt *opt;
QTAILQ_FOREACH_REVERSE(opt, &opts->head, QemuOptHead, next) { QTAILQ_FOREACH_REVERSE(opt, &opts->head, next) {
if (is_help_option(opt->name)) { if (is_help_option(opt->name)) {
return true; return true;
} }