diff --git a/acl.c b/acl.c index 1a11a61d19..311dade4e2 100644 --- a/acl.c +++ b/acl.c @@ -64,7 +64,7 @@ qemu_acl *qemu_acl_init(const char *aclname) acl->defaultDeny = 1; acl->nentries = 0; - TAILQ_INIT(&acl->entries); + QTAILQ_INIT(&acl->entries); acls = qemu_realloc(acls, sizeof(*acls) * (nacls +1)); acls[nacls] = acl; @@ -78,7 +78,7 @@ int qemu_acl_party_is_allowed(qemu_acl *acl, { qemu_acl_entry *entry; - TAILQ_FOREACH(entry, &acl->entries, next) { + QTAILQ_FOREACH(entry, &acl->entries, next) { #ifdef CONFIG_FNMATCH if (fnmatch(entry->match, party, 0) == 0) return entry->deny ? 0 : 1; @@ -102,8 +102,8 @@ void qemu_acl_reset(qemu_acl *acl) * of "open access" while the user re-initializes the * access control list */ acl->defaultDeny = 1; - TAILQ_FOREACH(entry, &acl->entries, next) { - TAILQ_REMOVE(&acl->entries, entry, next); + QTAILQ_FOREACH(entry, &acl->entries, next) { + QTAILQ_REMOVE(&acl->entries, entry, next); free(entry->match); free(entry); } @@ -121,7 +121,7 @@ int qemu_acl_append(qemu_acl *acl, entry->match = qemu_strdup(match); entry->deny = deny; - TAILQ_INSERT_TAIL(&acl->entries, entry, next); + QTAILQ_INSERT_TAIL(&acl->entries, entry, next); acl->nentries++; return acl->nentries; @@ -147,10 +147,10 @@ int qemu_acl_insert(qemu_acl *acl, entry->match = qemu_strdup(match); entry->deny = deny; - TAILQ_FOREACH(tmp, &acl->entries, next) { + QTAILQ_FOREACH(tmp, &acl->entries, next) { i++; if (i == index) { - TAILQ_INSERT_BEFORE(tmp, entry, next); + QTAILQ_INSERT_BEFORE(tmp, entry, next); acl->nentries++; break; } @@ -165,10 +165,10 @@ int qemu_acl_remove(qemu_acl *acl, qemu_acl_entry *entry; int i = 0; - TAILQ_FOREACH(entry, &acl->entries, next) { + QTAILQ_FOREACH(entry, &acl->entries, next) { i++; if (strcmp(entry->match, match) == 0) { - TAILQ_REMOVE(&acl->entries, entry, next); + QTAILQ_REMOVE(&acl->entries, entry, next); return i; } } diff --git a/acl.h b/acl.h index 62a5e56409..0ef780401f 100644 --- a/acl.h +++ b/acl.h @@ -25,7 +25,7 @@ #ifndef __QEMU_ACL_H__ #define __QEMU_ACL_H__ -#include "sys-queue.h" +#include "qemu-queue.h" typedef struct qemu_acl_entry qemu_acl_entry; typedef struct qemu_acl qemu_acl; @@ -34,13 +34,13 @@ struct qemu_acl_entry { char *match; int deny; - TAILQ_ENTRY(qemu_acl_entry) next; + QTAILQ_ENTRY(qemu_acl_entry) next; }; struct qemu_acl { char *aclname; unsigned int nentries; - TAILQ_HEAD(,qemu_acl_entry) entries; + QTAILQ_HEAD(,qemu_acl_entry) entries; int defaultDeny; }; diff --git a/aio.c b/aio.c index efc63fd9a1..da18443369 100644 --- a/aio.c +++ b/aio.c @@ -13,13 +13,13 @@ #include "qemu-common.h" #include "block.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "qemu_socket.h" typedef struct AioHandler AioHandler; /* The list of registered AIO handlers */ -static LIST_HEAD(, AioHandler) aio_handlers; +static QLIST_HEAD(, AioHandler) aio_handlers; /* This is a simple lock used to protect the aio_handlers list. Specifically, * it's used to ensure that no callbacks are removed while we're walking and @@ -35,14 +35,14 @@ struct AioHandler AioFlushHandler *io_flush; int deleted; void *opaque; - LIST_ENTRY(AioHandler) node; + QLIST_ENTRY(AioHandler) node; }; static AioHandler *find_aio_handler(int fd) { AioHandler *node; - LIST_FOREACH(node, &aio_handlers, node) { + QLIST_FOREACH(node, &aio_handlers, node) { if (node->fd == fd) if (!node->deleted) return node; @@ -72,7 +72,7 @@ int qemu_aio_set_fd_handler(int fd, * deleted because deleted nodes are only cleaned up after * releasing the walking_handlers lock. */ - LIST_REMOVE(node, node); + QLIST_REMOVE(node, node); qemu_free(node); } } @@ -81,7 +81,7 @@ int qemu_aio_set_fd_handler(int fd, /* Alloc and insert if it's not already there */ node = qemu_mallocz(sizeof(AioHandler)); node->fd = fd; - LIST_INSERT_HEAD(&aio_handlers, node, node); + QLIST_INSERT_HEAD(&aio_handlers, node, node); } /* Update handler with latest information */ node->io_read = io_read; @@ -109,7 +109,7 @@ void qemu_aio_flush(void) */ qemu_aio_wait(); - LIST_FOREACH(node, &aio_handlers, node) { + QLIST_FOREACH(node, &aio_handlers, node) { ret |= node->io_flush(node->opaque); } } while (qemu_bh_poll() || ret > 0); @@ -133,7 +133,7 @@ void qemu_aio_wait(void) FD_ZERO(&wrfds); /* fill fd sets */ - LIST_FOREACH(node, &aio_handlers, node) { + QLIST_FOREACH(node, &aio_handlers, node) { /* If there aren't pending AIO operations, don't invoke callbacks. * Otherwise, if there are no AIO requests, qemu_aio_wait() would * wait indefinitely. @@ -168,7 +168,7 @@ void qemu_aio_wait(void) /* we have to walk very carefully in case * qemu_aio_set_fd_handler is called while we're walking */ - node = LIST_FIRST(&aio_handlers); + node = QLIST_FIRST(&aio_handlers); while (node) { AioHandler *tmp; @@ -184,10 +184,10 @@ void qemu_aio_wait(void) } tmp = node; - node = LIST_NEXT(node, node); + node = QLIST_NEXT(node, node); if (tmp->deleted) { - LIST_REMOVE(tmp, node); + QLIST_REMOVE(tmp, node); qemu_free(tmp); } } diff --git a/audio/audio.c b/audio/audio.c index aa9ea3ea0e..e223cf3e82 100644 --- a/audio/audio.c +++ b/audio/audio.c @@ -766,8 +766,8 @@ static void audio_detach_capture (HWVoiceOut *hw) sw->rate = NULL; } - LIST_REMOVE (sw, entries); - LIST_REMOVE (sc, entries); + QLIST_REMOVE (sw, entries); + QLIST_REMOVE (sc, entries); qemu_free (sc); if (was_active) { /* We have removed soft voice from the capture: @@ -811,8 +811,8 @@ static int audio_attach_capture (HWVoiceOut *hw) qemu_free (sw); return -1; } - LIST_INSERT_HEAD (&hw_cap->sw_head, sw, entries); - LIST_INSERT_HEAD (&hw->cap_head, sc, entries); + QLIST_INSERT_HEAD (&hw_cap->sw_head, sw, entries); + QLIST_INSERT_HEAD (&hw->cap_head, sc, entries); #ifdef DEBUG_CAPTURE asprintf (&sw->name, "for %p %d,%d,%d", hw, sw->info.freq, sw->info.bits, sw->info.nchannels); @@ -1803,9 +1803,9 @@ static void audio_init (void) return; } - LIST_INIT (&s->hw_head_out); - LIST_INIT (&s->hw_head_in); - LIST_INIT (&s->cap_head); + QLIST_INIT (&s->hw_head_out); + QLIST_INIT (&s->hw_head_in); + QLIST_INIT (&s->cap_head); atexit (audio_atexit); s->ts = qemu_new_timer (vm_clock, audio_timer, s); @@ -1887,7 +1887,7 @@ static void audio_init (void) "(Audio can continue looping even after stopping the VM)\n"); } - LIST_INIT (&s->card_head); + QLIST_INIT (&s->card_head); register_savevm ("audio", 0, 1, audio_save, audio_load, s); } @@ -1896,12 +1896,12 @@ void AUD_register_card (const char *name, QEMUSoundCard *card) audio_init (); card->name = qemu_strdup (name); memset (&card->entries, 0, sizeof (card->entries)); - LIST_INSERT_HEAD (&glob_audio_state.card_head, card, entries); + QLIST_INSERT_HEAD (&glob_audio_state.card_head, card, entries); } void AUD_remove_card (QEMUSoundCard *card) { - LIST_REMOVE (card, entries); + QLIST_REMOVE (card, entries); qemu_free (card->name); } @@ -1933,7 +1933,7 @@ CaptureVoiceOut *AUD_add_capture ( cap = audio_pcm_capture_find_specific (as); if (cap) { - LIST_INSERT_HEAD (&cap->cb_head, cb, entries); + QLIST_INSERT_HEAD (&cap->cb_head, cb, entries); return cap; } else { @@ -1948,8 +1948,8 @@ CaptureVoiceOut *AUD_add_capture ( } hw = &cap->hw; - LIST_INIT (&hw->sw_head); - LIST_INIT (&cap->cb_head); + QLIST_INIT (&hw->sw_head); + QLIST_INIT (&cap->cb_head); /* XXX find a more elegant way */ hw->samples = 4096 * 4; @@ -1977,8 +1977,8 @@ CaptureVoiceOut *AUD_add_capture ( [hw->info.swap_endianness] [audio_bits_to_index (hw->info.bits)]; - LIST_INSERT_HEAD (&s->cap_head, cap, entries); - LIST_INSERT_HEAD (&cap->cb_head, cb, entries); + QLIST_INSERT_HEAD (&s->cap_head, cap, entries); + QLIST_INSERT_HEAD (&cap->cb_head, cb, entries); hw = NULL; while ((hw = audio_pcm_hw_find_any_out (hw))) { @@ -2004,7 +2004,7 @@ void AUD_del_capture (CaptureVoiceOut *cap, void *cb_opaque) for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { if (cb->opaque == cb_opaque) { cb->ops.destroy (cb_opaque); - LIST_REMOVE (cb, entries); + QLIST_REMOVE (cb, entries); qemu_free (cb); if (!cap->cb_head.lh_first) { @@ -2021,12 +2021,12 @@ void AUD_del_capture (CaptureVoiceOut *cap, void *cb_opaque) st_rate_stop (sw->rate); sw->rate = NULL; } - LIST_REMOVE (sw, entries); - LIST_REMOVE (sc, entries); + QLIST_REMOVE (sw, entries); + QLIST_REMOVE (sc, entries); qemu_free (sc); sw = sw1; } - LIST_REMOVE (cap, entries); + QLIST_REMOVE (cap, entries); qemu_free (cap); } return; diff --git a/audio/audio.h b/audio/audio.h index dec86e5f77..f234ad0f54 100644 --- a/audio/audio.h +++ b/audio/audio.h @@ -25,7 +25,7 @@ #define QEMU_AUDIO_H #include "config-host.h" -#include "sys-queue.h" +#include "qemu-queue.h" typedef void (*audio_callback_fn_t) (void *opaque, int avail); @@ -70,7 +70,7 @@ struct capture_ops { typedef struct CaptureState { void *opaque; struct capture_ops ops; - LIST_ENTRY (CaptureState) entries; + QLIST_ENTRY (CaptureState) entries; } CaptureState; typedef struct SWVoiceOut SWVoiceOut; @@ -79,7 +79,7 @@ typedef struct SWVoiceIn SWVoiceIn; typedef struct QEMUSoundCard { char *name; - LIST_ENTRY (QEMUSoundCard) entries; + QLIST_ENTRY (QEMUSoundCard) entries; } QEMUSoundCard; typedef struct QEMUAudioTimeStamp { diff --git a/audio/audio_int.h b/audio/audio_int.h index d930d0790e..ce791ee46c 100644 --- a/audio/audio_int.h +++ b/audio/audio_int.h @@ -80,10 +80,10 @@ typedef struct HWVoiceOut { struct st_sample *mix_buf; int samples; - LIST_HEAD (sw_out_listhead, SWVoiceOut) sw_head; - LIST_HEAD (sw_cap_listhead, SWVoiceCap) cap_head; + QLIST_HEAD (sw_out_listhead, SWVoiceOut) sw_head; + QLIST_HEAD (sw_cap_listhead, SWVoiceCap) cap_head; struct audio_pcm_ops *pcm_ops; - LIST_ENTRY (HWVoiceOut) entries; + QLIST_ENTRY (HWVoiceOut) entries; } HWVoiceOut; typedef struct HWVoiceIn { @@ -100,9 +100,9 @@ typedef struct HWVoiceIn { struct st_sample *conv_buf; int samples; - LIST_HEAD (sw_in_listhead, SWVoiceIn) sw_head; + QLIST_HEAD (sw_in_listhead, SWVoiceIn) sw_head; struct audio_pcm_ops *pcm_ops; - LIST_ENTRY (HWVoiceIn) entries; + QLIST_ENTRY (HWVoiceIn) entries; } HWVoiceIn; struct SWVoiceOut { @@ -119,7 +119,7 @@ struct SWVoiceOut { char *name; struct mixeng_volume vol; struct audio_callback callback; - LIST_ENTRY (SWVoiceOut) entries; + QLIST_ENTRY (SWVoiceOut) entries; }; struct SWVoiceIn { @@ -135,7 +135,7 @@ struct SWVoiceIn { char *name; struct mixeng_volume vol; struct audio_callback callback; - LIST_ENTRY (SWVoiceIn) entries; + QLIST_ENTRY (SWVoiceIn) entries; }; struct audio_driver { @@ -169,20 +169,20 @@ struct audio_pcm_ops { struct capture_callback { struct audio_capture_ops ops; void *opaque; - LIST_ENTRY (capture_callback) entries; + QLIST_ENTRY (capture_callback) entries; }; struct CaptureVoiceOut { HWVoiceOut hw; void *buf; - LIST_HEAD (cb_listhead, capture_callback) cb_head; - LIST_ENTRY (CaptureVoiceOut) entries; + QLIST_HEAD (cb_listhead, capture_callback) cb_head; + QLIST_ENTRY (CaptureVoiceOut) entries; }; struct SWVoiceCap { SWVoiceOut sw; CaptureVoiceOut *cap; - LIST_ENTRY (SWVoiceCap) entries; + QLIST_ENTRY (SWVoiceCap) entries; }; struct AudioState { @@ -190,10 +190,10 @@ struct AudioState { void *drv_opaque; QEMUTimer *ts; - LIST_HEAD (card_listhead, QEMUSoundCard) card_head; - LIST_HEAD (hw_in_listhead, HWVoiceIn) hw_head_in; - LIST_HEAD (hw_out_listhead, HWVoiceOut) hw_head_out; - LIST_HEAD (cap_listhead, CaptureVoiceOut) cap_head; + QLIST_HEAD (card_listhead, QEMUSoundCard) card_head; + QLIST_HEAD (hw_in_listhead, HWVoiceIn) hw_head_in; + QLIST_HEAD (hw_out_listhead, HWVoiceOut) hw_head_out; + QLIST_HEAD (cap_listhead, CaptureVoiceOut) cap_head; int nb_hw_voices_out; int nb_hw_voices_in; int vm_running; diff --git a/audio/audio_template.h b/audio/audio_template.h index 0ffca652f5..e65d834ac9 100644 --- a/audio/audio_template.h +++ b/audio/audio_template.h @@ -184,12 +184,12 @@ static void glue (audio_pcm_sw_fini_, TYPE) (SW *sw) static void glue (audio_pcm_hw_add_sw_, TYPE) (HW *hw, SW *sw) { - LIST_INSERT_HEAD (&hw->sw_head, sw, entries); + QLIST_INSERT_HEAD (&hw->sw_head, sw, entries); } static void glue (audio_pcm_hw_del_sw_, TYPE) (SW *sw) { - LIST_REMOVE (sw, entries); + QLIST_REMOVE (sw, entries); } static void glue (audio_pcm_hw_gc_, TYPE) (HW **hwp) @@ -201,7 +201,7 @@ static void glue (audio_pcm_hw_gc_, TYPE) (HW **hwp) #ifdef DAC audio_detach_capture (hw); #endif - LIST_REMOVE (hw, entries); + QLIST_REMOVE (hw, entries); glue (s->nb_hw_voices_, TYPE) += 1; glue (audio_pcm_hw_free_resources_ ,TYPE) (hw); glue (hw->pcm_ops->fini_, TYPE) (hw); @@ -267,9 +267,9 @@ static HW *glue (audio_pcm_hw_add_new_, TYPE) (struct audsettings *as) } hw->pcm_ops = drv->pcm_ops; - LIST_INIT (&hw->sw_head); + QLIST_INIT (&hw->sw_head); #ifdef DAC - LIST_INIT (&hw->cap_head); + QLIST_INIT (&hw->cap_head); #endif if (glue (hw->pcm_ops->init_, TYPE) (hw, as)) { goto err0; @@ -294,7 +294,7 @@ static HW *glue (audio_pcm_hw_add_new_, TYPE) (struct audsettings *as) goto err1; } - LIST_INSERT_HEAD (&s->glue (hw_head_, TYPE), hw, entries); + QLIST_INSERT_HEAD (&s->glue (hw_head_, TYPE), hw, entries); glue (s->nb_hw_voices_, TYPE) -= 1; #ifdef DAC audio_attach_capture (hw); diff --git a/block.c b/block.c index 0c6a97bc9c..33f3d652c6 100644 --- a/block.c +++ b/block.c @@ -22,11 +22,6 @@ * THE SOFTWARE. */ #include "config-host.h" -#ifdef CONFIG_BSD -/* include native header before sys-queue.h */ -#include -#endif - #include "qemu-common.h" #include "monitor.h" #include "block_int.h" @@ -36,6 +31,7 @@ #include #include #include +#include #ifndef __DragonFly__ #include #endif diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c index d4631c3974..54e505cbed 100644 --- a/block/qcow2-cluster.c +++ b/block/qcow2-cluster.c @@ -738,7 +738,7 @@ uint64_t qcow2_alloc_cluster_offset(BlockDriverState *bs, * the same cluster. In this case we need to wait until the previous * request has completed and updated the L2 table accordingly. */ - LIST_FOREACH(old_alloc, &s->cluster_allocs, next_in_flight) { + QLIST_FOREACH(old_alloc, &s->cluster_allocs, next_in_flight) { uint64_t end_offset = offset + nb_clusters * s->cluster_size; uint64_t old_offset = old_alloc->offset; @@ -769,7 +769,7 @@ uint64_t qcow2_alloc_cluster_offset(BlockDriverState *bs, abort(); } - LIST_INSERT_HEAD(&s->cluster_allocs, m, next_in_flight); + QLIST_INSERT_HEAD(&s->cluster_allocs, m, next_in_flight); /* allocate a new cluster */ diff --git a/block/qcow2.c b/block/qcow2.c index 8579e01508..a9e768268a 100644 --- a/block/qcow2.c +++ b/block/qcow2.c @@ -219,7 +219,7 @@ static int qcow_open(BlockDriverState *bs, const char *filename, int flags) if (qcow2_refcount_init(bs) < 0) goto fail; - LIST_INIT(&s->cluster_allocs); + QLIST_INIT(&s->cluster_allocs); /* read qcow2 extensions */ if (header.backing_file_offset) @@ -340,7 +340,7 @@ typedef struct QCowAIOCB { QEMUIOVector hd_qiov; QEMUBH *bh; QCowL2Meta l2meta; - LIST_ENTRY(QCowAIOCB) next_depend; + QLIST_ENTRY(QCowAIOCB) next_depend; } QCowAIOCB; static void qcow_aio_cancel(BlockDriverAIOCB *blockacb) @@ -503,7 +503,7 @@ static QCowAIOCB *qcow_aio_setup(BlockDriverState *bs, acb->n = 0; acb->cluster_offset = 0; acb->l2meta.nb_clusters = 0; - LIST_INIT(&acb->l2meta.dependent_requests); + QLIST_INIT(&acb->l2meta.dependent_requests); return acb; } @@ -530,12 +530,12 @@ static void run_dependent_requests(QCowL2Meta *m) /* Take the request off the list of running requests */ if (m->nb_clusters != 0) { - LIST_REMOVE(m, next_in_flight); + QLIST_REMOVE(m, next_in_flight); } /* * Restart all dependent requests. - * Can't use LIST_FOREACH here - the next link might not be the same + * Can't use QLIST_FOREACH here - the next link might not be the same * any more after the callback (request could depend on a different * request now) */ @@ -545,7 +545,7 @@ static void run_dependent_requests(QCowL2Meta *m) } /* Empty the list for the next part of the request */ - LIST_INIT(&m->dependent_requests); + QLIST_INIT(&m->dependent_requests); } static void qcow_aio_write_cb(void *opaque, int ret) @@ -590,7 +590,7 @@ static void qcow_aio_write_cb(void *opaque, int ret) /* Need to wait for another request? If so, we are done for now. */ if (!acb->cluster_offset && acb->l2meta.depends_on != NULL) { - LIST_INSERT_HEAD(&acb->l2meta.depends_on->dependent_requests, + QLIST_INSERT_HEAD(&acb->l2meta.depends_on->dependent_requests, acb, next_depend); return; } @@ -690,7 +690,7 @@ static int preallocate(BlockDriverState *bs) nb_sectors = bdrv_getlength(bs) >> 9; offset = 0; - LIST_INIT(&meta.dependent_requests); + QLIST_INIT(&meta.dependent_requests); while (nb_sectors) { num = MIN(nb_sectors, INT_MAX >> 9); diff --git a/block/qcow2.h b/block/qcow2.h index 965a2f45c1..ecc94cbfad 100644 --- a/block/qcow2.h +++ b/block/qcow2.h @@ -98,7 +98,7 @@ typedef struct BDRVQcowState { uint8_t *cluster_cache; uint8_t *cluster_data; uint64_t cluster_cache_offset; - LIST_HEAD(QCowClusterAlloc, QCowL2Meta) cluster_allocs; + QLIST_HEAD(QCowClusterAlloc, QCowL2Meta) cluster_allocs; uint64_t *refcount_table; uint64_t refcount_table_offset; @@ -139,9 +139,9 @@ typedef struct QCowL2Meta int nb_available; int nb_clusters; struct QCowL2Meta *depends_on; - LIST_HEAD(QCowAioDependencies, QCowAIOCB) dependent_requests; + QLIST_HEAD(QCowAioDependencies, QCowAIOCB) dependent_requests; - LIST_ENTRY(QCowL2Meta) next_in_flight; + QLIST_ENTRY(QCowL2Meta) next_in_flight; } QCowL2Meta; static inline int size_to_clusters(BDRVQcowState *s, int64_t size) diff --git a/check-qdict.c b/check-qdict.c index 19989d65a7..c37d448227 100644 --- a/check-qdict.c +++ b/check-qdict.c @@ -47,7 +47,7 @@ START_TEST(qdict_put_obj_test) qdict_put_obj(qdict, "", QOBJECT(qint_from_int(num))); fail_unless(qdict_size(qdict) == 1); - ent = LIST_FIRST(&qdict->table[12345 % QDICT_HASH_SIZE]); + ent = QLIST_FIRST(&qdict->table[12345 % QDICT_HASH_SIZE]); qi = qobject_to_qint(ent->value); fail_unless(qint_get_int(qi) == num); diff --git a/cpu-defs.h b/cpu-defs.h index b6c8b955c1..95068b5304 100644 --- a/cpu-defs.h +++ b/cpu-defs.h @@ -28,7 +28,7 @@ #include #include #include "osdep.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "targphys.h" #ifndef TARGET_LONG_BITS @@ -124,14 +124,14 @@ struct KVMState; typedef struct CPUBreakpoint { target_ulong pc; int flags; /* BP_* */ - TAILQ_ENTRY(CPUBreakpoint) entry; + QTAILQ_ENTRY(CPUBreakpoint) entry; } CPUBreakpoint; typedef struct CPUWatchpoint { target_ulong vaddr; target_ulong len_mask; int flags; /* BP_* */ - TAILQ_ENTRY(CPUWatchpoint) entry; + QTAILQ_ENTRY(CPUWatchpoint) entry; } CPUWatchpoint; #define CPU_TEMP_BUF_NLONGS 128 @@ -169,10 +169,10 @@ typedef struct CPUWatchpoint { \ /* from this point: preserved by CPU reset */ \ /* ice debug support */ \ - TAILQ_HEAD(breakpoints_head, CPUBreakpoint) breakpoints; \ + QTAILQ_HEAD(breakpoints_head, CPUBreakpoint) breakpoints; \ int singlestep_enabled; \ \ - TAILQ_HEAD(watchpoints_head, CPUWatchpoint) watchpoints; \ + QTAILQ_HEAD(watchpoints_head, CPUWatchpoint) watchpoints; \ CPUWatchpoint *watchpoint_hit; \ \ struct GDBRegisterState *gdb_regs; \ diff --git a/cpu-exec.c b/cpu-exec.c index bf20ada1a0..8aa92c7854 100644 --- a/cpu-exec.c +++ b/cpu-exec.c @@ -202,7 +202,7 @@ static void cpu_handle_debug_exception(CPUState *env) CPUWatchpoint *wp; if (!env->watchpoint_hit) - TAILQ_FOREACH(wp, &env->watchpoints, entry) + QTAILQ_FOREACH(wp, &env->watchpoints, entry) wp->flags &= ~BP_WATCHPOINT_HIT; if (debug_excp_handler) diff --git a/envlist.c b/envlist.c index e13c2d3e14..f2303cdd79 100644 --- a/envlist.c +++ b/envlist.c @@ -1,20 +1,19 @@ -#include - #include #include #include #include #include +#include "qemu-queue.h" #include "envlist.h" struct envlist_entry { const char *ev_var; /* actual env value */ - LIST_ENTRY(envlist_entry) ev_link; + QLIST_ENTRY(envlist_entry) ev_link; }; struct envlist { - LIST_HEAD(, envlist_entry) el_entries; /* actual entries */ + QLIST_HEAD(, envlist_entry) el_entries; /* actual entries */ size_t el_count; /* number of entries */ }; @@ -33,7 +32,7 @@ envlist_create(void) if ((envlist = malloc(sizeof (*envlist))) == NULL) return (NULL); - LIST_INIT(&envlist->el_entries); + QLIST_INIT(&envlist->el_entries); envlist->el_count = 0; return (envlist); @@ -51,7 +50,7 @@ envlist_free(envlist_t *envlist) while (envlist->el_entries.lh_first != NULL) { entry = envlist->el_entries.lh_first; - LIST_REMOVE(entry, ev_link); + QLIST_REMOVE(entry, ev_link); free((char *)entry->ev_var); free(entry); @@ -159,7 +158,7 @@ envlist_setenv(envlist_t *envlist, const char *env) } if (entry != NULL) { - LIST_REMOVE(entry, ev_link); + QLIST_REMOVE(entry, ev_link); free((char *)entry->ev_var); free(entry); } else { @@ -172,7 +171,7 @@ envlist_setenv(envlist_t *envlist, const char *env) free(entry); return (errno); } - LIST_INSERT_HEAD(&envlist->el_entries, entry, ev_link); + QLIST_INSERT_HEAD(&envlist->el_entries, entry, ev_link); return (0); } @@ -205,7 +204,7 @@ envlist_unsetenv(envlist_t *envlist, const char *env) break; } if (entry != NULL) { - LIST_REMOVE(entry, ev_link); + QLIST_REMOVE(entry, ev_link); free((char *)entry->ev_var); free(entry); diff --git a/exec.c b/exec.c index 6a62a8a054..c82e76714c 100644 --- a/exec.c +++ b/exec.c @@ -586,8 +586,8 @@ void cpu_exec_init(CPUState *env) } env->cpu_index = cpu_index; env->numa_node = 0; - TAILQ_INIT(&env->breakpoints); - TAILQ_INIT(&env->watchpoints); + QTAILQ_INIT(&env->breakpoints); + QTAILQ_INIT(&env->watchpoints); *penv = env; #if defined(CONFIG_USER_ONLY) cpu_list_unlock(); @@ -1348,9 +1348,9 @@ int cpu_watchpoint_insert(CPUState *env, target_ulong addr, target_ulong len, /* keep all GDB-injected watchpoints in front */ if (flags & BP_GDB) - TAILQ_INSERT_HEAD(&env->watchpoints, wp, entry); + QTAILQ_INSERT_HEAD(&env->watchpoints, wp, entry); else - TAILQ_INSERT_TAIL(&env->watchpoints, wp, entry); + QTAILQ_INSERT_TAIL(&env->watchpoints, wp, entry); tlb_flush_page(env, addr); @@ -1366,7 +1366,7 @@ int cpu_watchpoint_remove(CPUState *env, target_ulong addr, target_ulong len, target_ulong len_mask = ~(len - 1); CPUWatchpoint *wp; - TAILQ_FOREACH(wp, &env->watchpoints, entry) { + QTAILQ_FOREACH(wp, &env->watchpoints, entry) { if (addr == wp->vaddr && len_mask == wp->len_mask && flags == (wp->flags & ~BP_WATCHPOINT_HIT)) { cpu_watchpoint_remove_by_ref(env, wp); @@ -1379,7 +1379,7 @@ int cpu_watchpoint_remove(CPUState *env, target_ulong addr, target_ulong len, /* Remove a specific watchpoint by reference. */ void cpu_watchpoint_remove_by_ref(CPUState *env, CPUWatchpoint *watchpoint) { - TAILQ_REMOVE(&env->watchpoints, watchpoint, entry); + QTAILQ_REMOVE(&env->watchpoints, watchpoint, entry); tlb_flush_page(env, watchpoint->vaddr); @@ -1391,7 +1391,7 @@ void cpu_watchpoint_remove_all(CPUState *env, int mask) { CPUWatchpoint *wp, *next; - TAILQ_FOREACH_SAFE(wp, &env->watchpoints, entry, next) { + QTAILQ_FOREACH_SAFE(wp, &env->watchpoints, entry, next) { if (wp->flags & mask) cpu_watchpoint_remove_by_ref(env, wp); } @@ -1411,9 +1411,9 @@ int cpu_breakpoint_insert(CPUState *env, target_ulong pc, int flags, /* keep all GDB-injected breakpoints in front */ if (flags & BP_GDB) - TAILQ_INSERT_HEAD(&env->breakpoints, bp, entry); + QTAILQ_INSERT_HEAD(&env->breakpoints, bp, entry); else - TAILQ_INSERT_TAIL(&env->breakpoints, bp, entry); + QTAILQ_INSERT_TAIL(&env->breakpoints, bp, entry); breakpoint_invalidate(env, pc); @@ -1431,7 +1431,7 @@ int cpu_breakpoint_remove(CPUState *env, target_ulong pc, int flags) #if defined(TARGET_HAS_ICE) CPUBreakpoint *bp; - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == pc && bp->flags == flags) { cpu_breakpoint_remove_by_ref(env, bp); return 0; @@ -1447,7 +1447,7 @@ int cpu_breakpoint_remove(CPUState *env, target_ulong pc, int flags) void cpu_breakpoint_remove_by_ref(CPUState *env, CPUBreakpoint *breakpoint) { #if defined(TARGET_HAS_ICE) - TAILQ_REMOVE(&env->breakpoints, breakpoint, entry); + QTAILQ_REMOVE(&env->breakpoints, breakpoint, entry); breakpoint_invalidate(env, breakpoint->pc); @@ -1461,7 +1461,7 @@ void cpu_breakpoint_remove_all(CPUState *env, int mask) #if defined(TARGET_HAS_ICE) CPUBreakpoint *bp, *next; - TAILQ_FOREACH_SAFE(bp, &env->breakpoints, entry, next) { + QTAILQ_FOREACH_SAFE(bp, &env->breakpoints, entry, next) { if (bp->flags & mask) cpu_breakpoint_remove_by_ref(env, bp); } @@ -1712,13 +1712,13 @@ CPUState *cpu_copy(CPUState *env) /* Clone all break/watchpoints. Note: Once we support ptrace with hw-debug register access, make sure BP_CPU break/watchpoints are handled correctly on clone. */ - TAILQ_INIT(&env->breakpoints); - TAILQ_INIT(&env->watchpoints); + QTAILQ_INIT(&env->breakpoints); + QTAILQ_INIT(&env->watchpoints); #if defined(TARGET_HAS_ICE) - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { cpu_breakpoint_insert(new_env, bp->pc, bp->flags, NULL); } - TAILQ_FOREACH(wp, &env->watchpoints, entry) { + QTAILQ_FOREACH(wp, &env->watchpoints, entry) { cpu_watchpoint_insert(new_env, wp->vaddr, (~wp->len_mask) + 1, wp->flags, NULL); } @@ -2009,7 +2009,7 @@ int tlb_set_page_exec(CPUState *env, target_ulong vaddr, code_address = address; /* Make accesses to pages with watchpoints go via the watchpoint trap routines. */ - TAILQ_FOREACH(wp, &env->watchpoints, entry) { + QTAILQ_FOREACH(wp, &env->watchpoints, entry) { if (vaddr == (wp->vaddr & TARGET_PAGE_MASK)) { iotlb = io_mem_watch + paddr; /* TODO: The memory case can be optimized by not trapping @@ -2663,7 +2663,7 @@ static void check_watchpoint(int offset, int len_mask, int flags) return; } vaddr = (env->mem_io_vaddr & TARGET_PAGE_MASK) + offset; - TAILQ_FOREACH(wp, &env->watchpoints, entry) { + QTAILQ_FOREACH(wp, &env->watchpoints, entry) { if ((vaddr == (wp->vaddr & len_mask) || (vaddr & wp->len_mask) == wp->vaddr) && (wp->flags & flags)) { wp->flags |= BP_WATCHPOINT_HIT; @@ -3169,11 +3169,11 @@ static BounceBuffer bounce; typedef struct MapClient { void *opaque; void (*callback)(void *opaque); - LIST_ENTRY(MapClient) link; + QLIST_ENTRY(MapClient) link; } MapClient; -static LIST_HEAD(map_client_list, MapClient) map_client_list - = LIST_HEAD_INITIALIZER(map_client_list); +static QLIST_HEAD(map_client_list, MapClient) map_client_list + = QLIST_HEAD_INITIALIZER(map_client_list); void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque)) { @@ -3181,7 +3181,7 @@ void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque)) client->opaque = opaque; client->callback = callback; - LIST_INSERT_HEAD(&map_client_list, client, link); + QLIST_INSERT_HEAD(&map_client_list, client, link); return client; } @@ -3189,7 +3189,7 @@ void cpu_unregister_map_client(void *_client) { MapClient *client = (MapClient *)_client; - LIST_REMOVE(client, link); + QLIST_REMOVE(client, link); qemu_free(client); } @@ -3197,8 +3197,8 @@ static void cpu_notify_map_clients(void) { MapClient *client; - while (!LIST_EMPTY(&map_client_list)) { - client = LIST_FIRST(&map_client_list); + while (!QLIST_EMPTY(&map_client_list)) { + client = QLIST_FIRST(&map_client_list); client->callback(client->opaque); cpu_unregister_map_client(client); } diff --git a/hw/device-hotplug.c b/hw/device-hotplug.c index fd4cc3fb54..69779caef5 100644 --- a/hw/device-hotplug.c +++ b/hw/device-hotplug.c @@ -68,7 +68,7 @@ void destroy_bdrvs(dev_match_fn *match_fn, void *arg) DriveInfo *dinfo; struct BlockDriverState *bs; - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { bs = dinfo->bdrv; if (bs) { if (bs->private && match_fn(bs->private, arg)) { diff --git a/hw/i2c.c b/hw/i2c.c index 547377213b..370c43128b 100644 --- a/hw/i2c.c +++ b/hw/i2c.c @@ -76,7 +76,7 @@ int i2c_start_transfer(i2c_bus *bus, int address, int recv) DeviceState *qdev; i2c_slave *slave = NULL; - LIST_FOREACH(qdev, &bus->qbus.children, sibling) { + QLIST_FOREACH(qdev, &bus->qbus.children, sibling) { slave = I2C_SLAVE_FROM_QDEV(qdev); if (slave->address == address) break; diff --git a/hw/pci-hotplug.c b/hw/pci-hotplug.c index 5348dd1b2e..f3dc42103d 100644 --- a/hw/pci-hotplug.c +++ b/hw/pci-hotplug.c @@ -84,7 +84,7 @@ void drive_hot_add(Monitor *mon, const QDict *qdict) switch (type) { case IF_SCSI: success = 1; - scsibus = LIST_FIRST(&dev->qdev.child_bus); + scsibus = QLIST_FIRST(&dev->qdev.child_bus); scsi_bus_legacy_add_drive(DO_UPCAST(SCSIBus, qbus, scsibus), dinfo, dinfo->unit); break; diff --git a/hw/qdev.c b/hw/qdev.c index 6451b8a6d7..43b1beb258 100644 --- a/hw/qdev.c +++ b/hw/qdev.c @@ -101,7 +101,7 @@ DeviceState *qdev_create(BusState *bus, const char *name) qdev_prop_set_defaults(dev, dev->info->props); qdev_prop_set_defaults(dev, dev->parent_bus->info->props); qdev_prop_set_compat(dev); - LIST_INSERT_HEAD(&bus->children, dev, sibling); + QLIST_INSERT_HEAD(&bus->children, dev, sibling); return dev; } @@ -235,7 +235,7 @@ void qdev_free(DeviceState *dev) #endif if (dev->info->reset) qemu_unregister_reset(dev->info->reset, dev); - LIST_REMOVE(dev, sibling); + QLIST_REMOVE(dev, sibling); qemu_free(dev); } @@ -321,7 +321,7 @@ BusState *qdev_get_child_bus(DeviceState *dev, const char *name) { BusState *bus; - LIST_FOREACH(bus, &dev->child_bus, sibling) { + QLIST_FOREACH(bus, &dev->child_bus, sibling) { if (strcmp(name, bus->name) == 0) { return bus; } @@ -346,8 +346,8 @@ static BusState *qbus_find_recursive(BusState *bus, const char *name, return bus; } - LIST_FOREACH(dev, &bus->children, sibling) { - LIST_FOREACH(child, &dev->child_bus, sibling) { + QLIST_FOREACH(dev, &bus->children, sibling) { + QLIST_FOREACH(child, &dev->child_bus, sibling) { ret = qbus_find_recursive(child, name, info); if (ret) { return ret; @@ -365,7 +365,7 @@ static void qbus_list_bus(DeviceState *dev, char *dest, int len) pos += snprintf(dest+pos, len-pos,"child busses at \"%s\":", dev->id ? dev->id : dev->info->name); - LIST_FOREACH(child, &dev->child_bus, sibling) { + QLIST_FOREACH(child, &dev->child_bus, sibling) { pos += snprintf(dest+pos, len-pos, "%s\"%s\"", sep, child->name); sep = ", "; } @@ -379,7 +379,7 @@ static void qbus_list_dev(BusState *bus, char *dest, int len) pos += snprintf(dest+pos, len-pos, "devices at \"%s\":", bus->name); - LIST_FOREACH(dev, &bus->children, sibling) { + QLIST_FOREACH(dev, &bus->children, sibling) { pos += snprintf(dest+pos, len-pos, "%s\"%s\"", sep, dev->info->name); if (dev->id) @@ -392,7 +392,7 @@ static BusState *qbus_find_bus(DeviceState *dev, char *elem) { BusState *child; - LIST_FOREACH(child, &dev->child_bus, sibling) { + QLIST_FOREACH(child, &dev->child_bus, sibling) { if (strcmp(child->name, elem) == 0) { return child; } @@ -410,17 +410,17 @@ static DeviceState *qbus_find_dev(BusState *bus, char *elem) * (2) driver name * (3) driver alias, if present */ - LIST_FOREACH(dev, &bus->children, sibling) { + QLIST_FOREACH(dev, &bus->children, sibling) { if (dev->id && strcmp(dev->id, elem) == 0) { return dev; } } - LIST_FOREACH(dev, &bus->children, sibling) { + QLIST_FOREACH(dev, &bus->children, sibling) { if (strcmp(dev->info->name, elem) == 0) { return dev; } } - LIST_FOREACH(dev, &bus->children, sibling) { + QLIST_FOREACH(dev, &bus->children, sibling) { if (dev->info->alias && strcmp(dev->info->alias, elem) == 0) { return dev; } @@ -478,7 +478,7 @@ static BusState *qbus_find(const char *path) qemu_error("device has no child bus (%s)\n", path); return NULL; case 1: - return LIST_FIRST(&dev->child_bus); + return QLIST_FIRST(&dev->child_bus); default: qbus_list_bus(dev, msg, sizeof(msg)); qemu_error("device has multiple child busses (%s)\n%s\n", @@ -532,9 +532,9 @@ BusState *qbus_create(BusInfo *info, DeviceState *parent, const char *name) bus->name = buf; } - LIST_INIT(&bus->children); + QLIST_INIT(&bus->children); if (parent) { - LIST_INSERT_HEAD(&parent->child_bus, bus, sibling); + QLIST_INSERT_HEAD(&parent->child_bus, bus, sibling); parent->num_child_bus++; } return bus; @@ -575,7 +575,7 @@ static void qdev_print(Monitor *mon, DeviceState *dev, int indent) qdev_print_props(mon, dev, dev->parent_bus->info->props, "bus", indent); if (dev->parent_bus->info->print_dev) dev->parent_bus->info->print_dev(mon, dev, indent); - LIST_FOREACH(child, &dev->child_bus, sibling) { + QLIST_FOREACH(child, &dev->child_bus, sibling) { qbus_print(mon, child, indent); } } @@ -587,7 +587,7 @@ static void qbus_print(Monitor *mon, BusState *bus, int indent) qdev_printf("bus: %s\n", bus->name); indent += 2; qdev_printf("type %s\n", bus->info->name); - LIST_FOREACH(dev, &bus->children, sibling) { + QLIST_FOREACH(dev, &bus->children, sibling) { qdev_print(mon, dev, indent); } } diff --git a/hw/qdev.h b/hw/qdev.h index c2609b4fe9..623ded52fe 100644 --- a/hw/qdev.h +++ b/hw/qdev.h @@ -3,7 +3,7 @@ #include "hw.h" #include "sysemu.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "qemu-char.h" #include "qemu-option.h" @@ -29,10 +29,10 @@ struct DeviceState { qemu_irq *gpio_out; int num_gpio_in; qemu_irq *gpio_in; - LIST_HEAD(, BusState) child_bus; + QLIST_HEAD(, BusState) child_bus; int num_child_bus; NICInfo *nd; - LIST_ENTRY(DeviceState) sibling; + QLIST_ENTRY(DeviceState) sibling; }; typedef void (*bus_dev_printfn)(Monitor *mon, DeviceState *dev, int indent); @@ -47,8 +47,8 @@ struct BusState { DeviceState *parent; BusInfo *info; const char *name; - LIST_HEAD(, DeviceState) children; - LIST_ENTRY(BusState) sibling; + QLIST_HEAD(, DeviceState) children; + QLIST_ENTRY(BusState) sibling; }; struct Property { diff --git a/hw/ssi.c b/hw/ssi.c index 54ad1a1bdb..73cb54150a 100644 --- a/hw/ssi.c +++ b/hw/ssi.c @@ -25,8 +25,8 @@ static int ssi_slave_init(DeviceState *dev, DeviceInfo *base_info) SSIBus *bus; bus = FROM_QBUS(SSIBus, qdev_get_parent_bus(dev)); - if (LIST_FIRST(&bus->qbus.children) != dev - || LIST_NEXT(dev, sibling) != NULL) { + if (QLIST_FIRST(&bus->qbus.children) != dev + || QLIST_NEXT(dev, sibling) != NULL) { hw_error("Too many devices on SSI bus"); } @@ -61,7 +61,7 @@ uint32_t ssi_transfer(SSIBus *bus, uint32_t val) { DeviceState *dev; SSISlave *slave; - dev = LIST_FIRST(&bus->qbus.children); + dev = QLIST_FIRST(&bus->qbus.children); if (!dev) { return 0; } diff --git a/hw/usb-bus.c b/hw/usb-bus.c index 169fb2f58d..03933f12f1 100644 --- a/hw/usb-bus.c +++ b/hw/usb-bus.c @@ -12,7 +12,7 @@ static struct BusInfo usb_bus_info = { .print_dev = usb_bus_dev_print, }; static int next_usb_bus = 0; -static TAILQ_HEAD(, USBBus) busses = TAILQ_HEAD_INITIALIZER(busses); +static QTAILQ_HEAD(, USBBus) busses = QTAILQ_HEAD_INITIALIZER(busses); USBBus *usb_bus_new(DeviceState *host) { @@ -20,9 +20,9 @@ USBBus *usb_bus_new(DeviceState *host) bus = FROM_QBUS(USBBus, qbus_create(&usb_bus_info, host, NULL)); bus->busnr = next_usb_bus++; - TAILQ_INIT(&bus->free); - TAILQ_INIT(&bus->used); - TAILQ_INSERT_TAIL(&busses, bus, next); + QTAILQ_INIT(&bus->free); + QTAILQ_INIT(&bus->used); + QTAILQ_INSERT_TAIL(&busses, bus, next); return bus; } @@ -31,8 +31,8 @@ USBBus *usb_bus_find(int busnr) USBBus *bus; if (-1 == busnr) - return TAILQ_FIRST(&busses); - TAILQ_FOREACH(bus, &busses, next) { + return QTAILQ_FIRST(&busses); + QTAILQ_FOREACH(bus, &busses, next) { if (bus->busnr == busnr) return bus; } @@ -100,7 +100,7 @@ void usb_register_port(USBBus *bus, USBPort *port, void *opaque, int index, port->opaque = opaque; port->index = index; port->attach = attach; - TAILQ_INSERT_TAIL(&bus->free, port, next); + QTAILQ_INSERT_TAIL(&bus->free, port, next); bus->nfree++; } @@ -116,13 +116,13 @@ static void do_attach(USBDevice *dev) } dev->attached++; - port = TAILQ_FIRST(&bus->free); - TAILQ_REMOVE(&bus->free, port, next); + port = QTAILQ_FIRST(&bus->free); + QTAILQ_REMOVE(&bus->free, port, next); bus->nfree--; usb_attach(port, dev); - TAILQ_INSERT_TAIL(&bus->used, port, next); + QTAILQ_INSERT_TAIL(&bus->used, port, next); bus->nused++; } @@ -149,7 +149,7 @@ int usb_device_delete_addr(int busnr, int addr) if (!bus) return -1; - TAILQ_FOREACH(port, &bus->used, next) { + QTAILQ_FOREACH(port, &bus->used, next) { if (port->dev->addr == addr) break; } @@ -157,13 +157,13 @@ int usb_device_delete_addr(int busnr, int addr) return -1; dev = port->dev; - TAILQ_REMOVE(&bus->used, port, next); + QTAILQ_REMOVE(&bus->used, port, next); bus->nused--; usb_attach(port, NULL); dev->info->handle_destroy(dev); - TAILQ_INSERT_TAIL(&bus->free, port, next); + QTAILQ_INSERT_TAIL(&bus->free, port, next); bus->nfree++; return 0; } @@ -196,13 +196,13 @@ void usb_info(Monitor *mon) USBDevice *dev; USBPort *port; - if (TAILQ_EMPTY(&busses)) { + if (QTAILQ_EMPTY(&busses)) { monitor_printf(mon, "USB support not enabled\n"); return; } - TAILQ_FOREACH(bus, &busses, next) { - TAILQ_FOREACH(port, &bus->used, next) { + QTAILQ_FOREACH(bus, &busses, next) { + QTAILQ_FOREACH(port, &bus->used, next) { dev = port->dev; if (!dev) continue; diff --git a/hw/usb-net.c b/hw/usb-net.c index f19309ee13..b33e32927c 100644 --- a/hw/usb-net.c +++ b/hw/usb-net.c @@ -26,7 +26,7 @@ #include "qemu-common.h" #include "usb.h" #include "net.h" -#include "sys-queue.h" +#include "qemu-queue.h" /*#define TRAFFIC_DEBUG*/ /* Thanks to NetChip Technologies for donating this product ID. @@ -595,7 +595,7 @@ static const uint32_t oid_supported_list[] = #define NDIS_MAC_OPTION_8021P_PRIORITY (1 << 6) struct rndis_response { - TAILQ_ENTRY(rndis_response) entries; + QTAILQ_ENTRY(rndis_response) entries; uint32_t length; uint8_t buf[0]; }; @@ -621,7 +621,7 @@ typedef struct USBNetState { char usbstring_mac[13]; VLANClientState *vc; - TAILQ_HEAD(rndis_resp_head, rndis_response) rndis_resp; + QTAILQ_HEAD(rndis_resp_head, rndis_response) rndis_resp; } USBNetState; static int ndis_query(USBNetState *s, uint32_t oid, @@ -812,7 +812,7 @@ static int rndis_get_response(USBNetState *s, uint8_t *buf) if (!r) return ret; - TAILQ_REMOVE(&s->rndis_resp, r, entries); + QTAILQ_REMOVE(&s->rndis_resp, r, entries); ret = r->length; memcpy(buf, r->buf, r->length); qemu_free(r); @@ -825,7 +825,7 @@ static void *rndis_queue_response(USBNetState *s, unsigned int length) struct rndis_response *r = qemu_mallocz(sizeof(struct rndis_response) + length); - TAILQ_INSERT_TAIL(&s->rndis_resp, r, entries); + QTAILQ_INSERT_TAIL(&s->rndis_resp, r, entries); r->length = length; return &r->buf[0]; @@ -836,7 +836,7 @@ static void rndis_clear_responsequeue(USBNetState *s) struct rndis_response *r; while ((r = s->rndis_resp.tqh_first)) { - TAILQ_REMOVE(&s->rndis_resp, r, entries); + QTAILQ_REMOVE(&s->rndis_resp, r, entries); qemu_free(r); } } @@ -1440,7 +1440,7 @@ static int usb_net_initfn(USBDevice *dev) s->rndis = 1; s->rndis_state = RNDIS_UNINITIALIZED; - TAILQ_INIT(&s->rndis_resp); + QTAILQ_INIT(&s->rndis_resp); s->medium = 0; /* NDIS_MEDIUM_802_3 */ s->speed = 1000000; /* 100MBps, in 100Bps units */ diff --git a/hw/usb.h b/hw/usb.h index 36326399cd..7c5cf83384 100644 --- a/hw/usb.h +++ b/hw/usb.h @@ -24,7 +24,7 @@ #include "block.h" #include "qdev.h" -#include "sys-queue.h" +#include "qemu-queue.h" #define USB_TOKEN_SETUP 0x2d #define USB_TOKEN_IN 0x69 /* device -> host */ @@ -193,7 +193,7 @@ struct USBPort { usb_attachfn attach; void *opaque; int index; /* internal port index, may be used with the opaque */ - TAILQ_ENTRY(USBPort) next; + QTAILQ_ENTRY(USBPort) next; }; typedef void USBCallback(USBPacket * packet, void *opaque); @@ -298,9 +298,9 @@ struct USBBus { int busnr; int nfree; int nused; - TAILQ_HEAD(, USBPort) free; - TAILQ_HEAD(, USBPort) used; - TAILQ_ENTRY(USBBus) next; + QTAILQ_HEAD(, USBPort) free; + QTAILQ_HEAD(, USBPort) used; + QTAILQ_ENTRY(USBBus) next; }; USBBus *usb_bus_new(DeviceState *host); diff --git a/hw/watchdog.c b/hw/watchdog.c index adba872533..6a3d1b4320 100644 --- a/hw/watchdog.c +++ b/hw/watchdog.c @@ -22,7 +22,7 @@ #include "qemu-common.h" #include "qemu-option.h" #include "qemu-config.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "sysemu.h" #include "hw/watchdog.h" @@ -35,11 +35,11 @@ #define WDT_NONE 6 /* Do nothing. */ static int watchdog_action = WDT_RESET; -static LIST_HEAD(watchdog_list, WatchdogTimerModel) watchdog_list; +static QLIST_HEAD(watchdog_list, WatchdogTimerModel) watchdog_list; void watchdog_add_model(WatchdogTimerModel *model) { - LIST_INSERT_HEAD(&watchdog_list, model, entry); + QLIST_INSERT_HEAD(&watchdog_list, model, entry); } /* Returns: @@ -54,14 +54,14 @@ int select_watchdog(const char *p) /* -watchdog ? lists available devices and exits cleanly. */ if (strcmp(p, "?") == 0) { - LIST_FOREACH(model, &watchdog_list, entry) { + QLIST_FOREACH(model, &watchdog_list, entry) { fprintf(stderr, "\t%s\t%s\n", model->wdt_name, model->wdt_description); } return 2; } - LIST_FOREACH(model, &watchdog_list, entry) { + QLIST_FOREACH(model, &watchdog_list, entry) { if (strcasecmp(model->wdt_name, p) == 0) { /* add the device */ opts = qemu_opts_create(&qemu_device_opts, NULL, 0); @@ -71,7 +71,7 @@ int select_watchdog(const char *p) } fprintf(stderr, "Unknown -watchdog device. Supported devices are:\n"); - LIST_FOREACH(model, &watchdog_list, entry) { + QLIST_FOREACH(model, &watchdog_list, entry) { fprintf(stderr, "\t%s\t%s\n", model->wdt_name, model->wdt_description); } diff --git a/hw/watchdog.h b/hw/watchdog.h index 8c54fa41fd..330062c85f 100644 --- a/hw/watchdog.h +++ b/hw/watchdog.h @@ -23,7 +23,7 @@ #define QEMU_WATCHDOG_H struct WatchdogTimerModel { - LIST_ENTRY(WatchdogTimerModel) entry; + QLIST_ENTRY(WatchdogTimerModel) entry; /* Short name of the device - used to select it on the command line. */ const char *wdt_name; diff --git a/hw/xen_backend.c b/hw/xen_backend.c index efafd2fa52..658ea8d1d3 100644 --- a/hw/xen_backend.c +++ b/hw/xen_backend.c @@ -48,7 +48,7 @@ struct xs_handle *xenstore = NULL; const char *xen_protocol; /* private */ -static TAILQ_HEAD(XenDeviceHead, XenDevice) xendevs = TAILQ_HEAD_INITIALIZER(xendevs); +static QTAILQ_HEAD(XenDeviceHead, XenDevice) xendevs = QTAILQ_HEAD_INITIALIZER(xendevs); static int debug = 0; /* ------------------------------------------------------------- */ @@ -165,7 +165,7 @@ struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev) { struct XenDevice *xendev; - TAILQ_FOREACH(xendev, &xendevs, next) { + QTAILQ_FOREACH(xendev, &xendevs, next) { if (xendev->dom != dom) continue; if (xendev->dev != dev) @@ -227,7 +227,7 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev, xendev->gnttabdev = -1; } - TAILQ_INSERT_TAIL(&xendevs, xendev, next); + QTAILQ_INSERT_TAIL(&xendevs, xendev, next); if (xendev->ops->alloc) xendev->ops->alloc(xendev); @@ -243,7 +243,7 @@ static struct XenDevice *xen_be_del_xendev(int dom, int dev) struct XenDevice *xendev, *xnext; /* - * This is pretty much like TAILQ_FOREACH(xendev, &xendevs, next) but + * This is pretty much like QTAILQ_FOREACH(xendev, &xendevs, next) but * we save the next pointer in xnext because we might free xendev. */ xnext = xendevs.tqh_first; @@ -271,7 +271,7 @@ static struct XenDevice *xen_be_del_xendev(int dom, int dev) if (xendev->gnttabdev >= 0) xc_gnttab_close(xendev->gnttabdev); - TAILQ_REMOVE(&xendevs, xendev, next); + QTAILQ_REMOVE(&xendevs, xendev, next); qemu_free(xendev); } return NULL; diff --git a/hw/xen_backend.h b/hw/xen_backend.h index 4dbfdb4a4a..f07f7d4224 100644 --- a/hw/xen_backend.h +++ b/hw/xen_backend.h @@ -50,7 +50,7 @@ struct XenDevice { int gnttabdev; struct XenDevOps *ops; - TAILQ_ENTRY(XenDevice) next; + QTAILQ_ENTRY(XenDevice) next; }; /* ------------------------------------------------------------- */ diff --git a/hw/xen_devconfig.c b/hw/xen_devconfig.c index 4121188a48..ea8f8c4c2d 100644 --- a/hw/xen_devconfig.c +++ b/hw/xen_devconfig.c @@ -4,9 +4,9 @@ struct xs_dirs { char *xs_dir; - TAILQ_ENTRY(xs_dirs) list; + QTAILQ_ENTRY(xs_dirs) list; }; -static TAILQ_HEAD(xs_dirs_head, xs_dirs) xs_cleanup = TAILQ_HEAD_INITIALIZER(xs_cleanup); +static QTAILQ_HEAD(xs_dirs_head, xs_dirs) xs_cleanup = QTAILQ_HEAD_INITIALIZER(xs_cleanup); static void xen_config_cleanup_dir(char *dir) { @@ -14,14 +14,14 @@ static void xen_config_cleanup_dir(char *dir) d = qemu_malloc(sizeof(*d)); d->xs_dir = dir; - TAILQ_INSERT_TAIL(&xs_cleanup, d, list); + QTAILQ_INSERT_TAIL(&xs_cleanup, d, list); } void xen_config_cleanup(void) { struct xs_dirs *d; - TAILQ_FOREACH(d, &xs_cleanup, list) { + QTAILQ_FOREACH(d, &xs_cleanup, list) { xs_rm(xenstore, 0, d->xs_dir); } } diff --git a/hw/xen_disk.c b/hw/xen_disk.c index 100ef8e9bc..74cde80691 100644 --- a/hw/xen_disk.c +++ b/hw/xen_disk.c @@ -77,7 +77,7 @@ struct ioreq { int aio_errors; struct XenBlkDev *blkdev; - LIST_ENTRY(ioreq) list; + QLIST_ENTRY(ioreq) list; }; struct XenBlkDev { @@ -99,9 +99,9 @@ struct XenBlkDev { int cnt_map; /* request lists */ - LIST_HEAD(inflight_head, ioreq) inflight; - LIST_HEAD(finished_head, ioreq) finished; - LIST_HEAD(freelist_head, ioreq) freelist; + QLIST_HEAD(inflight_head, ioreq) inflight; + QLIST_HEAD(finished_head, ioreq) finished; + QLIST_HEAD(freelist_head, ioreq) freelist; int requests_total; int requests_inflight; int requests_finished; @@ -118,7 +118,7 @@ static struct ioreq *ioreq_start(struct XenBlkDev *blkdev) { struct ioreq *ioreq = NULL; - if (LIST_EMPTY(&blkdev->freelist)) { + if (QLIST_EMPTY(&blkdev->freelist)) { if (blkdev->requests_total >= max_requests) goto out; /* allocate new struct */ @@ -128,11 +128,11 @@ static struct ioreq *ioreq_start(struct XenBlkDev *blkdev) qemu_iovec_init(&ioreq->v, BLKIF_MAX_SEGMENTS_PER_REQUEST); } else { /* get one from freelist */ - ioreq = LIST_FIRST(&blkdev->freelist); - LIST_REMOVE(ioreq, list); + ioreq = QLIST_FIRST(&blkdev->freelist); + QLIST_REMOVE(ioreq, list); qemu_iovec_reset(&ioreq->v); } - LIST_INSERT_HEAD(&blkdev->inflight, ioreq, list); + QLIST_INSERT_HEAD(&blkdev->inflight, ioreq, list); blkdev->requests_inflight++; out: @@ -143,8 +143,8 @@ static void ioreq_finish(struct ioreq *ioreq) { struct XenBlkDev *blkdev = ioreq->blkdev; - LIST_REMOVE(ioreq, list); - LIST_INSERT_HEAD(&blkdev->finished, ioreq, list); + QLIST_REMOVE(ioreq, list); + QLIST_INSERT_HEAD(&blkdev->finished, ioreq, list); blkdev->requests_inflight--; blkdev->requests_finished++; } @@ -153,10 +153,10 @@ static void ioreq_release(struct ioreq *ioreq) { struct XenBlkDev *blkdev = ioreq->blkdev; - LIST_REMOVE(ioreq, list); + QLIST_REMOVE(ioreq, list); memset(ioreq, 0, sizeof(*ioreq)); ioreq->blkdev = blkdev; - LIST_INSERT_HEAD(&blkdev->freelist, ioreq, list); + QLIST_INSERT_HEAD(&blkdev->freelist, ioreq, list); blkdev->requests_finished--; } @@ -476,8 +476,8 @@ static void blk_send_response_all(struct XenBlkDev *blkdev) struct ioreq *ioreq; int send_notify = 0; - while (!LIST_EMPTY(&blkdev->finished)) { - ioreq = LIST_FIRST(&blkdev->finished); + while (!QLIST_EMPTY(&blkdev->finished)) { + ioreq = QLIST_FIRST(&blkdev->finished); send_notify += blk_send_response_one(ioreq); ioreq_release(ioreq); } @@ -564,9 +564,9 @@ static void blk_alloc(struct XenDevice *xendev) { struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); - LIST_INIT(&blkdev->inflight); - LIST_INIT(&blkdev->finished); - LIST_INIT(&blkdev->freelist); + QLIST_INIT(&blkdev->inflight); + QLIST_INIT(&blkdev->finished); + QLIST_INIT(&blkdev->freelist); blkdev->bh = qemu_bh_new(blk_bh, blkdev); if (xen_mode != XEN_EMULATE) batch_maps = 1; @@ -750,9 +750,9 @@ static int blk_free(struct XenDevice *xendev) struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); struct ioreq *ioreq; - while (!LIST_EMPTY(&blkdev->freelist)) { - ioreq = LIST_FIRST(&blkdev->freelist); - LIST_REMOVE(ioreq, list); + while (!QLIST_EMPTY(&blkdev->freelist)) { + ioreq = QLIST_FIRST(&blkdev->freelist); + QLIST_REMOVE(ioreq, list); qemu_iovec_destroy(&ioreq->v); qemu_free(ioreq); } diff --git a/kvm-all.c b/kvm-all.c index 15c30d41be..ac5798497f 100644 --- a/kvm-all.c +++ b/kvm-all.c @@ -428,7 +428,7 @@ int kvm_init(int smp_cpus) s = qemu_mallocz(sizeof(KVMState)); #ifdef KVM_CAP_SET_GUEST_DEBUG - TAILQ_INIT(&s->kvm_sw_breakpoints); + QTAILQ_INIT(&s->kvm_sw_breakpoints); #endif for (i = 0; i < ARRAY_SIZE(s->slots); i++) s->slots[i].slot = i; @@ -917,7 +917,7 @@ struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *env, { struct kvm_sw_breakpoint *bp; - TAILQ_FOREACH(bp, &env->kvm_state->kvm_sw_breakpoints, entry) { + QTAILQ_FOREACH(bp, &env->kvm_state->kvm_sw_breakpoints, entry) { if (bp->pc == pc) return bp; } @@ -926,7 +926,7 @@ struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *env, int kvm_sw_breakpoints_active(CPUState *env) { - return !TAILQ_EMPTY(&env->kvm_state->kvm_sw_breakpoints); + return !QTAILQ_EMPTY(&env->kvm_state->kvm_sw_breakpoints); } struct kvm_set_guest_debug_data { @@ -983,7 +983,7 @@ int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr, return err; } - TAILQ_INSERT_HEAD(¤t_env->kvm_state->kvm_sw_breakpoints, + QTAILQ_INSERT_HEAD(¤t_env->kvm_state->kvm_sw_breakpoints, bp, entry); } else { err = kvm_arch_insert_hw_breakpoint(addr, len, type); @@ -1020,7 +1020,7 @@ int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr, if (err) return err; - TAILQ_REMOVE(¤t_env->kvm_state->kvm_sw_breakpoints, bp, entry); + QTAILQ_REMOVE(¤t_env->kvm_state->kvm_sw_breakpoints, bp, entry); qemu_free(bp); } else { err = kvm_arch_remove_hw_breakpoint(addr, len, type); @@ -1042,7 +1042,7 @@ void kvm_remove_all_breakpoints(CPUState *current_env) KVMState *s = current_env->kvm_state; CPUState *env; - TAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) { + QTAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) { if (kvm_arch_remove_sw_breakpoint(current_env, bp) != 0) { /* Try harder to find a CPU that currently sees the breakpoint. */ for (env = first_cpu; env != NULL; env = env->next_cpu) { diff --git a/kvm.h b/kvm.h index dbe825fdf2..e7d5beb87b 100644 --- a/kvm.h +++ b/kvm.h @@ -15,7 +15,7 @@ #define QEMU_KVM_H #include "config.h" -#include "sys-queue.h" +#include "qemu-queue.h" #ifdef CONFIG_KVM extern int kvm_allowed; @@ -100,10 +100,10 @@ struct kvm_sw_breakpoint { target_ulong pc; target_ulong saved_insn; int use_count; - TAILQ_ENTRY(kvm_sw_breakpoint) entry; + QTAILQ_ENTRY(kvm_sw_breakpoint) entry; }; -TAILQ_HEAD(kvm_sw_breakpoint_head, kvm_sw_breakpoint); +QTAILQ_HEAD(kvm_sw_breakpoint_head, kvm_sw_breakpoint); int kvm_arch_debug(struct kvm_debug_exit_arch *arch_info); diff --git a/linux-user/elfload.c b/linux-user/elfload.c index 4f04b98287..10d4781da8 100644 --- a/linux-user/elfload.c +++ b/linux-user/elfload.c @@ -1844,7 +1844,7 @@ struct target_elf_prpsinfo { /* Here is the structure in which status of each thread is captured. */ struct elf_thread_status { - TAILQ_ENTRY(elf_thread_status) ets_link; + QTAILQ_ENTRY(elf_thread_status) ets_link; struct target_elf_prstatus prstatus; /* NT_PRSTATUS */ #if 0 elf_fpregset_t fpu; /* NT_PRFPREG */ @@ -1860,7 +1860,7 @@ struct elf_note_info { struct target_elf_prstatus *prstatus; /* NT_PRSTATUS */ struct target_elf_prpsinfo *psinfo; /* NT_PRPSINFO */ - TAILQ_HEAD(thread_list_head, elf_thread_status) thread_list; + QTAILQ_HEAD(thread_list_head, elf_thread_status) thread_list; #if 0 /* * Current version of ELF coredump doesn't support @@ -1878,11 +1878,11 @@ struct vm_area_struct { abi_ulong vma_start; /* start vaddr of memory region */ abi_ulong vma_end; /* end vaddr of memory region */ abi_ulong vma_flags; /* protection etc. flags for the region */ - TAILQ_ENTRY(vm_area_struct) vma_link; + QTAILQ_ENTRY(vm_area_struct) vma_link; }; struct mm_struct { - TAILQ_HEAD(, vm_area_struct) mm_mmap; + QTAILQ_HEAD(, vm_area_struct) mm_mmap; int mm_count; /* number of mappings */ }; @@ -1962,7 +1962,7 @@ static struct mm_struct *vma_init(void) return (NULL); mm->mm_count = 0; - TAILQ_INIT(&mm->mm_mmap); + QTAILQ_INIT(&mm->mm_mmap); return (mm); } @@ -1972,7 +1972,7 @@ static void vma_delete(struct mm_struct *mm) struct vm_area_struct *vma; while ((vma = vma_first(mm)) != NULL) { - TAILQ_REMOVE(&mm->mm_mmap, vma, vma_link); + QTAILQ_REMOVE(&mm->mm_mmap, vma, vma_link); qemu_free(vma); } qemu_free(mm); @@ -1990,7 +1990,7 @@ static int vma_add_mapping(struct mm_struct *mm, abi_ulong start, vma->vma_end = end; vma->vma_flags = flags; - TAILQ_INSERT_TAIL(&mm->mm_mmap, vma, vma_link); + QTAILQ_INSERT_TAIL(&mm->mm_mmap, vma, vma_link); mm->mm_count++; return (0); @@ -1998,12 +1998,12 @@ static int vma_add_mapping(struct mm_struct *mm, abi_ulong start, static struct vm_area_struct *vma_first(const struct mm_struct *mm) { - return (TAILQ_FIRST(&mm->mm_mmap)); + return (QTAILQ_FIRST(&mm->mm_mmap)); } static struct vm_area_struct *vma_next(struct vm_area_struct *vma) { - return (TAILQ_NEXT(vma, vma_link)); + return (QTAILQ_NEXT(vma, vma_link)); } static int vma_get_mapping_count(const struct mm_struct *mm) @@ -2328,7 +2328,7 @@ static void fill_thread_info(struct elf_note_info *info, const CPUState *env) fill_note(&ets->notes[0], "CORE", NT_PRSTATUS, sizeof (ets->prstatus), &ets->prstatus); - TAILQ_INSERT_TAIL(&info->thread_list, ets, ets_link); + QTAILQ_INSERT_TAIL(&info->thread_list, ets, ets_link); info->notes_size += note_size(&ets->notes[0]); } @@ -2343,7 +2343,7 @@ static int fill_note_info(struct elf_note_info *info, (void) memset(info, 0, sizeof (*info)); - TAILQ_INIT(&info->thread_list); + QTAILQ_INIT(&info->thread_list); info->notes = qemu_mallocz(NUMNOTES * sizeof (struct memelfnote)); if (info->notes == NULL) @@ -2389,9 +2389,9 @@ static void free_note_info(struct elf_note_info *info) { struct elf_thread_status *ets; - while (!TAILQ_EMPTY(&info->thread_list)) { - ets = TAILQ_FIRST(&info->thread_list); - TAILQ_REMOVE(&info->thread_list, ets, ets_link); + while (!QTAILQ_EMPTY(&info->thread_list)) { + ets = QTAILQ_FIRST(&info->thread_list); + QTAILQ_REMOVE(&info->thread_list, ets, ets_link); qemu_free(ets); } diff --git a/linux-user/qemu.h b/linux-user/qemu.h index def620f0ee..d129debb1f 100644 --- a/linux-user/qemu.h +++ b/linux-user/qemu.h @@ -18,7 +18,7 @@ #include "syscall.h" #include "target_signal.h" #include "gdbstub.h" -#include "sys-queue.h" +#include "qemu-queue.h" #if defined(CONFIG_USE_NPTL) #define THREAD __thread diff --git a/module.c b/module.c index 3729283830..e77d569768 100644 --- a/module.c +++ b/module.c @@ -12,17 +12,17 @@ */ #include "qemu-common.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "module.h" typedef struct ModuleEntry { module_init_type type; void (*init)(void); - TAILQ_ENTRY(ModuleEntry) node; + QTAILQ_ENTRY(ModuleEntry) node; } ModuleEntry; -typedef TAILQ_HEAD(, ModuleEntry) ModuleTypeList; +typedef QTAILQ_HEAD(, ModuleEntry) ModuleTypeList; static ModuleTypeList init_type_list[MODULE_INIT_MAX]; @@ -36,7 +36,7 @@ static void init_types(void) } for (i = 0; i < MODULE_INIT_MAX; i++) { - TAILQ_INIT(&init_type_list[i]); + QTAILQ_INIT(&init_type_list[i]); } inited = 1; @@ -64,7 +64,7 @@ void register_module_init(void (*fn)(void), module_init_type type) l = find_type(type); - TAILQ_INSERT_TAIL(l, e, node); + QTAILQ_INSERT_TAIL(l, e, node); } void module_call_init(module_init_type type) @@ -74,7 +74,7 @@ void module_call_init(module_init_type type) l = find_type(type); - TAILQ_FOREACH(e, l, node) { + QTAILQ_FOREACH(e, l, node) { e->init(); } } diff --git a/monitor.c b/monitor.c index a88cdc9510..18bcc92234 100644 --- a/monitor.c +++ b/monitor.c @@ -80,7 +80,7 @@ typedef struct mon_fd_t mon_fd_t; struct mon_fd_t { char *name; int fd; - LIST_ENTRY(mon_fd_t) next; + QLIST_ENTRY(mon_fd_t) next; }; struct Monitor { @@ -95,11 +95,11 @@ struct Monitor { CPUState *mon_cpu; BlockDriverCompletionFunc *password_completion_cb; void *password_opaque; - LIST_HEAD(,mon_fd_t) fds; - LIST_ENTRY(Monitor) entry; + QLIST_HEAD(,mon_fd_t) fds; + QLIST_ENTRY(Monitor) entry; }; -static LIST_HEAD(mon_list, Monitor) mon_list; +static QLIST_HEAD(mon_list, Monitor) mon_list; static const mon_cmd_t mon_cmds[]; static const mon_cmd_t info_cmds[]; @@ -270,7 +270,7 @@ static void do_commit(Monitor *mon, const QDict *qdict) const char *device = qdict_get_str(qdict, "device"); all_devices = !strcmp(device, "all"); - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { if (!all_devices) if (strcmp(bdrv_get_device_name(dinfo->bdrv), device)) continue; @@ -1477,7 +1477,7 @@ static void do_info_profile(Monitor *mon) #endif /* Capture support */ -static LIST_HEAD (capture_list_head, CaptureState) capture_head; +static QLIST_HEAD (capture_list_head, CaptureState) capture_head; static void do_info_capture(Monitor *mon) { @@ -1500,7 +1500,7 @@ static void do_stop_capture(Monitor *mon, const QDict *qdict) for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) { if (i == n) { s->ops.destroy (s->opaque); - LIST_REMOVE (s, entries); + QLIST_REMOVE (s, entries); qemu_free (s); return; } @@ -1528,7 +1528,7 @@ static void do_wav_capture(Monitor *mon, const QDict *qdict) monitor_printf(mon, "Faied to add wave capture\n"); qemu_free (s); } - LIST_INSERT_HEAD (&capture_head, s, entries); + QLIST_INSERT_HEAD (&capture_head, s, entries); } #endif @@ -1600,7 +1600,7 @@ static void do_acl_show(Monitor *mon, const QDict *qdict) if (acl) { monitor_printf(mon, "policy: %s\n", acl->defaultDeny ? "deny" : "allow"); - TAILQ_FOREACH(entry, &acl->entries, next) { + QTAILQ_FOREACH(entry, &acl->entries, next) { i++; monitor_printf(mon, "%d: %s %s\n", i, entry->deny ? "deny" : "allow", entry->match); @@ -1729,7 +1729,7 @@ static void do_getfd(Monitor *mon, const QDict *qdict) return; } - LIST_FOREACH(monfd, &mon->fds, next) { + QLIST_FOREACH(monfd, &mon->fds, next) { if (strcmp(monfd->name, fdname) != 0) { continue; } @@ -1743,7 +1743,7 @@ static void do_getfd(Monitor *mon, const QDict *qdict) monfd->name = qemu_strdup(fdname); monfd->fd = fd; - LIST_INSERT_HEAD(&mon->fds, monfd, next); + QLIST_INSERT_HEAD(&mon->fds, monfd, next); } static void do_closefd(Monitor *mon, const QDict *qdict) @@ -1751,12 +1751,12 @@ static void do_closefd(Monitor *mon, const QDict *qdict) const char *fdname = qdict_get_str(qdict, "fdname"); mon_fd_t *monfd; - LIST_FOREACH(monfd, &mon->fds, next) { + QLIST_FOREACH(monfd, &mon->fds, next) { if (strcmp(monfd->name, fdname) != 0) { continue; } - LIST_REMOVE(monfd, next); + QLIST_REMOVE(monfd, next); close(monfd->fd); qemu_free(monfd->name); qemu_free(monfd); @@ -1782,7 +1782,7 @@ int monitor_get_fd(Monitor *mon, const char *fdname) { mon_fd_t *monfd; - LIST_FOREACH(monfd, &mon->fds, next) { + QLIST_FOREACH(monfd, &mon->fds, next) { int fd; if (strcmp(monfd->name, fdname) != 0) { @@ -1792,7 +1792,7 @@ int monitor_get_fd(Monitor *mon, const char *fdname) fd = monfd->fd; /* caller takes ownership of fd */ - LIST_REMOVE(monfd, next); + QLIST_REMOVE(monfd, next); qemu_free(monfd->name); qemu_free(monfd); @@ -3178,7 +3178,7 @@ void monitor_init(CharDriverState *chr, int flags) qemu_chr_add_handlers(chr, monitor_can_read, monitor_read, monitor_event, mon); - LIST_INSERT_HEAD(&mon_list, mon, entry); + QLIST_INSERT_HEAD(&mon_list, mon, entry); if (!cur_mon || (flags & MONITOR_IS_DEFAULT)) cur_mon = mon; } diff --git a/net.c b/net.c index 4510694cfc..3fdf1e6a1b 100644 --- a/net.c +++ b/net.c @@ -31,8 +31,6 @@ /* Needed early for CONFIG_BSD etc. */ #include "config-host.h" -/* Needed early to override system queue definitions on BSD */ -#include "sys-queue.h" #ifndef _WIN32 #include @@ -114,6 +112,7 @@ #include "qemu-log.h" #include "slirp/libslirp.h" +#include "qemu-queue.h" static VLANState *first_vlan; @@ -440,9 +439,9 @@ void qemu_purge_queued_packets(VLANClientState *vc) { VLANPacket *packet, *next; - TAILQ_FOREACH_SAFE(packet, &vc->vlan->send_queue, entry, next) { + QTAILQ_FOREACH_SAFE(packet, &vc->vlan->send_queue, entry, next) { if (packet->sender == vc) { - TAILQ_REMOVE(&vc->vlan->send_queue, packet, entry); + QTAILQ_REMOVE(&vc->vlan->send_queue, packet, entry); qemu_free(packet); } } @@ -450,16 +449,16 @@ void qemu_purge_queued_packets(VLANClientState *vc) void qemu_flush_queued_packets(VLANClientState *vc) { - while (!TAILQ_EMPTY(&vc->vlan->send_queue)) { + while (!QTAILQ_EMPTY(&vc->vlan->send_queue)) { VLANPacket *packet; int ret; - packet = TAILQ_FIRST(&vc->vlan->send_queue); - TAILQ_REMOVE(&vc->vlan->send_queue, packet, entry); + packet = QTAILQ_FIRST(&vc->vlan->send_queue); + QTAILQ_REMOVE(&vc->vlan->send_queue, packet, entry); ret = qemu_deliver_packet(packet->sender, packet->data, packet->size); if (ret == 0 && packet->sent_cb != NULL) { - TAILQ_INSERT_HEAD(&vc->vlan->send_queue, packet, entry); + QTAILQ_INSERT_HEAD(&vc->vlan->send_queue, packet, entry); break; } @@ -482,7 +481,7 @@ static void qemu_enqueue_packet(VLANClientState *sender, packet->sent_cb = sent_cb; memcpy(packet->data, buf, size); - TAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry); + QTAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry); } ssize_t qemu_send_packet_async(VLANClientState *sender, @@ -605,7 +604,7 @@ static ssize_t qemu_enqueue_packet_iov(VLANClientState *sender, packet->size += len; } - TAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry); + QTAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry); return packet->size; } @@ -671,7 +670,7 @@ struct slirp_config_str { }; typedef struct SlirpState { - TAILQ_ENTRY(SlirpState) entry; + QTAILQ_ENTRY(SlirpState) entry; VLANClientState *vc; Slirp *slirp; #ifndef _WIN32 @@ -682,8 +681,8 @@ typedef struct SlirpState { static struct slirp_config_str *slirp_configs; const char *legacy_tftp_prefix; const char *legacy_bootp_filename; -static TAILQ_HEAD(slirp_stacks, SlirpState) slirp_stacks = - TAILQ_HEAD_INITIALIZER(slirp_stacks); +static QTAILQ_HEAD(slirp_stacks, SlirpState) slirp_stacks = + QTAILQ_HEAD_INITIALIZER(slirp_stacks); static void slirp_hostfwd(SlirpState *s, Monitor *mon, const char *redir_str, int legacy_format); @@ -736,7 +735,7 @@ static void net_slirp_cleanup(VLANClientState *vc) slirp_cleanup(s->slirp); slirp_smb_cleanup(s); - TAILQ_REMOVE(&slirp_stacks, s, entry); + QTAILQ_REMOVE(&slirp_stacks, s, entry); qemu_free(s); } @@ -844,7 +843,7 @@ static int net_slirp_init(Monitor *mon, VLANState *vlan, const char *model, s = qemu_mallocz(sizeof(SlirpState)); s->slirp = slirp_init(restricted, net, mask, host, vhostname, tftp_export, bootfile, dhcp, dns, s); - TAILQ_INSERT_TAIL(&slirp_stacks, s, entry); + QTAILQ_INSERT_TAIL(&slirp_stacks, s, entry); while (slirp_configs) { struct slirp_config_str *config = slirp_configs; @@ -891,11 +890,11 @@ static SlirpState *slirp_lookup(Monitor *mon, const char *vlan, } return vc->opaque; } else { - if (TAILQ_EMPTY(&slirp_stacks)) { + if (QTAILQ_EMPTY(&slirp_stacks)) { monitor_printf(mon, "user mode network stack not in use\n"); return NULL; } - return TAILQ_FIRST(&slirp_stacks); + return QTAILQ_FIRST(&slirp_stacks); } } @@ -946,7 +945,7 @@ void net_slirp_hostfwd_remove(Monitor *mon, const QDict *qdict) host_port = atoi(p); - err = slirp_remove_hostfwd(TAILQ_FIRST(&slirp_stacks)->slirp, is_udp, + err = slirp_remove_hostfwd(QTAILQ_FIRST(&slirp_stacks)->slirp, is_udp, host_addr, host_port); monitor_printf(mon, "host forwarding rule for %s %s\n", src_str, @@ -1045,7 +1044,7 @@ void net_slirp_redir(const char *redir_str) { struct slirp_config_str *config; - if (TAILQ_EMPTY(&slirp_stacks)) { + if (QTAILQ_EMPTY(&slirp_stacks)) { config = qemu_malloc(sizeof(*config)); pstrcpy(config->str, sizeof(config->str), redir_str); config->flags = SLIRP_CFG_HOSTFWD | SLIRP_CFG_LEGACY; @@ -1054,7 +1053,7 @@ void net_slirp_redir(const char *redir_str) return; } - slirp_hostfwd(TAILQ_FIRST(&slirp_stacks), NULL, redir_str, 1); + slirp_hostfwd(QTAILQ_FIRST(&slirp_stacks), NULL, redir_str, 1); } #ifndef _WIN32 @@ -1137,8 +1136,8 @@ void net_slirp_smb(const char *exported_dir) exit(1); } legacy_smb_export = exported_dir; - if (!TAILQ_EMPTY(&slirp_stacks)) { - slirp_smb(TAILQ_FIRST(&slirp_stacks), NULL, exported_dir, + if (!QTAILQ_EMPTY(&slirp_stacks)) { + slirp_smb(QTAILQ_FIRST(&slirp_stacks), NULL, exported_dir, vserver_addr); } } @@ -1233,7 +1232,7 @@ void do_info_usernet(Monitor *mon) { SlirpState *s; - TAILQ_FOREACH(s, &slirp_stacks, entry) { + QTAILQ_FOREACH(s, &slirp_stacks, entry) { monitor_printf(mon, "VLAN %d (%s):\n", s->vc->vlan->id, s->vc->name); slirp_connection_info(s->slirp, mon); } @@ -2330,7 +2329,7 @@ VLANState *qemu_find_vlan(int id, int allocate) } vlan = qemu_mallocz(sizeof(VLANState)); vlan->id = id; - TAILQ_INIT(&vlan->send_queue); + QTAILQ_INIT(&vlan->send_queue); vlan->next = NULL; pvlan = &first_vlan; while (*pvlan != NULL) @@ -2594,7 +2593,7 @@ int net_client_init(Monitor *mon, const char *device, const char *p) qemu_free(smb_export); qemu_free(vsmbsrv); } else if (!strcmp(device, "channel")) { - if (TAILQ_EMPTY(&slirp_stacks)) { + if (QTAILQ_EMPTY(&slirp_stacks)) { struct slirp_config_str *config; config = qemu_malloc(sizeof(*config)); @@ -2603,7 +2602,7 @@ int net_client_init(Monitor *mon, const char *device, const char *p) config->next = slirp_configs; slirp_configs = config; } else { - slirp_guestfwd(TAILQ_FIRST(&slirp_stacks), mon, p, 1); + slirp_guestfwd(QTAILQ_FIRST(&slirp_stacks), mon, p, 1); } ret = 0; } else diff --git a/net.h b/net.h index f46e6c6756..147982659e 100644 --- a/net.h +++ b/net.h @@ -1,7 +1,7 @@ #ifndef QEMU_NET_H #define QEMU_NET_H -#include "sys-queue.h" +#include "qemu-queue.h" #include "qemu-common.h" #include "qdict.h" @@ -37,7 +37,7 @@ typedef struct VLANPacket VLANPacket; typedef void (NetPacketSent) (VLANClientState *, ssize_t); struct VLANPacket { - TAILQ_ENTRY(VLANPacket) entry; + QTAILQ_ENTRY(VLANPacket) entry; VLANClientState *sender; int size; NetPacketSent *sent_cb; @@ -49,7 +49,7 @@ struct VLANState { VLANClientState *first_client; struct VLANState *next; unsigned int nb_guest_devs, nb_host_devs; - TAILQ_HEAD(send_queue, VLANPacket) send_queue; + QTAILQ_HEAD(send_queue, VLANPacket) send_queue; int delivering; }; diff --git a/posix-aio-compat.c b/posix-aio-compat.c index 8bb3d10ee8..68cbec8bd1 100644 --- a/posix-aio-compat.c +++ b/posix-aio-compat.c @@ -22,7 +22,7 @@ #include #include -#include "sys-queue.h" +#include "qemu-queue.h" #include "osdep.h" #include "qemu-common.h" #include "block_int.h" @@ -43,7 +43,7 @@ struct qemu_paiocb { int ev_signo; off_t aio_offset; - TAILQ_ENTRY(qemu_paiocb) node; + QTAILQ_ENTRY(qemu_paiocb) node; int aio_type; ssize_t ret; int active; @@ -63,7 +63,7 @@ static pthread_attr_t attr; static int max_threads = 64; static int cur_threads = 0; static int idle_threads = 0; -static TAILQ_HEAD(, qemu_paiocb) request_list; +static QTAILQ_HEAD(, qemu_paiocb) request_list; #ifdef CONFIG_PREADV static int preadv_present = 1; @@ -321,16 +321,16 @@ static void *aio_thread(void *unused) mutex_lock(&lock); - while (TAILQ_EMPTY(&request_list) && + while (QTAILQ_EMPTY(&request_list) && !(ret == ETIMEDOUT)) { ret = cond_timedwait(&cond, &lock, &ts); } - if (TAILQ_EMPTY(&request_list)) + if (QTAILQ_EMPTY(&request_list)) break; - aiocb = TAILQ_FIRST(&request_list); - TAILQ_REMOVE(&request_list, aiocb, node); + aiocb = QTAILQ_FIRST(&request_list); + QTAILQ_REMOVE(&request_list, aiocb, node); aiocb->active = 1; idle_threads--; mutex_unlock(&lock); @@ -381,7 +381,7 @@ static void qemu_paio_submit(struct qemu_paiocb *aiocb) mutex_lock(&lock); if (idle_threads == 0 && cur_threads < max_threads) spawn_thread(); - TAILQ_INSERT_TAIL(&request_list, aiocb, node); + QTAILQ_INSERT_TAIL(&request_list, aiocb, node); mutex_unlock(&lock); cond_signal(&cond); } @@ -509,7 +509,7 @@ static void paio_cancel(BlockDriverAIOCB *blockacb) mutex_lock(&lock); if (!acb->active) { - TAILQ_REMOVE(&request_list, acb, node); + QTAILQ_REMOVE(&request_list, acb, node); acb->ret = -ECANCELED; } else if (acb->ret == -EINPROGRESS) { active = 1; @@ -619,7 +619,7 @@ void *paio_init(void) if (ret) die2(ret, "pthread_attr_setdetachstate"); - TAILQ_INIT(&request_list); + QTAILQ_INIT(&request_list); posix_aio_state = s; diff --git a/qdict.c b/qdict.c index ecc266e488..a302f4c0c4 100644 --- a/qdict.c +++ b/qdict.c @@ -14,7 +14,7 @@ #include "qdict.h" #include "qstring.h" #include "qobject.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "qemu-common.h" static void qdict_destroy_obj(QObject *obj); @@ -88,7 +88,7 @@ static QDictEntry *qdict_find(const QDict *qdict, { QDictEntry *entry; - LIST_FOREACH(entry, &qdict->table[hash], next) + QLIST_FOREACH(entry, &qdict->table[hash], next) if (!strcmp(entry->key, key)) return entry; @@ -120,7 +120,7 @@ void qdict_put_obj(QDict *qdict, const char *key, QObject *value) } else { /* allocate a new entry */ entry = alloc_entry(key, value); - LIST_INSERT_HEAD(&qdict->table[hash], entry, next); + QLIST_INSERT_HEAD(&qdict->table[hash], entry, next); } qdict->size++; @@ -266,7 +266,7 @@ void qdict_del(QDict *qdict, const char *key) entry = qdict_find(qdict, key, tdb_hash(key) % QDICT_HASH_SIZE); if (entry) { - LIST_REMOVE(entry, next); + QLIST_REMOVE(entry, next); qentry_destroy(entry); qdict->size--; } @@ -284,10 +284,10 @@ static void qdict_destroy_obj(QObject *obj) qdict = qobject_to_qdict(obj); for (i = 0; i < QDICT_HASH_SIZE; i++) { - QDictEntry *entry = LIST_FIRST(&qdict->table[i]); + QDictEntry *entry = QLIST_FIRST(&qdict->table[i]); while (entry) { - QDictEntry *tmp = LIST_NEXT(entry, next); - LIST_REMOVE(entry, next); + QDictEntry *tmp = QLIST_NEXT(entry, next); + QLIST_REMOVE(entry, next); qentry_destroy(entry); entry = tmp; } diff --git a/qdict.h b/qdict.h index 613d163209..3102ca296f 100644 --- a/qdict.h +++ b/qdict.h @@ -2,7 +2,7 @@ #define QDICT_H #include "qobject.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include #define QDICT_HASH_SIZE 512 @@ -10,13 +10,13 @@ typedef struct QDictEntry { char *key; QObject *value; - LIST_ENTRY(QDictEntry) next; + QLIST_ENTRY(QDictEntry) next; } QDictEntry; typedef struct QDict { QObject_HEAD; size_t size; - LIST_HEAD(,QDictEntry) table[QDICT_HASH_SIZE]; + QLIST_HEAD(,QDictEntry) table[QDICT_HASH_SIZE]; } QDict; /* Object API */ diff --git a/qemu-char.c b/qemu-char.c index 4f29618022..8084a6785d 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -106,8 +106,8 @@ /***********************************************************/ /* character device */ -static TAILQ_HEAD(CharDriverStateHead, CharDriverState) chardevs = - TAILQ_HEAD_INITIALIZER(chardevs); +static QTAILQ_HEAD(CharDriverStateHead, CharDriverState) chardevs = + QTAILQ_HEAD_INITIALIZER(chardevs); static int initial_reset_issued; static void qemu_chr_event(CharDriverState *s, int event) @@ -139,7 +139,7 @@ void qemu_chr_initial_reset(void) initial_reset_issued = 1; - TAILQ_FOREACH(chr, &chardevs, next) { + QTAILQ_FOREACH(chr, &chardevs, next) { qemu_chr_reset(chr); } } @@ -352,7 +352,7 @@ static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch) case 's': { DriveInfo *dinfo; - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { bdrv_commit(dinfo->bdrv); } } @@ -2400,7 +2400,7 @@ CharDriverState *qemu_chr_open_opts(QemuOpts *opts, if (!chr->filename) chr->filename = qemu_strdup(qemu_opt_get(opts, "backend")); chr->init = init; - TAILQ_INSERT_TAIL(&chardevs, chr, next); + QTAILQ_INSERT_TAIL(&chardevs, chr, next); if (qemu_opt_get_bool(opts, "mux", 0)) { CharDriverState *base = chr; @@ -2409,7 +2409,7 @@ CharDriverState *qemu_chr_open_opts(QemuOpts *opts, snprintf(base->label, len, "%s-base", qemu_opts_id(opts)); chr = qemu_chr_open_mux(base); chr->filename = base->filename; - TAILQ_INSERT_TAIL(&chardevs, chr, next); + QTAILQ_INSERT_TAIL(&chardevs, chr, next); } chr->label = qemu_strdup(qemu_opts_id(opts)); return chr; @@ -2438,7 +2438,7 @@ CharDriverState *qemu_chr_open(const char *label, const char *filename, void (*i void qemu_chr_close(CharDriverState *chr) { - TAILQ_REMOVE(&chardevs, chr, next); + QTAILQ_REMOVE(&chardevs, chr, next); if (chr->chr_close) chr->chr_close(chr); qemu_free(chr->filename); @@ -2450,7 +2450,7 @@ void qemu_chr_info(Monitor *mon) { CharDriverState *chr; - TAILQ_FOREACH(chr, &chardevs, next) { + QTAILQ_FOREACH(chr, &chardevs, next) { monitor_printf(mon, "%s: filename=%s\n", chr->label, chr->filename); } } @@ -2459,7 +2459,7 @@ CharDriverState *qemu_chr_find(const char *name) { CharDriverState *chr; - TAILQ_FOREACH(chr, &chardevs, next) { + QTAILQ_FOREACH(chr, &chardevs, next) { if (strcmp(chr->label, name) != 0) continue; return chr; diff --git a/qemu-char.h b/qemu-char.h index d12ab11a84..c0654bca25 100644 --- a/qemu-char.h +++ b/qemu-char.h @@ -2,7 +2,7 @@ #define QEMU_CHAR_H #include "qemu-common.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "qemu-option.h" #include "qemu-config.h" @@ -66,7 +66,7 @@ struct CharDriverState { QEMUBH *bh; char *label; char *filename; - TAILQ_ENTRY(CharDriverState) next; + QTAILQ_ENTRY(CharDriverState) next; }; CharDriverState *qemu_chr_open_opts(QemuOpts *opts, diff --git a/qemu-config.c b/qemu-config.c index f6f4cb4828..39bf6a9826 100644 --- a/qemu-config.c +++ b/qemu-config.c @@ -4,7 +4,7 @@ QemuOptsList qemu_drive_opts = { .name = "drive", - .head = TAILQ_HEAD_INITIALIZER(qemu_drive_opts.head), + .head = QTAILQ_HEAD_INITIALIZER(qemu_drive_opts.head), .desc = { { .name = "bus", @@ -77,7 +77,7 @@ QemuOptsList qemu_drive_opts = { QemuOptsList qemu_chardev_opts = { .name = "chardev", - .head = TAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head), + .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head), .desc = { { .name = "backend", @@ -140,7 +140,7 @@ QemuOptsList qemu_chardev_opts = { QemuOptsList qemu_device_opts = { .name = "device", - .head = TAILQ_HEAD_INITIALIZER(qemu_device_opts.head), + .head = QTAILQ_HEAD_INITIALIZER(qemu_device_opts.head), .desc = { /* * no elements => accept any diff --git a/qemu-option.c b/qemu-option.c index 0c2101e3e6..88298e4b51 100644 --- a/qemu-option.c +++ b/qemu-option.c @@ -477,21 +477,21 @@ struct QemuOpt { } value; QemuOpts *opts; - TAILQ_ENTRY(QemuOpt) next; + QTAILQ_ENTRY(QemuOpt) next; }; struct QemuOpts { const char *id; QemuOptsList *list; - TAILQ_HEAD(, QemuOpt) head; - TAILQ_ENTRY(QemuOpts) next; + QTAILQ_HEAD(, QemuOpt) head; + QTAILQ_ENTRY(QemuOpts) next; }; static QemuOpt *qemu_opt_find(QemuOpts *opts, const char *name) { QemuOpt *opt; - TAILQ_FOREACH(opt, &opts->head, next) { + QTAILQ_FOREACH(opt, &opts->head, next) { if (strcmp(opt->name, name) != 0) continue; return opt; @@ -556,7 +556,7 @@ static int qemu_opt_parse(QemuOpt *opt) static void qemu_opt_del(QemuOpt *opt) { - TAILQ_REMOVE(&opt->opts->head, opt, next); + QTAILQ_REMOVE(&opt->opts->head, opt, next); qemu_free((/* !const */ char*)opt->name); qemu_free((/* !const */ char*)opt->str); qemu_free(opt); @@ -588,7 +588,7 @@ int qemu_opt_set(QemuOpts *opts, const char *name, const char *value) opt = qemu_mallocz(sizeof(*opt)); opt->name = qemu_strdup(name); opt->opts = opts; - TAILQ_INSERT_TAIL(&opts->head, opt, next); + QTAILQ_INSERT_TAIL(&opts->head, opt, next); if (desc[i].name != NULL) { opt->desc = desc+i; } @@ -613,7 +613,7 @@ int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque, QemuOpt *opt; int rc = 0; - TAILQ_FOREACH(opt, &opts->head, next) { + QTAILQ_FOREACH(opt, &opts->head, next) { rc = func(opt->name, opt->str, opaque); if (abort_on_failure && rc != 0) break; @@ -625,7 +625,7 @@ QemuOpts *qemu_opts_find(QemuOptsList *list, const char *id) { QemuOpts *opts; - TAILQ_FOREACH(opts, &list->head, next) { + QTAILQ_FOREACH(opts, &list->head, next) { if (!opts->id) { continue; } @@ -658,8 +658,8 @@ QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id, int fail_if_exist opts->id = qemu_strdup(id); } opts->list = list; - TAILQ_INIT(&opts->head); - TAILQ_INSERT_TAIL(&list->head, opts, next); + QTAILQ_INIT(&opts->head); + QTAILQ_INSERT_TAIL(&list->head, opts, next); return opts; } @@ -687,12 +687,12 @@ void qemu_opts_del(QemuOpts *opts) QemuOpt *opt; for (;;) { - opt = TAILQ_FIRST(&opts->head); + opt = QTAILQ_FIRST(&opts->head); if (opt == NULL) break; qemu_opt_del(opt); } - TAILQ_REMOVE(&opts->list->head, opts, next); + QTAILQ_REMOVE(&opts->list->head, opts, next); qemu_free(opts); } @@ -702,7 +702,7 @@ int qemu_opts_print(QemuOpts *opts, void *dummy) fprintf(stderr, "%s: %s:", opts->list->name, opts->id ? opts->id : ""); - TAILQ_FOREACH(opt, &opts->head, next) { + QTAILQ_FOREACH(opt, &opts->head, next) { fprintf(stderr, " %s=\"%s\"", opt->name, opt->str); } fprintf(stderr, "\n"); @@ -788,7 +788,7 @@ int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func, void *opaque, QemuOpts *opts; int rc = 0; - TAILQ_FOREACH(opts, &list->head, next) { + QTAILQ_FOREACH(opts, &list->head, next) { rc = func(opts, opaque); if (abort_on_failure && rc != 0) break; diff --git a/qemu-option.h b/qemu-option.h index 9e52625cc0..6b968a5728 100644 --- a/qemu-option.h +++ b/qemu-option.h @@ -26,7 +26,7 @@ #ifndef QEMU_OPTIONS_H #define QEMU_OPTIONS_H -#include "sys-queue.h" +#include "qemu-queue.h" enum QEMUOptionParType { OPT_FLAG, @@ -95,7 +95,7 @@ typedef struct QemuOptDesc { struct QemuOptsList { const char *name; - TAILQ_HEAD(, QemuOpts) head; + QTAILQ_HEAD(, QemuOpts) head; QemuOptDesc desc[]; }; diff --git a/sys-queue.h b/qemu-queue.h similarity index 81% rename from sys-queue.h rename to qemu-queue.h index eb89a4d217..8877efd7b4 100644 --- a/sys-queue.h +++ b/qemu-queue.h @@ -36,8 +36,8 @@ * @(#)queue.h 8.5 (Berkeley) 8/20/94 */ -#ifndef _SYS_QUEUE_H_ -#define _SYS_QUEUE_H_ +#ifndef QEMU_SYS_QUEUE_H_ +#define QEMU_SYS_QUEUE_H_ /* * This file defines three types of data structures: @@ -71,15 +71,15 @@ /* * List definitions. */ -#define LIST_HEAD(name, type) \ +#define QLIST_HEAD(name, type) \ struct name { \ struct type *lh_first; /* first element */ \ } -#define LIST_HEAD_INITIALIZER(head) \ +#define QLIST_HEAD_INITIALIZER(head) \ { NULL } -#define LIST_ENTRY(type) \ +#define QLIST_ENTRY(type) \ struct { \ struct type *le_next; /* next element */ \ struct type **le_prev; /* address of previous next element */ \ @@ -88,11 +88,11 @@ struct { \ /* * List functions. */ -#define LIST_INIT(head) do { \ +#define QLIST_INIT(head) do { \ (head)->lh_first = NULL; \ } while (/*CONSTCOND*/0) -#define LIST_INSERT_AFTER(listelm, elm, field) do { \ +#define QLIST_INSERT_AFTER(listelm, elm, field) do { \ if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \ (listelm)->field.le_next->field.le_prev = \ &(elm)->field.le_next; \ @@ -100,33 +100,33 @@ struct { \ (elm)->field.le_prev = &(listelm)->field.le_next; \ } while (/*CONSTCOND*/0) -#define LIST_INSERT_BEFORE(listelm, elm, field) do { \ +#define QLIST_INSERT_BEFORE(listelm, elm, field) do { \ (elm)->field.le_prev = (listelm)->field.le_prev; \ (elm)->field.le_next = (listelm); \ *(listelm)->field.le_prev = (elm); \ (listelm)->field.le_prev = &(elm)->field.le_next; \ } while (/*CONSTCOND*/0) -#define LIST_INSERT_HEAD(head, elm, field) do { \ +#define QLIST_INSERT_HEAD(head, elm, field) do { \ if (((elm)->field.le_next = (head)->lh_first) != NULL) \ (head)->lh_first->field.le_prev = &(elm)->field.le_next;\ (head)->lh_first = (elm); \ (elm)->field.le_prev = &(head)->lh_first; \ } while (/*CONSTCOND*/0) -#define LIST_REMOVE(elm, field) do { \ +#define QLIST_REMOVE(elm, field) do { \ if ((elm)->field.le_next != NULL) \ (elm)->field.le_next->field.le_prev = \ (elm)->field.le_prev; \ *(elm)->field.le_prev = (elm)->field.le_next; \ } while (/*CONSTCOND*/0) -#define LIST_FOREACH(var, head, field) \ +#define QLIST_FOREACH(var, head, field) \ for ((var) = ((head)->lh_first); \ (var); \ (var) = ((var)->field.le_next)) -#define LIST_FOREACH_SAFE(var, head, field, next_var) \ +#define QLIST_FOREACH_SAFE(var, head, field, next_var) \ for ((var) = ((head)->lh_first); \ (var) && ((next_var) = ((var)->field.le_next), 1); \ (var) = (next_var)) @@ -134,40 +134,40 @@ struct { \ /* * List access methods. */ -#define LIST_EMPTY(head) ((head)->lh_first == NULL) -#define LIST_FIRST(head) ((head)->lh_first) -#define LIST_NEXT(elm, field) ((elm)->field.le_next) +#define QLIST_EMPTY(head) ((head)->lh_first == NULL) +#define QLIST_FIRST(head) ((head)->lh_first) +#define QLIST_NEXT(elm, field) ((elm)->field.le_next) /* * Tail queue definitions. */ -#define _TAILQ_HEAD(name, type, qual) \ +#define Q_TAILQ_HEAD(name, type, qual) \ struct name { \ qual type *tqh_first; /* first element */ \ qual type *qual *tqh_last; /* addr of last next element */ \ } -#define TAILQ_HEAD(name, type) _TAILQ_HEAD(name, struct type,) +#define QTAILQ_HEAD(name, type) Q_TAILQ_HEAD(name, struct type,) -#define TAILQ_HEAD_INITIALIZER(head) \ +#define QTAILQ_HEAD_INITIALIZER(head) \ { NULL, &(head).tqh_first } -#define _TAILQ_ENTRY(type, qual) \ +#define Q_TAILQ_ENTRY(type, qual) \ struct { \ qual type *tqe_next; /* next element */ \ qual type *qual *tqe_prev; /* address of previous next element */\ } -#define TAILQ_ENTRY(type) _TAILQ_ENTRY(struct type,) +#define QTAILQ_ENTRY(type) Q_TAILQ_ENTRY(struct type,) /* * Tail queue functions. */ -#define TAILQ_INIT(head) do { \ +#define QTAILQ_INIT(head) do { \ (head)->tqh_first = NULL; \ (head)->tqh_last = &(head)->tqh_first; \ } while (/*CONSTCOND*/0) -#define TAILQ_INSERT_HEAD(head, elm, field) do { \ +#define QTAILQ_INSERT_HEAD(head, elm, field) do { \ if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \ (head)->tqh_first->field.tqe_prev = \ &(elm)->field.tqe_next; \ @@ -177,14 +177,14 @@ struct { \ (elm)->field.tqe_prev = &(head)->tqh_first; \ } while (/*CONSTCOND*/0) -#define TAILQ_INSERT_TAIL(head, elm, field) do { \ +#define QTAILQ_INSERT_TAIL(head, elm, field) do { \ (elm)->field.tqe_next = NULL; \ (elm)->field.tqe_prev = (head)->tqh_last; \ *(head)->tqh_last = (elm); \ (head)->tqh_last = &(elm)->field.tqe_next; \ } while (/*CONSTCOND*/0) -#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ +#define QTAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\ (elm)->field.tqe_next->field.tqe_prev = \ &(elm)->field.tqe_next; \ @@ -194,14 +194,14 @@ struct { \ (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \ } while (/*CONSTCOND*/0) -#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ +#define QTAILQ_INSERT_BEFORE(listelm, elm, field) do { \ (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ (elm)->field.tqe_next = (listelm); \ *(listelm)->field.tqe_prev = (elm); \ (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \ } while (/*CONSTCOND*/0) -#define TAILQ_REMOVE(head, elm, field) do { \ +#define QTAILQ_REMOVE(head, elm, field) do { \ if (((elm)->field.tqe_next) != NULL) \ (elm)->field.tqe_next->field.tqe_prev = \ (elm)->field.tqe_prev; \ @@ -210,17 +210,17 @@ struct { \ *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ } while (/*CONSTCOND*/0) -#define TAILQ_FOREACH(var, head, field) \ +#define QTAILQ_FOREACH(var, head, field) \ for ((var) = ((head)->tqh_first); \ (var); \ (var) = ((var)->field.tqe_next)) -#define TAILQ_FOREACH_SAFE(var, head, field, next_var) \ +#define QTAILQ_FOREACH_SAFE(var, head, field, next_var) \ for ((var) = ((head)->tqh_first); \ (var) && ((next_var) = ((var)->field.tqe_next), 1); \ (var) = (next_var)) -#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ +#define QTAILQ_FOREACH_REVERSE(var, head, headname, field) \ for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last)); \ (var); \ (var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last))) @@ -228,29 +228,29 @@ struct { \ /* * Tail queue access methods. */ -#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL) -#define TAILQ_FIRST(head) ((head)->tqh_first) -#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) +#define QTAILQ_EMPTY(head) ((head)->tqh_first == NULL) +#define QTAILQ_FIRST(head) ((head)->tqh_first) +#define QTAILQ_NEXT(elm, field) ((elm)->field.tqe_next) -#define TAILQ_LAST(head, headname) \ +#define QTAILQ_LAST(head, headname) \ (*(((struct headname *)((head)->tqh_last))->tqh_last)) -#define TAILQ_PREV(elm, headname, field) \ +#define QTAILQ_PREV(elm, headname, field) \ (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) /* * Circular queue definitions. */ -#define CIRCLEQ_HEAD(name, type) \ +#define QCIRCLEQ_HEAD(name, type) \ struct name { \ struct type *cqh_first; /* first element */ \ struct type *cqh_last; /* last element */ \ } -#define CIRCLEQ_HEAD_INITIALIZER(head) \ +#define QCIRCLEQ_HEAD_INITIALIZER(head) \ { (void *)&head, (void *)&head } -#define CIRCLEQ_ENTRY(type) \ +#define QCIRCLEQ_ENTRY(type) \ struct { \ struct type *cqe_next; /* next element */ \ struct type *cqe_prev; /* previous element */ \ @@ -259,12 +259,12 @@ struct { \ /* * Circular queue functions. */ -#define CIRCLEQ_INIT(head) do { \ +#define QCIRCLEQ_INIT(head) do { \ (head)->cqh_first = (void *)(head); \ (head)->cqh_last = (void *)(head); \ } while (/*CONSTCOND*/0) -#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ +#define QCIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ (elm)->field.cqe_next = (listelm)->field.cqe_next; \ (elm)->field.cqe_prev = (listelm); \ if ((listelm)->field.cqe_next == (void *)(head)) \ @@ -274,7 +274,7 @@ struct { \ (listelm)->field.cqe_next = (elm); \ } while (/*CONSTCOND*/0) -#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \ +#define QCIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \ (elm)->field.cqe_next = (listelm); \ (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \ if ((listelm)->field.cqe_prev == (void *)(head)) \ @@ -284,7 +284,7 @@ struct { \ (listelm)->field.cqe_prev = (elm); \ } while (/*CONSTCOND*/0) -#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \ +#define QCIRCLEQ_INSERT_HEAD(head, elm, field) do { \ (elm)->field.cqe_next = (head)->cqh_first; \ (elm)->field.cqe_prev = (void *)(head); \ if ((head)->cqh_last == (void *)(head)) \ @@ -294,7 +294,7 @@ struct { \ (head)->cqh_first = (elm); \ } while (/*CONSTCOND*/0) -#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \ +#define QCIRCLEQ_INSERT_TAIL(head, elm, field) do { \ (elm)->field.cqe_next = (void *)(head); \ (elm)->field.cqe_prev = (head)->cqh_last; \ if ((head)->cqh_first == (void *)(head)) \ @@ -304,7 +304,7 @@ struct { \ (head)->cqh_last = (elm); \ } while (/*CONSTCOND*/0) -#define CIRCLEQ_REMOVE(head, elm, field) do { \ +#define QCIRCLEQ_REMOVE(head, elm, field) do { \ if ((elm)->field.cqe_next == (void *)(head)) \ (head)->cqh_last = (elm)->field.cqe_prev; \ else \ @@ -317,12 +317,12 @@ struct { \ (elm)->field.cqe_next; \ } while (/*CONSTCOND*/0) -#define CIRCLEQ_FOREACH(var, head, field) \ +#define QCIRCLEQ_FOREACH(var, head, field) \ for ((var) = ((head)->cqh_first); \ (var) != (const void *)(head); \ (var) = ((var)->field.cqe_next)) -#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \ +#define QCIRCLEQ_FOREACH_REVERSE(var, head, field) \ for ((var) = ((head)->cqh_last); \ (var) != (const void *)(head); \ (var) = ((var)->field.cqe_prev)) @@ -330,19 +330,19 @@ struct { \ /* * Circular queue access methods. */ -#define CIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head)) -#define CIRCLEQ_FIRST(head) ((head)->cqh_first) -#define CIRCLEQ_LAST(head) ((head)->cqh_last) -#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next) -#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev) +#define QCIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head)) +#define QCIRCLEQ_FIRST(head) ((head)->cqh_first) +#define QCIRCLEQ_LAST(head) ((head)->cqh_last) +#define QCIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next) +#define QCIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev) -#define CIRCLEQ_LOOP_NEXT(head, elm, field) \ +#define QCIRCLEQ_LOOP_NEXT(head, elm, field) \ (((elm)->field.cqe_next == (void *)(head)) \ ? ((head)->cqh_first) \ : (elm->field.cqe_next)) -#define CIRCLEQ_LOOP_PREV(head, elm, field) \ +#define QCIRCLEQ_LOOP_PREV(head, elm, field) \ (((elm)->field.cqe_prev == (void *)(head)) \ ? ((head)->cqh_last) \ : (elm->field.cqe_prev)) -#endif /* !_SYS_QUEUE_H_ */ +#endif /* !QEMU_SYS_QUEUE_H_ */ diff --git a/qemu-sockets.c b/qemu-sockets.c index b80279c867..3cdff4c206 100644 --- a/qemu-sockets.c +++ b/qemu-sockets.c @@ -32,7 +32,7 @@ static const int on=1, off=0; /* used temporarely until all users are converted to QemuOpts */ QemuOptsList dummy_opts = { .name = "dummy", - .head = TAILQ_HEAD_INITIALIZER(dummy_opts.head), + .head = QTAILQ_HEAD_INITIALIZER(dummy_opts.head), .desc = { { .name = "path", diff --git a/savevm.c b/savevm.c index dd82bd87c1..fd767be2cd 100644 --- a/savevm.c +++ b/savevm.c @@ -31,8 +31,6 @@ /* Needed early for CONFIG_BSD etc. */ #include "config-host.h" -/* Needed early to override system queue definitions on BSD */ -#include "sys-queue.h" #ifndef _WIN32 #include @@ -92,6 +90,7 @@ #include "audio/audio.h" #include "migration.h" #include "qemu_socket.h" +#include "qemu-queue.h" /* point to the block driver where the snapshots are managed */ static BlockDriverState *bs_snapshots; @@ -912,7 +911,7 @@ const VMStateInfo vmstate_info_buffer = { }; typedef struct SaveStateEntry { - TAILQ_ENTRY(SaveStateEntry) entry; + QTAILQ_ENTRY(SaveStateEntry) entry; char idstr[256]; int instance_id; int version_id; @@ -924,8 +923,8 @@ typedef struct SaveStateEntry { void *opaque; } SaveStateEntry; -static TAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers = - TAILQ_HEAD_INITIALIZER(savevm_handlers); +static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers = + QTAILQ_HEAD_INITIALIZER(savevm_handlers); static int global_section_id; static int calculate_new_instance_id(const char *idstr) @@ -933,7 +932,7 @@ static int calculate_new_instance_id(const char *idstr) SaveStateEntry *se; int instance_id = 0; - TAILQ_FOREACH(se, &savevm_handlers, entry) { + QTAILQ_FOREACH(se, &savevm_handlers, entry) { if (strcmp(idstr, se->idstr) == 0 && instance_id <= se->instance_id) { instance_id = se->instance_id + 1; @@ -972,7 +971,7 @@ int register_savevm_live(const char *idstr, se->instance_id = instance_id; } /* add at the end of list */ - TAILQ_INSERT_TAIL(&savevm_handlers, se, entry); + QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry); return 0; } @@ -991,9 +990,9 @@ void unregister_savevm(const char *idstr, void *opaque) { SaveStateEntry *se, *new_se; - TAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) { + QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) { if (strcmp(se->idstr, idstr) == 0 && se->opaque == opaque) { - TAILQ_REMOVE(&savevm_handlers, se, entry); + QTAILQ_REMOVE(&savevm_handlers, se, entry); qemu_free(se); } } @@ -1020,7 +1019,7 @@ int vmstate_register(int instance_id, const VMStateDescription *vmsd, se->instance_id = instance_id; } /* add at the end of list */ - TAILQ_INSERT_TAIL(&savevm_handlers, se, entry); + QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry); return 0; } @@ -1028,9 +1027,9 @@ void vmstate_unregister(const VMStateDescription *vmsd, void *opaque) { SaveStateEntry *se, *new_se; - TAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) { + QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) { if (se->vmsd == vmsd && se->opaque == opaque) { - TAILQ_REMOVE(&savevm_handlers, se, entry); + QTAILQ_REMOVE(&savevm_handlers, se, entry); qemu_free(se); } } @@ -1160,7 +1159,7 @@ int qemu_savevm_state_begin(QEMUFile *f) qemu_put_be32(f, QEMU_VM_FILE_MAGIC); qemu_put_be32(f, QEMU_VM_FILE_VERSION); - TAILQ_FOREACH(se, &savevm_handlers, entry) { + QTAILQ_FOREACH(se, &savevm_handlers, entry) { int len; if (se->save_live_state == NULL) @@ -1192,7 +1191,7 @@ int qemu_savevm_state_iterate(QEMUFile *f) SaveStateEntry *se; int ret = 1; - TAILQ_FOREACH(se, &savevm_handlers, entry) { + QTAILQ_FOREACH(se, &savevm_handlers, entry) { if (se->save_live_state == NULL) continue; @@ -1216,7 +1215,7 @@ int qemu_savevm_state_complete(QEMUFile *f) { SaveStateEntry *se; - TAILQ_FOREACH(se, &savevm_handlers, entry) { + QTAILQ_FOREACH(se, &savevm_handlers, entry) { if (se->save_live_state == NULL) continue; @@ -1227,7 +1226,7 @@ int qemu_savevm_state_complete(QEMUFile *f) se->save_live_state(f, QEMU_VM_SECTION_END, se->opaque); } - TAILQ_FOREACH(se, &savevm_handlers, entry) { + QTAILQ_FOREACH(se, &savevm_handlers, entry) { int len; if (se->save_state == NULL && se->vmsd == NULL) @@ -1292,7 +1291,7 @@ static SaveStateEntry *find_se(const char *idstr, int instance_id) { SaveStateEntry *se; - TAILQ_FOREACH(se, &savevm_handlers, entry) { + QTAILQ_FOREACH(se, &savevm_handlers, entry) { if (!strcmp(se->idstr, idstr) && instance_id == se->instance_id) return se; @@ -1301,7 +1300,7 @@ static SaveStateEntry *find_se(const char *idstr, int instance_id) } typedef struct LoadStateEntry { - LIST_ENTRY(LoadStateEntry) entry; + QLIST_ENTRY(LoadStateEntry) entry; SaveStateEntry *se; int section_id; int version_id; @@ -1309,8 +1308,8 @@ typedef struct LoadStateEntry { int qemu_loadvm_state(QEMUFile *f) { - LIST_HEAD(, LoadStateEntry) loadvm_handlers = - LIST_HEAD_INITIALIZER(loadvm_handlers); + QLIST_HEAD(, LoadStateEntry) loadvm_handlers = + QLIST_HEAD_INITIALIZER(loadvm_handlers); LoadStateEntry *le, *new_le; uint8_t section_type; unsigned int v; @@ -1367,7 +1366,7 @@ int qemu_loadvm_state(QEMUFile *f) le->se = se; le->section_id = section_id; le->version_id = version_id; - LIST_INSERT_HEAD(&loadvm_handlers, le, entry); + QLIST_INSERT_HEAD(&loadvm_handlers, le, entry); ret = vmstate_load(f, le->se, le->version_id); if (ret < 0) { @@ -1380,7 +1379,7 @@ int qemu_loadvm_state(QEMUFile *f) case QEMU_VM_SECTION_END: section_id = qemu_get_be32(f); - LIST_FOREACH(le, &loadvm_handlers, entry) { + QLIST_FOREACH(le, &loadvm_handlers, entry) { if (le->section_id == section_id) { break; } @@ -1408,8 +1407,8 @@ int qemu_loadvm_state(QEMUFile *f) ret = 0; out: - LIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) { - LIST_REMOVE(le, entry); + QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) { + QLIST_REMOVE(le, entry); qemu_free(le); } @@ -1442,7 +1441,7 @@ static BlockDriverState *get_bs_snapshots(void) if (bs_snapshots) return bs_snapshots; - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { bs = dinfo->bdrv; if (bdrv_can_snapshot(bs)) goto ok; @@ -1547,7 +1546,7 @@ void do_savevm(Monitor *mon, const QDict *qdict) /* create the snapshots */ - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { bs1 = dinfo->bdrv; if (bdrv_has_snapshot(bs1)) { if (must_delete) { @@ -1590,7 +1589,7 @@ int load_vmstate(Monitor *mon, const char *name) /* Flush all IO requests so they don't interfere with the new state. */ qemu_aio_flush(); - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { bs1 = dinfo->bdrv; if (bdrv_has_snapshot(bs1)) { ret = bdrv_snapshot_goto(bs1, name); @@ -1653,7 +1652,7 @@ void do_delvm(Monitor *mon, const QDict *qdict) return; } - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { bs1 = dinfo->bdrv; if (bdrv_has_snapshot(bs1)) { ret = bdrv_snapshot_delete(bs1, name); @@ -1684,7 +1683,7 @@ void do_info_snapshots(Monitor *mon) return; } monitor_printf(mon, "Snapshot devices:"); - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { bs1 = dinfo->bdrv; if (bdrv_has_snapshot(bs1)) { if (bs == bs1) diff --git a/slirp/slirp.c b/slirp/slirp.c index d4a9bacf17..6731f529f6 100644 --- a/slirp/slirp.c +++ b/slirp/slirp.c @@ -44,8 +44,8 @@ u_int curtime; static u_int time_fasttimo, last_slowtimo; static int do_slowtimo; -static TAILQ_HEAD(slirp_instances, Slirp) slirp_instances = - TAILQ_HEAD_INITIALIZER(slirp_instances); +static QTAILQ_HEAD(slirp_instances, Slirp) slirp_instances = + QTAILQ_HEAD_INITIALIZER(slirp_instances); static struct in_addr dns_addr; static u_int dns_addr_time; @@ -234,14 +234,14 @@ Slirp *slirp_init(int restricted, struct in_addr vnetwork, register_savevm("slirp", 0, 3, slirp_state_save, slirp_state_load, slirp); - TAILQ_INSERT_TAIL(&slirp_instances, slirp, entry); + QTAILQ_INSERT_TAIL(&slirp_instances, slirp, entry); return slirp; } void slirp_cleanup(Slirp *slirp) { - TAILQ_REMOVE(&slirp_instances, slirp, entry); + QTAILQ_REMOVE(&slirp_instances, slirp, entry); unregister_savevm("slirp", slirp); @@ -261,7 +261,7 @@ void slirp_select_fill(int *pnfds, struct socket *so, *so_next; int nfds; - if (TAILQ_EMPTY(&slirp_instances)) { + if (QTAILQ_EMPTY(&slirp_instances)) { return; } @@ -276,7 +276,7 @@ void slirp_select_fill(int *pnfds, */ do_slowtimo = 0; - TAILQ_FOREACH(slirp, &slirp_instances, entry) { + QTAILQ_FOREACH(slirp, &slirp_instances, entry) { /* * *_slowtimo needs calling if there are IP fragments * in the fragment queue, or there are TCP connections active @@ -384,7 +384,7 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds, struct socket *so, *so_next; int ret; - if (TAILQ_EMPTY(&slirp_instances)) { + if (QTAILQ_EMPTY(&slirp_instances)) { return; } @@ -394,7 +394,7 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds, curtime = qemu_get_clock(rt_clock); - TAILQ_FOREACH(slirp, &slirp_instances, entry) { + QTAILQ_FOREACH(slirp, &slirp_instances, entry) { /* * See if anything has timed out */ diff --git a/slirp/slirp.h b/slirp/slirp.h index 020412caf3..9ef57ea394 100644 --- a/slirp/slirp.h +++ b/slirp/slirp.h @@ -174,7 +174,7 @@ int inet_aton(const char *cp, struct in_addr *ia); #include "debug.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "libslirp.h" #include "ip.h" @@ -198,7 +198,7 @@ int inet_aton(const char *cp, struct in_addr *ia); #include "tftp.h" struct Slirp { - TAILQ_ENTRY(Slirp) entry; + QTAILQ_ENTRY(Slirp) entry; /* virtual network configuration */ struct in_addr vnetwork_addr; diff --git a/sysemu.h b/sysemu.h index ac16c2105a..a96b168793 100644 --- a/sysemu.h +++ b/sysemu.h @@ -4,7 +4,7 @@ #include "qemu-common.h" #include "qemu-option.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "qdict.h" #ifdef _WIN32 @@ -174,15 +174,15 @@ typedef struct DriveInfo { QemuOpts *opts; BlockInterfaceErrorAction onerror; char serial[BLOCK_SERIAL_STRLEN + 1]; - TAILQ_ENTRY(DriveInfo) next; + QTAILQ_ENTRY(DriveInfo) next; } DriveInfo; #define MAX_IDE_DEVS 2 #define MAX_SCSI_DEVS 7 #define MAX_DRIVES 32 -extern TAILQ_HEAD(drivelist, DriveInfo) drives; -extern TAILQ_HEAD(driveoptlist, DriveOpt) driveopts; +extern QTAILQ_HEAD(drivelist, DriveInfo) drives; +extern QTAILQ_HEAD(driveoptlist, DriveOpt) driveopts; extern DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit); extern DriveInfo *drive_get_by_id(const char *id); diff --git a/target-alpha/translate.c b/target-alpha/translate.c index 1dd85629b3..9d2bc45d86 100644 --- a/target-alpha/translate.c +++ b/target-alpha/translate.c @@ -2367,8 +2367,8 @@ static inline void gen_intermediate_code_internal(CPUState *env, gen_icount_start(); for (ret = 0; ret == 0;) { - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == ctx.pc) { gen_excp(&ctx, EXCP_DEBUG, 0); break; diff --git a/target-arm/translate.c b/target-arm/translate.c index 4db8d0e262..c1d0dcf166 100644 --- a/target-arm/translate.c +++ b/target-arm/translate.c @@ -8770,8 +8770,8 @@ static inline void gen_intermediate_code_internal(CPUState *env, } #endif - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == dc->pc) { gen_set_condexec(dc); gen_set_pc_im(dc->pc); diff --git a/target-cris/translate.c b/target-cris/translate.c index bd3ae3d763..c6068f78f8 100644 --- a/target-cris/translate.c +++ b/target-cris/translate.c @@ -3082,8 +3082,8 @@ static void check_breakpoint(CPUState *env, DisasContext *dc) { CPUBreakpoint *bp; - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == dc->pc) { cris_evaluate_flags (dc); tcg_gen_movi_tl(env_pc, dc->pc); diff --git a/target-i386/helper.c b/target-i386/helper.c index 8abbed0a6f..45b04eeb03 100644 --- a/target-i386/helper.c +++ b/target-i386/helper.c @@ -1522,7 +1522,7 @@ static void breakpoint_handler(CPUState *env) cpu_resume_from_signal(env, NULL); } } else { - TAILQ_FOREACH(bp, &env->breakpoints, entry) + QTAILQ_FOREACH(bp, &env->breakpoints, entry) if (bp->pc == env->eip) { if (bp->flags & BP_CPU) { check_hw_breakpoints(env, 1); diff --git a/target-i386/translate.c b/target-i386/translate.c index ff93985754..335fc08421 100644 --- a/target-i386/translate.c +++ b/target-i386/translate.c @@ -7687,8 +7687,8 @@ static inline void gen_intermediate_code_internal(CPUState *env, gen_icount_start(); for(;;) { - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == pc_ptr && !((bp->flags & BP_CPU) && (tb->flags & HF_RF_MASK))) { gen_debug(dc, pc_ptr - dc->cs_base); diff --git a/target-m68k/translate.c b/target-m68k/translate.c index b37578baf9..99cf6ddef7 100644 --- a/target-m68k/translate.c +++ b/target-m68k/translate.c @@ -2999,8 +2999,8 @@ gen_intermediate_code_internal(CPUState *env, TranslationBlock *tb, do { pc_offset = dc->pc - pc_start; gen_throws_exception = NULL; - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == dc->pc) { gen_exception(dc, dc->pc, EXCP_DEBUG); dc->is_jmp = DISAS_JUMP; diff --git a/target-microblaze/translate.c b/target-microblaze/translate.c index fe53b2e141..dfeb8ae848 100644 --- a/target-microblaze/translate.c +++ b/target-microblaze/translate.c @@ -1230,8 +1230,8 @@ static void check_breakpoint(CPUState *env, DisasContext *dc) { CPUBreakpoint *bp; - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == dc->pc) { t_gen_raise_exception(dc, EXCP_DEBUG); dc->is_jmp = DISAS_UPDATE; diff --git a/target-mips/translate.c b/target-mips/translate.c index a2b2edbbd2..fb3c980c18 100644 --- a/target-mips/translate.c +++ b/target-mips/translate.c @@ -8314,8 +8314,8 @@ gen_intermediate_code_internal (CPUState *env, TranslationBlock *tb, LOG_DISAS("\ntb %p idx %d hflags %04x\n", tb, ctx.mem_idx, ctx.hflags); gen_icount_start(); while (ctx.bstate == BS_NONE) { - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == ctx.pc) { save_cpu_state(&ctx, 1); ctx.bstate = BS_BRANCH; diff --git a/target-ppc/translate.c b/target-ppc/translate.c index 1c54fa7d85..648bf9e187 100644 --- a/target-ppc/translate.c +++ b/target-ppc/translate.c @@ -9000,8 +9000,8 @@ static inline void gen_intermediate_code_internal(CPUState *env, gen_icount_start(); /* Set env in case of segfault during code fetch */ while (ctx.exception == POWERPC_EXCP_NONE && gen_opc_ptr < gen_opc_end) { - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == ctx.nip) { gen_debug_exception(ctxp); break; diff --git a/target-sh4/translate.c b/target-sh4/translate.c index b272f4c06e..895b978d38 100644 --- a/target-sh4/translate.c +++ b/target-sh4/translate.c @@ -1927,8 +1927,8 @@ gen_intermediate_code_internal(CPUState * env, TranslationBlock * tb, max_insns = CF_COUNT_MASK; gen_icount_start(); while (ctx.bstate == BS_NONE && gen_opc_ptr < gen_opc_end) { - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (ctx.pc == bp->pc) { /* We have hit a breakpoint - make sure PC is up-to-date */ tcg_gen_movi_i32(cpu_pc, ctx.pc); diff --git a/target-sparc/translate.c b/target-sparc/translate.c index 61578ecc3c..928aa61ad2 100644 --- a/target-sparc/translate.c +++ b/target-sparc/translate.c @@ -4706,8 +4706,8 @@ static inline void gen_intermediate_code_internal(TranslationBlock * tb, max_insns = CF_COUNT_MASK; gen_icount_start(); do { - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == dc->pc) { if (dc->pc != pc_start) save_state(dc, cpu_cond); diff --git a/vl.c b/vl.c index 1f95a37c18..0e6133316a 100644 --- a/vl.c +++ b/vl.c @@ -31,8 +31,6 @@ /* Needed early for CONFIG_BSD etc. */ #include "config-host.h" -/* Needed early to override system queue definitions on BSD */ -#include "sys-queue.h" #ifndef _WIN32 #include @@ -168,6 +166,8 @@ int main(int argc, char **argv) #include "slirp/libslirp.h" +#include "qemu-queue.h" + //#define DEBUG_NET //#define DEBUG_SLIRP @@ -180,8 +180,8 @@ static const char *data_dir; const char *bios_name = NULL; /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available to store the VM snapshots */ -struct drivelist drives = TAILQ_HEAD_INITIALIZER(drives); -struct driveoptlist driveopts = TAILQ_HEAD_INITIALIZER(driveopts); +struct drivelist drives = QTAILQ_HEAD_INITIALIZER(drives); +struct driveoptlist driveopts = QTAILQ_HEAD_INITIALIZER(driveopts); enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB; static DisplayState *display_state; DisplayType display_type = DT_DEFAULT; @@ -1810,7 +1810,7 @@ DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit) /* seek interface, bus and unit */ - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { if (dinfo->type == type && dinfo->bus == bus && dinfo->unit == unit) @@ -1824,7 +1824,7 @@ DriveInfo *drive_get_by_id(const char *id) { DriveInfo *dinfo; - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { if (strcmp(id, dinfo->id)) continue; return dinfo; @@ -1838,7 +1838,7 @@ int drive_get_max_bus(BlockInterfaceType type) DriveInfo *dinfo; max_bus = -1; - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { if(dinfo->type == type && dinfo->bus > max_bus) max_bus = dinfo->bus; @@ -1850,7 +1850,7 @@ const char *drive_get_serial(BlockDriverState *bdrv) { DriveInfo *dinfo; - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { if (dinfo->bdrv == bdrv) return dinfo->serial; } @@ -1862,7 +1862,7 @@ BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv) { DriveInfo *dinfo; - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { if (dinfo->bdrv == bdrv) return dinfo->onerror; } @@ -1879,11 +1879,11 @@ void drive_uninit(BlockDriverState *bdrv) { DriveInfo *dinfo; - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { if (dinfo->bdrv != bdrv) continue; qemu_opts_del(dinfo->opts); - TAILQ_REMOVE(&drives, dinfo, next); + QTAILQ_REMOVE(&drives, dinfo, next); qemu_free(dinfo); break; } @@ -2170,7 +2170,7 @@ DriveInfo *drive_init(QemuOpts *opts, void *opaque, dinfo->opts = opts; if (serial) strncpy(dinfo->serial, serial, sizeof(serial)); - TAILQ_INSERT_TAIL(&drives, dinfo, next); + QTAILQ_INSERT_TAIL(&drives, dinfo, next); switch(type) { case IF_IDE: @@ -3145,10 +3145,10 @@ static void nographic_update(void *opaque) struct vm_change_state_entry { VMChangeStateHandler *cb; void *opaque; - LIST_ENTRY (vm_change_state_entry) entries; + QLIST_ENTRY (vm_change_state_entry) entries; }; -static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head; +static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head; VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb, void *opaque) @@ -3159,13 +3159,13 @@ VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb, e->cb = cb; e->opaque = opaque; - LIST_INSERT_HEAD(&vm_change_state_head, e, entries); + QLIST_INSERT_HEAD(&vm_change_state_head, e, entries); return e; } void qemu_del_vm_change_state_handler(VMChangeStateEntry *e) { - LIST_REMOVE (e, entries); + QLIST_REMOVE (e, entries); qemu_free (e); } @@ -3195,13 +3195,13 @@ void vm_start(void) /* reset/shutdown handler */ typedef struct QEMUResetEntry { - TAILQ_ENTRY(QEMUResetEntry) entry; + QTAILQ_ENTRY(QEMUResetEntry) entry; QEMUResetHandler *func; void *opaque; } QEMUResetEntry; -static TAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers = - TAILQ_HEAD_INITIALIZER(reset_handlers); +static QTAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers = + QTAILQ_HEAD_INITIALIZER(reset_handlers); static int reset_requested; static int shutdown_requested; static int powerdown_requested; @@ -3259,16 +3259,16 @@ void qemu_register_reset(QEMUResetHandler *func, void *opaque) re->func = func; re->opaque = opaque; - TAILQ_INSERT_TAIL(&reset_handlers, re, entry); + QTAILQ_INSERT_TAIL(&reset_handlers, re, entry); } void qemu_unregister_reset(QEMUResetHandler *func, void *opaque) { QEMUResetEntry *re; - TAILQ_FOREACH(re, &reset_handlers, entry) { + QTAILQ_FOREACH(re, &reset_handlers, entry) { if (re->func == func && re->opaque == opaque) { - TAILQ_REMOVE(&reset_handlers, re, entry); + QTAILQ_REMOVE(&reset_handlers, re, entry); qemu_free(re); return; } @@ -3280,7 +3280,7 @@ void qemu_system_reset(void) QEMUResetEntry *re, *nre; /* reset all devices */ - TAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) { + QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) { re->func(re->opaque); } } @@ -4579,9 +4579,9 @@ struct device_config { DEV_BT, /* -bt */ } type; const char *cmdline; - TAILQ_ENTRY(device_config) next; + QTAILQ_ENTRY(device_config) next; }; -TAILQ_HEAD(, device_config) device_configs = TAILQ_HEAD_INITIALIZER(device_configs); +QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs); static void add_device_config(int type, const char *cmdline) { @@ -4590,7 +4590,7 @@ static void add_device_config(int type, const char *cmdline) conf = qemu_mallocz(sizeof(*conf)); conf->type = type; conf->cmdline = cmdline; - TAILQ_INSERT_TAIL(&device_configs, conf, next); + QTAILQ_INSERT_TAIL(&device_configs, conf, next); } static int foreach_device_config(int type, int (*func)(const char *cmdline)) @@ -4598,7 +4598,7 @@ static int foreach_device_config(int type, int (*func)(const char *cmdline)) struct device_config *conf; int rc; - TAILQ_FOREACH(conf, &device_configs, next) { + QTAILQ_FOREACH(conf, &device_configs, next) { if (conf->type != type) continue; rc = func(conf->cmdline); @@ -4655,7 +4655,7 @@ int main(int argc, char **argv, char **envp) qemu_errors_to_file(stderr); qemu_cache_utils_init(envp); - LIST_INIT (&vm_change_state_head); + QLIST_INIT (&vm_change_state_head); #ifndef _WIN32 { struct sigaction act;