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;
{
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;
* 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);
}
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;
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;
}
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;
}
}
#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;
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;
};
#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
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;
* 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);
}
}
/* 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;
*/
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);
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.
/* 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;
}
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);
}
}
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:
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);
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);
"(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);
}
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);
}
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 {
}
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;
[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))) {
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) {
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;
#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);
typedef struct CaptureState {
void *opaque;
struct capture_ops ops;
- LIST_ENTRY (CaptureState) entries;
+ QLIST_ENTRY (CaptureState) entries;
} CaptureState;
typedef struct SWVoiceOut SWVoiceOut;
typedef struct QEMUSoundCard {
char *name;
- LIST_ENTRY (QEMUSoundCard) entries;
+ QLIST_ENTRY (QEMUSoundCard) entries;
} QEMUSoundCard;
typedef struct QEMUAudioTimeStamp {
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 {
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 {
char *name;
struct mixeng_volume vol;
struct audio_callback callback;
- LIST_ENTRY (SWVoiceOut) entries;
+ QLIST_ENTRY (SWVoiceOut) entries;
};
struct SWVoiceIn {
char *name;
struct mixeng_volume vol;
struct audio_callback callback;
- LIST_ENTRY (SWVoiceIn) entries;
+ QLIST_ENTRY (SWVoiceIn) entries;
};
struct audio_driver {
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 {
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;
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)
#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);
}
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;
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);
* THE SOFTWARE.
*/
#include "config-host.h"
-#ifdef CONFIG_BSD
-/* include native header before sys-queue.h */
-#include <sys/queue.h>
-#endif
-
#include "qemu-common.h"
#include "monitor.h"
#include "block_int.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
+#include <sys/queue.h>
#ifndef __DragonFly__
#include <sys/disk.h>
#endif
* 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;
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 */
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)
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)
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;
}
/* 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)
*/
}
/* 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)
/* 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;
}
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);
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;
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)
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);
#include <inttypes.h>
#include <signal.h>
#include "osdep.h"
-#include "sys-queue.h"
+#include "qemu-queue.h"
#include "targphys.h"
#ifndef TARGET_LONG_BITS
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
\
/* 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; \
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)
-#include <sys/queue.h>
-
#include <assert.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
+#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 */
};
if ((envlist = malloc(sizeof (*envlist))) == NULL)
return (NULL);
- LIST_INIT(&envlist->el_entries);
+ QLIST_INIT(&envlist->el_entries);
envlist->el_count = 0;
return (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);
}
if (entry != NULL) {
- LIST_REMOVE(entry, ev_link);
+ QLIST_REMOVE(entry, ev_link);
free((char *)entry->ev_var);
free(entry);
} else {
free(entry);
return (errno);
}
- LIST_INSERT_HEAD(&envlist->el_entries, entry, ev_link);
+ QLIST_INSERT_HEAD(&envlist->el_entries, entry, ev_link);
return (0);
}
break;
}
if (entry != NULL) {
- LIST_REMOVE(entry, ev_link);
+ QLIST_REMOVE(entry, ev_link);
free((char *)entry->ev_var);
free(entry);
}
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();
/* 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);
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);
/* 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);
{
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);
}
/* 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);
#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;
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);
#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);
}
/* 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);
}
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
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;
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))
{
client->opaque = opaque;
client->callback = callback;
- LIST_INSERT_HEAD(&map_client_list, client, link);
+ QLIST_INSERT_HEAD(&map_client_list, client, link);
return client;
}
{
MapClient *client = (MapClient *)_client;
- LIST_REMOVE(client, link);
+ QLIST_REMOVE(client, link);
qemu_free(client);
}
{
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);
}
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)) {
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;
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;
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;
}
#endif
if (dev->info->reset)
qemu_unregister_reset(dev->info->reset, dev);
- LIST_REMOVE(dev, sibling);
+ QLIST_REMOVE(dev, sibling);
qemu_free(dev);
}
{
BusState *bus;
- LIST_FOREACH(bus, &dev->child_bus, sibling) {
+ QLIST_FOREACH(bus, &dev->child_bus, sibling) {
if (strcmp(name, bus->name) == 0) {
return bus;
}
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;
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 = ", ";
}
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)
{
BusState *child;
- LIST_FOREACH(child, &dev->child_bus, sibling) {
+ QLIST_FOREACH(child, &dev->child_bus, sibling) {
if (strcmp(child->name, elem) == 0) {
return child;
}
* (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;
}
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",
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;
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);
}
}
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);
}
}
#include "hw.h"
#include "sysemu.h"
-#include "sys-queue.h"
+#include "qemu-queue.h"
#include "qemu-char.h"
#include "qemu-option.h"
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);
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 {
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");
}
{
DeviceState *dev;
SSISlave *slave;
- dev = LIST_FIRST(&bus->qbus.children);
+ dev = QLIST_FIRST(&bus->qbus.children);
if (!dev) {
return 0;
}
.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)
{
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;
}
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;
}
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++;
}
}
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++;
}
if (!bus)
return -1;
- TAILQ_FOREACH(port, &bus->used, next) {
+ QTAILQ_FOREACH(port, &bus->used, next) {
if (port->dev->addr == addr)
break;
}
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;
}
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;
#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.
#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];
};
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,
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);
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];
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);
}
}
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 */
#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 */
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);
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);
#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"
#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:
/* -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);
}
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);
}
#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;
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;
/* ------------------------------------------------------------- */
{
struct XenDevice *xendev;
- TAILQ_FOREACH(xendev, &xendevs, next) {
+ QTAILQ_FOREACH(xendev, &xendevs, next) {
if (xendev->dom != dom)
continue;
if (xendev->dev != dev)
xendev->gnttabdev = -1;
}
- TAILQ_INSERT_TAIL(&xendevs, xendev, next);
+ QTAILQ_INSERT_TAIL(&xendevs, xendev, next);
if (xendev->ops->alloc)
xendev->ops->alloc(xendev);
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;
if (xendev->gnttabdev >= 0)
xc_gnttab_close(xendev->gnttabdev);
- TAILQ_REMOVE(&xendevs, xendev, next);
+ QTAILQ_REMOVE(&xendevs, xendev, next);
qemu_free(xendev);
}
return NULL;
int gnttabdev;
struct XenDevOps *ops;
- TAILQ_ENTRY(XenDevice) next;
+ QTAILQ_ENTRY(XenDevice) next;
};
/* ------------------------------------------------------------- */
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)
{
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);
}
}
int aio_errors;
struct XenBlkDev *blkdev;
- LIST_ENTRY(ioreq) list;
+ QLIST_ENTRY(ioreq) list;
};
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;
{
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 */
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:
{
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++;
}
{
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--;
}
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);
}
{
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;
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);
}
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;
{
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;
}
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 {
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);
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);
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) {
#define QEMU_KVM_H
#include "config.h"
-#include "sys-queue.h"
+#include "qemu-queue.h"
#ifdef CONFIG_KVM
extern int kvm_allowed;
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);
/* 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 */
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
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 */
};
return (NULL);
mm->mm_count = 0;
- TAILQ_INIT(&mm->mm_mmap);
+ QTAILQ_INIT(&mm->mm_mmap);
return (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);
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);
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)
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]);
}
(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)
{
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);
}
#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
*/
#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];
}
for (i = 0; i < MODULE_INIT_MAX; i++) {
- TAILQ_INIT(&init_type_list[i]);
+ QTAILQ_INIT(&init_type_list[i]);
}
inited = 1;
l = find_type(type);
- TAILQ_INSERT_TAIL(l, e, node);
+ QTAILQ_INSERT_TAIL(l, e, node);
}
void module_call_init(module_init_type type)
l = find_type(type);
- TAILQ_FOREACH(e, l, node) {
+ QTAILQ_FOREACH(e, l, node) {
e->init();
}
}
struct mon_fd_t {
char *name;
int fd;
- LIST_ENTRY(mon_fd_t) next;
+ QLIST_ENTRY(mon_fd_t) next;
};
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[];
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;
#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)
{
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;
}
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
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);
return;
}
- LIST_FOREACH(monfd, &mon->fds, next) {
+ QLIST_FOREACH(monfd, &mon->fds, next) {
if (strcmp(monfd->name, fdname) != 0) {
continue;
}
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)
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);
{
mon_fd_t *monfd;
- LIST_FOREACH(monfd, &mon->fds, next) {
+ QLIST_FOREACH(monfd, &mon->fds, next) {
int fd;
if (strcmp(monfd->name, fdname) != 0) {
fd = monfd->fd;
/* caller takes ownership of fd */
- LIST_REMOVE(monfd, next);
+ QLIST_REMOVE(monfd, next);
qemu_free(monfd->name);
qemu_free(monfd);
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;
}
/* 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 <sys/times.h>
#include "qemu-log.h"
#include "slirp/libslirp.h"
+#include "qemu-queue.h"
static VLANState *first_vlan;
{
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);
}
}
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;
}
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,
packet->size += len;
}
- TAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry);
+ QTAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry);
return packet->size;
}
};
typedef struct SlirpState {
- TAILQ_ENTRY(SlirpState) entry;
+ QTAILQ_ENTRY(SlirpState) entry;
VLANClientState *vc;
Slirp *slirp;
#ifndef _WIN32
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);
slirp_cleanup(s->slirp);
slirp_smb_cleanup(s);
- TAILQ_REMOVE(&slirp_stacks, s, entry);
+ QTAILQ_REMOVE(&slirp_stacks, s, entry);
qemu_free(s);
}
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;
}
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);
}
}
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,
{
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;
return;
}
- slirp_hostfwd(TAILQ_FIRST(&slirp_stacks), NULL, redir_str, 1);
+ slirp_hostfwd(QTAILQ_FIRST(&slirp_stacks), NULL, redir_str, 1);
}
#ifndef _WIN32
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);
}
}
{
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);
}
}
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)
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));
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
#ifndef QEMU_NET_H
#define QEMU_NET_H
-#include "sys-queue.h"
+#include "qemu-queue.h"
#include "qemu-common.h"
#include "qdict.h"
typedef void (NetPacketSent) (VLANClientState *, ssize_t);
struct VLANPacket {
- TAILQ_ENTRY(VLANPacket) entry;
+ QTAILQ_ENTRY(VLANPacket) entry;
VLANClientState *sender;
int size;
NetPacketSent *sent_cb;
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;
};
#include <stdlib.h>
#include <stdio.h>
-#include "sys-queue.h"
+#include "qemu-queue.h"
#include "osdep.h"
#include "qemu-common.h"
#include "block_int.h"
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;
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;
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);
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);
}
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;
if (ret)
die2(ret, "pthread_attr_setdetachstate");
- TAILQ_INIT(&request_list);
+ QTAILQ_INIT(&request_list);
posix_aio_state = s;
#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);
{
QDictEntry *entry;
- LIST_FOREACH(entry, &qdict->table[hash], next)
+ QLIST_FOREACH(entry, &qdict->table[hash], next)
if (!strcmp(entry->key, key))
return entry;
} 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++;
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--;
}
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;
}
#define QDICT_H
#include "qobject.h"
-#include "sys-queue.h"
+#include "qemu-queue.h"
#include <stdint.h>
#define QDICT_HASH_SIZE 512
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 */
/***********************************************************/
/* 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)
initial_reset_issued = 1;
- TAILQ_FOREACH(chr, &chardevs, next) {
+ QTAILQ_FOREACH(chr, &chardevs, next) {
qemu_chr_reset(chr);
}
}
case 's':
{
DriveInfo *dinfo;
- TAILQ_FOREACH(dinfo, &drives, next) {
+ QTAILQ_FOREACH(dinfo, &drives, next) {
bdrv_commit(dinfo->bdrv);
}
}
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;
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;
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);
{
CharDriverState *chr;
- TAILQ_FOREACH(chr, &chardevs, next) {
+ QTAILQ_FOREACH(chr, &chardevs, next) {
monitor_printf(mon, "%s: filename=%s\n", chr->label, chr->filename);
}
}
{
CharDriverState *chr;
- TAILQ_FOREACH(chr, &chardevs, next) {
+ QTAILQ_FOREACH(chr, &chardevs, next) {
if (strcmp(chr->label, name) != 0)
continue;
return chr;
#define QEMU_CHAR_H
#include "qemu-common.h"
-#include "sys-queue.h"
+#include "qemu-queue.h"
#include "qemu-option.h"
#include "qemu-config.h"
QEMUBH *bh;
char *label;
char *filename;
- TAILQ_ENTRY(CharDriverState) next;
+ QTAILQ_ENTRY(CharDriverState) next;
};
CharDriverState *qemu_chr_open_opts(QemuOpts *opts,
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",
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",
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
} 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;
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);
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;
}
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;
{
QemuOpts *opts;
- TAILQ_FOREACH(opts, &list->head, next) {
+ QTAILQ_FOREACH(opts, &list->head, next) {
if (!opts->id) {
continue;
}
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;
}
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);
}
fprintf(stderr, "%s: %s:", opts->list->name,
opts->id ? opts->id : "<noid>");
- TAILQ_FOREACH(opt, &opts->head, next) {
+ QTAILQ_FOREACH(opt, &opts->head, next) {
fprintf(stderr, " %s=\"%s\"", opt->name, opt->str);
}
fprintf(stderr, "\n");
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;
#ifndef QEMU_OPTIONS_H
#define QEMU_OPTIONS_H
-#include "sys-queue.h"
+#include "qemu-queue.h"
enum QEMUOptionParType {
OPT_FLAG,
struct QemuOptsList {
const char *name;
- TAILQ_HEAD(, QemuOpts) head;
+ QTAILQ_HEAD(, QemuOpts) head;
QemuOptDesc desc[];
};
--- /dev/null
+/* $NetBSD: queue.h,v 1.45.14.1 2007/07/18 20:13:24 liamjfoy Exp $ */
+
+/*
+ * Qemu version: Copy from netbsd, removed debug code, removed some of
+ * the implementations. Left in lists, tail queues and circular queues.
+ */
+
+/*
+ * Copyright (c) 1991, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)queue.h 8.5 (Berkeley) 8/20/94
+ */
+
+#ifndef QEMU_SYS_QUEUE_H_
+#define QEMU_SYS_QUEUE_H_
+
+/*
+ * This file defines three types of data structures:
+ * lists, tail queues, and circular queues.
+ *
+ * A list is headed by a single forward pointer (or an array of forward
+ * pointers for a hash table header). The elements are doubly linked
+ * so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before
+ * or after an existing element or at the head of the list. A list
+ * may only be traversed in the forward direction.
+ *
+ * A tail queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are doubly
+ * linked so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before or
+ * after an existing element, at the head of the list, or at the end of
+ * the list. A tail queue may be traversed in either direction.
+ *
+ * A circle queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are doubly
+ * linked so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before or after
+ * an existing element, at the head of the list, or at the end of the list.
+ * A circle queue may be traversed in either direction, but has a more
+ * complex end of list detection.
+ *
+ * For details on the use of these macros, see the queue(3) manual page.
+ */
+
+/*
+ * List definitions.
+ */
+#define QLIST_HEAD(name, type) \
+struct name { \
+ struct type *lh_first; /* first element */ \
+}
+
+#define QLIST_HEAD_INITIALIZER(head) \
+ { NULL }
+
+#define QLIST_ENTRY(type) \
+struct { \
+ struct type *le_next; /* next element */ \
+ struct type **le_prev; /* address of previous next element */ \
+}
+
+/*
+ * List functions.
+ */
+#define QLIST_INIT(head) do { \
+ (head)->lh_first = NULL; \
+} while (/*CONSTCOND*/0)
+
+#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; \
+ (listelm)->field.le_next = (elm); \
+ (elm)->field.le_prev = &(listelm)->field.le_next; \
+} while (/*CONSTCOND*/0)
+
+#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 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 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 QLIST_FOREACH(var, head, field) \
+ for ((var) = ((head)->lh_first); \
+ (var); \
+ (var) = ((var)->field.le_next))
+
+#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))
+
+/*
+ * List access methods.
+ */
+#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 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 QTAILQ_HEAD(name, type) Q_TAILQ_HEAD(name, struct type,)
+
+#define QTAILQ_HEAD_INITIALIZER(head) \
+ { NULL, &(head).tqh_first }
+
+#define Q_TAILQ_ENTRY(type, qual) \
+struct { \
+ qual type *tqe_next; /* next element */ \
+ qual type *qual *tqe_prev; /* address of previous next element */\
+}
+#define QTAILQ_ENTRY(type) Q_TAILQ_ENTRY(struct type,)
+
+/*
+ * Tail queue functions.
+ */
+#define QTAILQ_INIT(head) do { \
+ (head)->tqh_first = NULL; \
+ (head)->tqh_last = &(head)->tqh_first; \
+} while (/*CONSTCOND*/0)
+
+#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; \
+ else \
+ (head)->tqh_last = &(elm)->field.tqe_next; \
+ (head)->tqh_first = (elm); \
+ (elm)->field.tqe_prev = &(head)->tqh_first; \
+} while (/*CONSTCOND*/0)
+
+#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 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; \
+ else \
+ (head)->tqh_last = &(elm)->field.tqe_next; \
+ (listelm)->field.tqe_next = (elm); \
+ (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \
+} while (/*CONSTCOND*/0)
+
+#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 QTAILQ_REMOVE(head, elm, field) do { \
+ if (((elm)->field.tqe_next) != NULL) \
+ (elm)->field.tqe_next->field.tqe_prev = \
+ (elm)->field.tqe_prev; \
+ else \
+ (head)->tqh_last = (elm)->field.tqe_prev; \
+ *(elm)->field.tqe_prev = (elm)->field.tqe_next; \
+} while (/*CONSTCOND*/0)
+
+#define QTAILQ_FOREACH(var, head, field) \
+ for ((var) = ((head)->tqh_first); \
+ (var); \
+ (var) = ((var)->field.tqe_next))
+
+#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 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)))
+
+/*
+ * Tail queue access methods.
+ */
+#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 QTAILQ_LAST(head, headname) \
+ (*(((struct headname *)((head)->tqh_last))->tqh_last))
+#define QTAILQ_PREV(elm, headname, field) \
+ (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
+
+
+/*
+ * Circular queue definitions.
+ */
+#define QCIRCLEQ_HEAD(name, type) \
+struct name { \
+ struct type *cqh_first; /* first element */ \
+ struct type *cqh_last; /* last element */ \
+}
+
+#define QCIRCLEQ_HEAD_INITIALIZER(head) \
+ { (void *)&head, (void *)&head }
+
+#define QCIRCLEQ_ENTRY(type) \
+struct { \
+ struct type *cqe_next; /* next element */ \
+ struct type *cqe_prev; /* previous element */ \
+}
+
+/*
+ * Circular queue functions.
+ */
+#define QCIRCLEQ_INIT(head) do { \
+ (head)->cqh_first = (void *)(head); \
+ (head)->cqh_last = (void *)(head); \
+} while (/*CONSTCOND*/0)
+
+#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)) \
+ (head)->cqh_last = (elm); \
+ else \
+ (listelm)->field.cqe_next->field.cqe_prev = (elm); \
+ (listelm)->field.cqe_next = (elm); \
+} while (/*CONSTCOND*/0)
+
+#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)) \
+ (head)->cqh_first = (elm); \
+ else \
+ (listelm)->field.cqe_prev->field.cqe_next = (elm); \
+ (listelm)->field.cqe_prev = (elm); \
+} while (/*CONSTCOND*/0)
+
+#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)) \
+ (head)->cqh_last = (elm); \
+ else \
+ (head)->cqh_first->field.cqe_prev = (elm); \
+ (head)->cqh_first = (elm); \
+} while (/*CONSTCOND*/0)
+
+#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)) \
+ (head)->cqh_first = (elm); \
+ else \
+ (head)->cqh_last->field.cqe_next = (elm); \
+ (head)->cqh_last = (elm); \
+} while (/*CONSTCOND*/0)
+
+#define QCIRCLEQ_REMOVE(head, elm, field) do { \
+ if ((elm)->field.cqe_next == (void *)(head)) \
+ (head)->cqh_last = (elm)->field.cqe_prev; \
+ else \
+ (elm)->field.cqe_next->field.cqe_prev = \
+ (elm)->field.cqe_prev; \
+ if ((elm)->field.cqe_prev == (void *)(head)) \
+ (head)->cqh_first = (elm)->field.cqe_next; \
+ else \
+ (elm)->field.cqe_prev->field.cqe_next = \
+ (elm)->field.cqe_next; \
+} while (/*CONSTCOND*/0)
+
+#define QCIRCLEQ_FOREACH(var, head, field) \
+ for ((var) = ((head)->cqh_first); \
+ (var) != (const void *)(head); \
+ (var) = ((var)->field.cqe_next))
+
+#define QCIRCLEQ_FOREACH_REVERSE(var, head, field) \
+ for ((var) = ((head)->cqh_last); \
+ (var) != (const void *)(head); \
+ (var) = ((var)->field.cqe_prev))
+
+/*
+ * Circular queue access methods.
+ */
+#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 QCIRCLEQ_LOOP_NEXT(head, elm, field) \
+ (((elm)->field.cqe_next == (void *)(head)) \
+ ? ((head)->cqh_first) \
+ : (elm->field.cqe_next))
+#define QCIRCLEQ_LOOP_PREV(head, elm, field) \
+ (((elm)->field.cqe_prev == (void *)(head)) \
+ ? ((head)->cqh_last) \
+ : (elm->field.cqe_prev))
+
+#endif /* !QEMU_SYS_QUEUE_H_ */
/* 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",
/* 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 <sys/times.h>
#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;
};
typedef struct SaveStateEntry {
- TAILQ_ENTRY(SaveStateEntry) entry;
+ QTAILQ_ENTRY(SaveStateEntry) entry;
char idstr[256];
int instance_id;
int version_id;
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)
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;
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;
}
{
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);
}
}
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;
}
{
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);
}
}
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)
SaveStateEntry *se;
int ret = 1;
- TAILQ_FOREACH(se, &savevm_handlers, entry) {
+ QTAILQ_FOREACH(se, &savevm_handlers, entry) {
if (se->save_live_state == NULL)
continue;
{
SaveStateEntry *se;
- TAILQ_FOREACH(se, &savevm_handlers, entry) {
+ QTAILQ_FOREACH(se, &savevm_handlers, entry) {
if (se->save_live_state == NULL)
continue;
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)
{
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;
}
typedef struct LoadStateEntry {
- LIST_ENTRY(LoadStateEntry) entry;
+ QLIST_ENTRY(LoadStateEntry) entry;
SaveStateEntry *se;
int section_id;
int version_id;
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;
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) {
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;
}
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);
}
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;
/* create the snapshots */
- TAILQ_FOREACH(dinfo, &drives, next) {
+ QTAILQ_FOREACH(dinfo, &drives, next) {
bs1 = dinfo->bdrv;
if (bdrv_has_snapshot(bs1)) {
if (must_delete) {
/* 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);
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);
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)
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;
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);
struct socket *so, *so_next;
int nfds;
- if (TAILQ_EMPTY(&slirp_instances)) {
+ if (QTAILQ_EMPTY(&slirp_instances)) {
return;
}
*/
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
struct socket *so, *so_next;
int ret;
- if (TAILQ_EMPTY(&slirp_instances)) {
+ if (QTAILQ_EMPTY(&slirp_instances)) {
return;
}
curtime = qemu_get_clock(rt_clock);
- TAILQ_FOREACH(slirp, &slirp_instances, entry) {
+ QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
/*
* See if anything has timed out
*/
#include "debug.h"
-#include "sys-queue.h"
+#include "qemu-queue.h"
#include "libslirp.h"
#include "ip.h"
#include "tftp.h"
struct Slirp {
- TAILQ_ENTRY(Slirp) entry;
+ QTAILQ_ENTRY(Slirp) entry;
/* virtual network configuration */
struct in_addr vnetwork_addr;
+++ /dev/null
-/* $NetBSD: queue.h,v 1.45.14.1 2007/07/18 20:13:24 liamjfoy Exp $ */
-
-/*
- * Qemu version: Copy from netbsd, removed debug code, removed some of
- * the implementations. Left in lists, tail queues and circular queues.
- */
-
-/*
- * Copyright (c) 1991, 1993
- * The Regents of the University of California. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the University nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * @(#)queue.h 8.5 (Berkeley) 8/20/94
- */
-
-#ifndef _SYS_QUEUE_H_
-#define _SYS_QUEUE_H_
-
-/*
- * This file defines three types of data structures:
- * lists, tail queues, and circular queues.
- *
- * A list is headed by a single forward pointer (or an array of forward
- * pointers for a hash table header). The elements are doubly linked
- * so that an arbitrary element can be removed without a need to
- * traverse the list. New elements can be added to the list before
- * or after an existing element or at the head of the list. A list
- * may only be traversed in the forward direction.
- *
- * A tail queue is headed by a pair of pointers, one to the head of the
- * list and the other to the tail of the list. The elements are doubly
- * linked so that an arbitrary element can be removed without a need to
- * traverse the list. New elements can be added to the list before or
- * after an existing element, at the head of the list, or at the end of
- * the list. A tail queue may be traversed in either direction.
- *
- * A circle queue is headed by a pair of pointers, one to the head of the
- * list and the other to the tail of the list. The elements are doubly
- * linked so that an arbitrary element can be removed without a need to
- * traverse the list. New elements can be added to the list before or after
- * an existing element, at the head of the list, or at the end of the list.
- * A circle queue may be traversed in either direction, but has a more
- * complex end of list detection.
- *
- * For details on the use of these macros, see the queue(3) manual page.
- */
-
-/*
- * List definitions.
- */
-#define LIST_HEAD(name, type) \
-struct name { \
- struct type *lh_first; /* first element */ \
-}
-
-#define LIST_HEAD_INITIALIZER(head) \
- { NULL }
-
-#define LIST_ENTRY(type) \
-struct { \
- struct type *le_next; /* next element */ \
- struct type **le_prev; /* address of previous next element */ \
-}
-
-/*
- * List functions.
- */
-#define LIST_INIT(head) do { \
- (head)->lh_first = NULL; \
-} while (/*CONSTCOND*/0)
-
-#define LIST_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; \
- (listelm)->field.le_next = (elm); \
- (elm)->field.le_prev = &(listelm)->field.le_next; \
-} while (/*CONSTCOND*/0)
-
-#define LIST_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 { \
- 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 { \
- 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) \
- for ((var) = ((head)->lh_first); \
- (var); \
- (var) = ((var)->field.le_next))
-
-#define LIST_FOREACH_SAFE(var, head, field, next_var) \
- for ((var) = ((head)->lh_first); \
- (var) && ((next_var) = ((var)->field.le_next), 1); \
- (var) = (next_var))
-
-/*
- * 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)
-
-
-/*
- * Tail queue definitions.
- */
-#define _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 TAILQ_HEAD_INITIALIZER(head) \
- { NULL, &(head).tqh_first }
-
-#define _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,)
-
-/*
- * Tail queue functions.
- */
-#define TAILQ_INIT(head) do { \
- (head)->tqh_first = NULL; \
- (head)->tqh_last = &(head)->tqh_first; \
-} while (/*CONSTCOND*/0)
-
-#define TAILQ_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; \
- else \
- (head)->tqh_last = &(elm)->field.tqe_next; \
- (head)->tqh_first = (elm); \
- (elm)->field.tqe_prev = &(head)->tqh_first; \
-} while (/*CONSTCOND*/0)
-
-#define TAILQ_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 { \
- if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
- (elm)->field.tqe_next->field.tqe_prev = \
- &(elm)->field.tqe_next; \
- else \
- (head)->tqh_last = &(elm)->field.tqe_next; \
- (listelm)->field.tqe_next = (elm); \
- (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \
-} while (/*CONSTCOND*/0)
-
-#define TAILQ_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 { \
- if (((elm)->field.tqe_next) != NULL) \
- (elm)->field.tqe_next->field.tqe_prev = \
- (elm)->field.tqe_prev; \
- else \
- (head)->tqh_last = (elm)->field.tqe_prev; \
- *(elm)->field.tqe_prev = (elm)->field.tqe_next; \
-} while (/*CONSTCOND*/0)
-
-#define TAILQ_FOREACH(var, head, field) \
- for ((var) = ((head)->tqh_first); \
- (var); \
- (var) = ((var)->field.tqe_next))
-
-#define TAILQ_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) \
- for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last)); \
- (var); \
- (var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last)))
-
-/*
- * 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 TAILQ_LAST(head, headname) \
- (*(((struct headname *)((head)->tqh_last))->tqh_last))
-#define TAILQ_PREV(elm, headname, field) \
- (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
-
-
-/*
- * Circular queue definitions.
- */
-#define CIRCLEQ_HEAD(name, type) \
-struct name { \
- struct type *cqh_first; /* first element */ \
- struct type *cqh_last; /* last element */ \
-}
-
-#define CIRCLEQ_HEAD_INITIALIZER(head) \
- { (void *)&head, (void *)&head }
-
-#define CIRCLEQ_ENTRY(type) \
-struct { \
- struct type *cqe_next; /* next element */ \
- struct type *cqe_prev; /* previous element */ \
-}
-
-/*
- * Circular queue functions.
- */
-#define CIRCLEQ_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 { \
- (elm)->field.cqe_next = (listelm)->field.cqe_next; \
- (elm)->field.cqe_prev = (listelm); \
- if ((listelm)->field.cqe_next == (void *)(head)) \
- (head)->cqh_last = (elm); \
- else \
- (listelm)->field.cqe_next->field.cqe_prev = (elm); \
- (listelm)->field.cqe_next = (elm); \
-} while (/*CONSTCOND*/0)
-
-#define CIRCLEQ_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)) \
- (head)->cqh_first = (elm); \
- else \
- (listelm)->field.cqe_prev->field.cqe_next = (elm); \
- (listelm)->field.cqe_prev = (elm); \
-} while (/*CONSTCOND*/0)
-
-#define CIRCLEQ_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)) \
- (head)->cqh_last = (elm); \
- else \
- (head)->cqh_first->field.cqe_prev = (elm); \
- (head)->cqh_first = (elm); \
-} while (/*CONSTCOND*/0)
-
-#define CIRCLEQ_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)) \
- (head)->cqh_first = (elm); \
- else \
- (head)->cqh_last->field.cqe_next = (elm); \
- (head)->cqh_last = (elm); \
-} while (/*CONSTCOND*/0)
-
-#define CIRCLEQ_REMOVE(head, elm, field) do { \
- if ((elm)->field.cqe_next == (void *)(head)) \
- (head)->cqh_last = (elm)->field.cqe_prev; \
- else \
- (elm)->field.cqe_next->field.cqe_prev = \
- (elm)->field.cqe_prev; \
- if ((elm)->field.cqe_prev == (void *)(head)) \
- (head)->cqh_first = (elm)->field.cqe_next; \
- else \
- (elm)->field.cqe_prev->field.cqe_next = \
- (elm)->field.cqe_next; \
-} while (/*CONSTCOND*/0)
-
-#define CIRCLEQ_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) \
- for ((var) = ((head)->cqh_last); \
- (var) != (const void *)(head); \
- (var) = ((var)->field.cqe_prev))
-
-/*
- * 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 CIRCLEQ_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) \
- (((elm)->field.cqe_prev == (void *)(head)) \
- ? ((head)->cqh_last) \
- : (elm->field.cqe_prev))
-
-#endif /* !_SYS_QUEUE_H_ */
#include "qemu-common.h"
#include "qemu-option.h"
-#include "sys-queue.h"
+#include "qemu-queue.h"
#include "qdict.h"
#ifdef _WIN32
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);
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;
}
#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);
{
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);
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);
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);
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;
{
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;
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;
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;
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);
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);
/* 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 <libgen.h>
#include "slirp/libslirp.h"
+#include "qemu-queue.h"
+
//#define DEBUG_NET
//#define DEBUG_SLIRP
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;
/* 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)
{
DriveInfo *dinfo;
- TAILQ_FOREACH(dinfo, &drives, next) {
+ QTAILQ_FOREACH(dinfo, &drives, next) {
if (strcmp(id, dinfo->id))
continue;
return dinfo;
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;
{
DriveInfo *dinfo;
- TAILQ_FOREACH(dinfo, &drives, next) {
+ QTAILQ_FOREACH(dinfo, &drives, next) {
if (dinfo->bdrv == bdrv)
return dinfo->serial;
}
{
DriveInfo *dinfo;
- TAILQ_FOREACH(dinfo, &drives, next) {
+ QTAILQ_FOREACH(dinfo, &drives, next) {
if (dinfo->bdrv == bdrv)
return dinfo->onerror;
}
{
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;
}
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:
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)
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);
}
/* 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;
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;
}
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);
}
}
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)
{
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))
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);
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;
projects / qemu / commitdiff