OpenE2K
/
qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

Fix sys-queue.h conflict for good 

Problem: Our file sys-queue.h is a copy of the BSD file, but there are
some additions and it's not entirely compatible. Because of that, there have
been conflicts with system headers on BSD systems. Some hacks have been
introduced in the commits 15cc923584,
f40d753718,
96555a96d7 and
3990d09adf but the fixes were fragile.

Solution: Avoid the conflict entirely by renaming the functions and the
file. Revert the previous hacks.

Signed-off-by: Blue Swirl <blauwirbel@gmail.com>
This commit is contained in:
Blue Swirl 2009-09-12 07:36:22 +00:00
parent 620150dc9c
commit 72cf2d4f0e
65 changed files with 481 additions and 488 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
acl.c
View File

@ -64,7 +64,7 @@ qemu_acl *qemu_acl_init(const char *aclname)
acl->defaultDeny = 1; acl->defaultDeny = 1;
acl->nentries = 0; acl->nentries = 0;
TAILQ_INIT(&acl->entries); QTAILQ_INIT(&acl->entries);
acls = qemu_realloc(acls, sizeof(*acls) * (nacls +1)); acls = qemu_realloc(acls, sizeof(*acls) * (nacls +1));
acls[nacls] = acl; acls[nacls] = acl;
@ -78,7 +78,7 @@ int qemu_acl_party_is_allowed(qemu_acl *acl,
{ {
qemu_acl_entry *entry; qemu_acl_entry *entry;
TAILQ_FOREACH(entry, &acl->entries, next) { QTAILQ_FOREACH(entry, &acl->entries, next) {
#ifdef CONFIG_FNMATCH #ifdef CONFIG_FNMATCH
if (fnmatch(entry->match, party, 0) == 0) if (fnmatch(entry->match, party, 0) == 0)
return entry->deny ? 0 : 1; return entry->deny ? 0 : 1;
@ -102,8 +102,8 @@ void qemu_acl_reset(qemu_acl *acl)
* of "open access" while the user re-initializes the * of "open access" while the user re-initializes the
* access control list */ * access control list */
acl->defaultDeny = 1; acl->defaultDeny = 1;
TAILQ_FOREACH(entry, &acl->entries, next) { QTAILQ_FOREACH(entry, &acl->entries, next) {
TAILQ_REMOVE(&acl->entries, entry, next); QTAILQ_REMOVE(&acl->entries, entry, next);
free(entry->match); free(entry->match);
free(entry); free(entry);
} }
@ -121,7 +121,7 @@ int qemu_acl_append(qemu_acl *acl,
entry->match = qemu_strdup(match); entry->match = qemu_strdup(match);
entry->deny = deny; entry->deny = deny;
TAILQ_INSERT_TAIL(&acl->entries, entry, next); QTAILQ_INSERT_TAIL(&acl->entries, entry, next);
acl->nentries++; acl->nentries++;
return acl->nentries; return acl->nentries;
@ -147,10 +147,10 @@ int qemu_acl_insert(qemu_acl *acl,
entry->match = qemu_strdup(match); entry->match = qemu_strdup(match);
entry->deny = deny; entry->deny = deny;
TAILQ_FOREACH(tmp, &acl->entries, next) { QTAILQ_FOREACH(tmp, &acl->entries, next) {
i++; i++;
if (i == index) { if (i == index) {
TAILQ_INSERT_BEFORE(tmp, entry, next); QTAILQ_INSERT_BEFORE(tmp, entry, next);
acl->nentries++; acl->nentries++;
break; break;
} }
@ -165,10 +165,10 @@ int qemu_acl_remove(qemu_acl *acl,
qemu_acl_entry *entry; qemu_acl_entry *entry;
int i = 0; int i = 0;
TAILQ_FOREACH(entry, &acl->entries, next) { QTAILQ_FOREACH(entry, &acl->entries, next) {
i++; i++;
if (strcmp(entry->match, match) == 0) { if (strcmp(entry->match, match) == 0) {
TAILQ_REMOVE(&acl->entries, entry, next); QTAILQ_REMOVE(&acl->entries, entry, next);
return i; return i;
} }
} }

6
acl.h
View File

@ -25,7 +25,7 @@
#ifndef __QEMU_ACL_H__ #ifndef __QEMU_ACL_H__
#define __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_entry qemu_acl_entry;
typedef struct qemu_acl qemu_acl; typedef struct qemu_acl qemu_acl;
@ -34,13 +34,13 @@ struct qemu_acl_entry {
char *match; char *match;
int deny; int deny;
TAILQ_ENTRY(qemu_acl_entry) next; QTAILQ_ENTRY(qemu_acl_entry) next;
}; };
struct qemu_acl { struct qemu_acl {
char *aclname; char *aclname;
unsigned int nentries; unsigned int nentries;
TAILQ_HEAD(,qemu_acl_entry) entries; QTAILQ_HEAD(,qemu_acl_entry) entries;
int defaultDeny; int defaultDeny;
}; };

22
aio.c
View File

@ -13,13 +13,13 @@
#include "qemu-common.h" #include "qemu-common.h"
#include "block.h" #include "block.h"
#include "sys-queue.h" #include "qemu-queue.h"
#include "qemu_socket.h" #include "qemu_socket.h"
typedef struct AioHandler AioHandler; typedef struct AioHandler AioHandler;
/* The list of registered AIO handlers */ /* 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, /* 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 * it's used to ensure that no callbacks are removed while we're walking and
@ -35,14 +35,14 @@ struct AioHandler
AioFlushHandler *io_flush; AioFlushHandler *io_flush;
int deleted; int deleted;
void *opaque; void *opaque;
LIST_ENTRY(AioHandler) node; QLIST_ENTRY(AioHandler) node;
}; };
static AioHandler *find_aio_handler(int fd) static AioHandler *find_aio_handler(int fd)
{ {
AioHandler *node; AioHandler *node;
LIST_FOREACH(node, &aio_handlers, node) { QLIST_FOREACH(node, &aio_handlers, node) {
if (node->fd == fd) if (node->fd == fd)
if (!node->deleted) if (!node->deleted)
return node; return node;
@ -72,7 +72,7 @@ int qemu_aio_set_fd_handler(int fd,
* deleted because deleted nodes are only cleaned up after * deleted because deleted nodes are only cleaned up after
* releasing the walking_handlers lock. * releasing the walking_handlers lock.
*/ */
LIST_REMOVE(node, node); QLIST_REMOVE(node, node);
qemu_free(node); qemu_free(node);
} }
} }
@ -81,7 +81,7 @@ int qemu_aio_set_fd_handler(int fd,
/* Alloc and insert if it's not already there */ /* Alloc and insert if it's not already there */
node = qemu_mallocz(sizeof(AioHandler)); node = qemu_mallocz(sizeof(AioHandler));
node->fd = fd; node->fd = fd;
LIST_INSERT_HEAD(&aio_handlers, node, node); QLIST_INSERT_HEAD(&aio_handlers, node, node);
} }
/* Update handler with latest information */ /* Update handler with latest information */
node->io_read = io_read; node->io_read = io_read;
@ -109,7 +109,7 @@ void qemu_aio_flush(void)
*/ */
qemu_aio_wait(); qemu_aio_wait();
LIST_FOREACH(node, &aio_handlers, node) { QLIST_FOREACH(node, &aio_handlers, node) {
ret |= node->io_flush(node->opaque); ret |= node->io_flush(node->opaque);
} }
} while (qemu_bh_poll() || ret > 0); } while (qemu_bh_poll() || ret > 0);
@ -133,7 +133,7 @@ void qemu_aio_wait(void)
FD_ZERO(&wrfds); FD_ZERO(&wrfds);
/* fill fd sets */ /* 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. /* If there aren't pending AIO operations, don't invoke callbacks.
* Otherwise, if there are no AIO requests, qemu_aio_wait() would * Otherwise, if there are no AIO requests, qemu_aio_wait() would
* wait indefinitely. * wait indefinitely.
@ -168,7 +168,7 @@ void qemu_aio_wait(void)
/* we have to walk very carefully in case /* we have to walk very carefully in case
* qemu_aio_set_fd_handler is called while we're walking */ * qemu_aio_set_fd_handler is called while we're walking */
node = LIST_FIRST(&aio_handlers); node = QLIST_FIRST(&aio_handlers);
while (node) { while (node) {
AioHandler *tmp; AioHandler *tmp;
@ -184,10 +184,10 @@ void qemu_aio_wait(void)
} }
tmp = node; tmp = node;
node = LIST_NEXT(node, node); node = QLIST_NEXT(node, node);
if (tmp->deleted) { if (tmp->deleted) {
LIST_REMOVE(tmp, node); QLIST_REMOVE(tmp, node);
qemu_free(tmp); qemu_free(tmp);
} }
} }

38
audio/audio.c
View File

@ -766,8 +766,8 @@ static void audio_detach_capture (HWVoiceOut *hw)
sw->rate = NULL; sw->rate = NULL;
} }
LIST_REMOVE (sw, entries); QLIST_REMOVE (sw, entries);
LIST_REMOVE (sc, entries); QLIST_REMOVE (sc, entries);
qemu_free (sc); qemu_free (sc);
if (was_active) { if (was_active) {
/* We have removed soft voice from the capture: /* We have removed soft voice from the capture:
@ -811,8 +811,8 @@ static int audio_attach_capture (HWVoiceOut *hw)
qemu_free (sw); qemu_free (sw);
return -1; return -1;
} }
LIST_INSERT_HEAD (&hw_cap->sw_head, sw, entries); QLIST_INSERT_HEAD (&hw_cap->sw_head, sw, entries);
LIST_INSERT_HEAD (&hw->cap_head, sc, entries); QLIST_INSERT_HEAD (&hw->cap_head, sc, entries);
#ifdef DEBUG_CAPTURE #ifdef DEBUG_CAPTURE
asprintf (&sw->name, "for %p %d,%d,%d", asprintf (&sw->name, "for %p %d,%d,%d",
hw, sw->info.freq, sw->info.bits, sw->info.nchannels); hw, sw->info.freq, sw->info.bits, sw->info.nchannels);
@ -1803,9 +1803,9 @@ static void audio_init (void)
return; return;
} }
LIST_INIT (&s->hw_head_out); QLIST_INIT (&s->hw_head_out);
LIST_INIT (&s->hw_head_in); QLIST_INIT (&s->hw_head_in);
LIST_INIT (&s->cap_head); QLIST_INIT (&s->cap_head);
atexit (audio_atexit); atexit (audio_atexit);
s->ts = qemu_new_timer (vm_clock, audio_timer, s); s->ts = qemu_new_timer (vm_clock, audio_timer, s);
@ -1887,7 +1887,7 @@ static void audio_init (void)
"(Audio can continue looping even after stopping the VM)\n"); "(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); register_savevm ("audio", 0, 1, audio_save, audio_load, s);
} }
@ -1896,12 +1896,12 @@ void AUD_register_card (const char *name, QEMUSoundCard *card)
audio_init (); audio_init ();
card->name = qemu_strdup (name); card->name = qemu_strdup (name);
memset (&card->entries, 0, sizeof (card->entries)); 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) void AUD_remove_card (QEMUSoundCard *card)
{ {
LIST_REMOVE (card, entries); QLIST_REMOVE (card, entries);
qemu_free (card->name); qemu_free (card->name);
} }
@ -1933,7 +1933,7 @@ CaptureVoiceOut *AUD_add_capture (
cap = audio_pcm_capture_find_specific (as); cap = audio_pcm_capture_find_specific (as);
if (cap) { if (cap) {
LIST_INSERT_HEAD (&cap->cb_head, cb, entries); QLIST_INSERT_HEAD (&cap->cb_head, cb, entries);
return cap; return cap;
} }
else { else {
@ -1948,8 +1948,8 @@ CaptureVoiceOut *AUD_add_capture (
} }
hw = &cap->hw; hw = &cap->hw;
LIST_INIT (&hw->sw_head); QLIST_INIT (&hw->sw_head);
LIST_INIT (&cap->cb_head); QLIST_INIT (&cap->cb_head);
/* XXX find a more elegant way */ /* XXX find a more elegant way */
hw->samples = 4096 * 4; hw->samples = 4096 * 4;
@ -1977,8 +1977,8 @@ CaptureVoiceOut *AUD_add_capture (
[hw->info.swap_endianness] [hw->info.swap_endianness]
[audio_bits_to_index (hw->info.bits)]; [audio_bits_to_index (hw->info.bits)];
LIST_INSERT_HEAD (&s->cap_head, cap, entries); QLIST_INSERT_HEAD (&s->cap_head, cap, entries);
LIST_INSERT_HEAD (&cap->cb_head, cb, entries); QLIST_INSERT_HEAD (&cap->cb_head, cb, entries);
hw = NULL; hw = NULL;
while ((hw = audio_pcm_hw_find_any_out (hw))) { while ((hw = audio_pcm_hw_find_any_out (hw))) {
@ -2004,7 +2004,7 @@ void AUD_del_capture (CaptureVoiceOut *cap, void *cb_opaque)
for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) {
if (cb->opaque == cb_opaque) { if (cb->opaque == cb_opaque) {
cb->ops.destroy (cb_opaque); cb->ops.destroy (cb_opaque);
LIST_REMOVE (cb, entries); QLIST_REMOVE (cb, entries);
qemu_free (cb); qemu_free (cb);
if (!cap->cb_head.lh_first) { if (!cap->cb_head.lh_first) {
@ -2021,12 +2021,12 @@ void AUD_del_capture (CaptureVoiceOut *cap, void *cb_opaque)
st_rate_stop (sw->rate); st_rate_stop (sw->rate);
sw->rate = NULL; sw->rate = NULL;
} }
LIST_REMOVE (sw, entries); QLIST_REMOVE (sw, entries);
LIST_REMOVE (sc, entries); QLIST_REMOVE (sc, entries);
qemu_free (sc); qemu_free (sc);
sw = sw1; sw = sw1;
} }
LIST_REMOVE (cap, entries); QLIST_REMOVE (cap, entries);
qemu_free (cap); qemu_free (cap);
} }
return; return;

6
audio/audio.h
View File

@ -25,7 +25,7 @@
#define QEMU_AUDIO_H #define QEMU_AUDIO_H
#include "config-host.h" #include "config-host.h"
#include "sys-queue.h" #include "qemu-queue.h"
typedef void (*audio_callback_fn_t) (void *opaque, int avail); typedef void (*audio_callback_fn_t) (void *opaque, int avail);
@ -70,7 +70,7 @@ struct capture_ops {
typedef struct CaptureState { typedef struct CaptureState {
void *opaque; void *opaque;
struct capture_ops ops; struct capture_ops ops;
LIST_ENTRY (CaptureState) entries; QLIST_ENTRY (CaptureState) entries;
} CaptureState; } CaptureState;
typedef struct SWVoiceOut SWVoiceOut; typedef struct SWVoiceOut SWVoiceOut;
@ -79,7 +79,7 @@ typedef struct SWVoiceIn SWVoiceIn;
typedef struct QEMUSoundCard { typedef struct QEMUSoundCard {
char *name; char *name;
LIST_ENTRY (QEMUSoundCard) entries; QLIST_ENTRY (QEMUSoundCard) entries;
} QEMUSoundCard; } QEMUSoundCard;
typedef struct QEMUAudioTimeStamp { typedef struct QEMUAudioTimeStamp {

30
audio/audio_int.h
View File

@ -80,10 +80,10 @@ typedef struct HWVoiceOut {
struct st_sample *mix_buf; struct st_sample *mix_buf;
int samples; int samples;
LIST_HEAD (sw_out_listhead, SWVoiceOut) sw_head; QLIST_HEAD (sw_out_listhead, SWVoiceOut) sw_head;
LIST_HEAD (sw_cap_listhead, SWVoiceCap) cap_head; QLIST_HEAD (sw_cap_listhead, SWVoiceCap) cap_head;
struct audio_pcm_ops *pcm_ops; struct audio_pcm_ops *pcm_ops;
LIST_ENTRY (HWVoiceOut) entries; QLIST_ENTRY (HWVoiceOut) entries;
} HWVoiceOut; } HWVoiceOut;
typedef struct HWVoiceIn { typedef struct HWVoiceIn {
@ -100,9 +100,9 @@ typedef struct HWVoiceIn {
struct st_sample *conv_buf; struct st_sample *conv_buf;
int samples; int samples;
LIST_HEAD (sw_in_listhead, SWVoiceIn) sw_head; QLIST_HEAD (sw_in_listhead, SWVoiceIn) sw_head;
struct audio_pcm_ops *pcm_ops; struct audio_pcm_ops *pcm_ops;
LIST_ENTRY (HWVoiceIn) entries; QLIST_ENTRY (HWVoiceIn) entries;
} HWVoiceIn; } HWVoiceIn;
struct SWVoiceOut { struct SWVoiceOut {
@ -119,7 +119,7 @@ struct SWVoiceOut {
char *name; char *name;
struct mixeng_volume vol; struct mixeng_volume vol;
struct audio_callback callback; struct audio_callback callback;
LIST_ENTRY (SWVoiceOut) entries; QLIST_ENTRY (SWVoiceOut) entries;
}; };
struct SWVoiceIn { struct SWVoiceIn {
@ -135,7 +135,7 @@ struct SWVoiceIn {
char *name; char *name;
struct mixeng_volume vol; struct mixeng_volume vol;
struct audio_callback callback; struct audio_callback callback;
LIST_ENTRY (SWVoiceIn) entries; QLIST_ENTRY (SWVoiceIn) entries;
}; };
struct audio_driver { struct audio_driver {
@ -169,20 +169,20 @@ struct audio_pcm_ops {
struct capture_callback { struct capture_callback {
struct audio_capture_ops ops; struct audio_capture_ops ops;
void *opaque; void *opaque;
LIST_ENTRY (capture_callback) entries; QLIST_ENTRY (capture_callback) entries;
}; };
struct CaptureVoiceOut { struct CaptureVoiceOut {
HWVoiceOut hw; HWVoiceOut hw;
void *buf; void *buf;
LIST_HEAD (cb_listhead, capture_callback) cb_head; QLIST_HEAD (cb_listhead, capture_callback) cb_head;
LIST_ENTRY (CaptureVoiceOut) entries; QLIST_ENTRY (CaptureVoiceOut) entries;
}; };
struct SWVoiceCap { struct SWVoiceCap {
SWVoiceOut sw; SWVoiceOut sw;
CaptureVoiceOut *cap; CaptureVoiceOut *cap;
LIST_ENTRY (SWVoiceCap) entries; QLIST_ENTRY (SWVoiceCap) entries;
}; };
struct AudioState { struct AudioState {
@ -190,10 +190,10 @@ struct AudioState {
void *drv_opaque; void *drv_opaque;
QEMUTimer *ts; QEMUTimer *ts;
LIST_HEAD (card_listhead, QEMUSoundCard) card_head; QLIST_HEAD (card_listhead, QEMUSoundCard) card_head;
LIST_HEAD (hw_in_listhead, HWVoiceIn) hw_head_in; QLIST_HEAD (hw_in_listhead, HWVoiceIn) hw_head_in;
LIST_HEAD (hw_out_listhead, HWVoiceOut) hw_head_out; QLIST_HEAD (hw_out_listhead, HWVoiceOut) hw_head_out;
LIST_HEAD (cap_listhead, CaptureVoiceOut) cap_head; QLIST_HEAD (cap_listhead, CaptureVoiceOut) cap_head;
int nb_hw_voices_out; int nb_hw_voices_out;
int nb_hw_voices_in; int nb_hw_voices_in;
int vm_running; int vm_running;

12
audio/audio_template.h
View File

@ -184,12 +184,12 @@ static void glue (audio_pcm_sw_fini_, TYPE) (SW *sw)
static void glue (audio_pcm_hw_add_sw_, TYPE) (HW *hw, SW *sw) 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) 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) static void glue (audio_pcm_hw_gc_, TYPE) (HW **hwp)
@ -201,7 +201,7 @@ static void glue (audio_pcm_hw_gc_, TYPE) (HW **hwp)
#ifdef DAC #ifdef DAC
audio_detach_capture (hw); audio_detach_capture (hw);
#endif #endif
LIST_REMOVE (hw, entries); QLIST_REMOVE (hw, entries);
glue (s->nb_hw_voices_, TYPE) += 1; glue (s->nb_hw_voices_, TYPE) += 1;
glue (audio_pcm_hw_free_resources_ ,TYPE) (hw); glue (audio_pcm_hw_free_resources_ ,TYPE) (hw);
glue (hw->pcm_ops->fini_, TYPE) (hw); glue (hw->pcm_ops->fini_, TYPE) (hw);
@ -267,9 +267,9 @@ static HW *glue (audio_pcm_hw_add_new_, TYPE) (struct audsettings *as)
} }
hw->pcm_ops = drv->pcm_ops; hw->pcm_ops = drv->pcm_ops;
LIST_INIT (&hw->sw_head); QLIST_INIT (&hw->sw_head);
#ifdef DAC #ifdef DAC
LIST_INIT (&hw->cap_head); QLIST_INIT (&hw->cap_head);
#endif #endif
if (glue (hw->pcm_ops->init_, TYPE) (hw, as)) { if (glue (hw->pcm_ops->init_, TYPE) (hw, as)) {
goto err0; goto err0;
@ -294,7 +294,7 @@ static HW *glue (audio_pcm_hw_add_new_, TYPE) (struct audsettings *as)
goto err1; 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; glue (s->nb_hw_voices_, TYPE) -= 1;
#ifdef DAC #ifdef DAC
audio_attach_capture (hw); audio_attach_capture (hw);

6
block.c
View File

@ -22,11 +22,6 @@
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#include "config-host.h" #include "config-host.h"
#ifdef CONFIG_BSD
/* include native header before sys-queue.h */
#include <sys/queue.h>
#endif
#include "qemu-common.h" #include "qemu-common.h"
#include "monitor.h" #include "monitor.h"
#include "block_int.h" #include "block_int.h"
@ -36,6 +31,7 @@
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
#include <sys/queue.h>
#ifndef __DragonFly__ #ifndef __DragonFly__
#include <sys/disk.h> #include <sys/disk.h>
#endif #endif

4
block/qcow2-cluster.c
View File

@ -738,7 +738,7 @@ uint64_t qcow2_alloc_cluster_offset(BlockDriverState *bs,
* the same cluster. In this case we need to wait until the previous * the same cluster. In this case we need to wait until the previous
* request has completed and updated the L2 table accordingly. * 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 end_offset = offset + nb_clusters * s->cluster_size;
uint64_t old_offset = old_alloc->offset; uint64_t old_offset = old_alloc->offset;
@ -769,7 +769,7 @@ uint64_t qcow2_alloc_cluster_offset(BlockDriverState *bs,
abort(); 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 */ /* allocate a new cluster */

16
block/qcow2.c
View File

@ -219,7 +219,7 @@ static int qcow_open(BlockDriverState *bs, const char *filename, int flags)
if (qcow2_refcount_init(bs) < 0) if (qcow2_refcount_init(bs) < 0)
goto fail; goto fail;
LIST_INIT(&s->cluster_allocs); QLIST_INIT(&s->cluster_allocs);
/* read qcow2 extensions */ /* read qcow2 extensions */
if (header.backing_file_offset) if (header.backing_file_offset)
@ -340,7 +340,7 @@ typedef struct QCowAIOCB {
QEMUIOVector hd_qiov; QEMUIOVector hd_qiov;
QEMUBH *bh; QEMUBH *bh;
QCowL2Meta l2meta; QCowL2Meta l2meta;
LIST_ENTRY(QCowAIOCB) next_depend; QLIST_ENTRY(QCowAIOCB) next_depend;
} QCowAIOCB; } QCowAIOCB;
static void qcow_aio_cancel(BlockDriverAIOCB *blockacb) static void qcow_aio_cancel(BlockDriverAIOCB *blockacb)
@ -503,7 +503,7 @@ static QCowAIOCB *qcow_aio_setup(BlockDriverState *bs,
acb->n = 0; acb->n = 0;
acb->cluster_offset = 0; acb->cluster_offset = 0;
acb->l2meta.nb_clusters = 0; acb->l2meta.nb_clusters = 0;
LIST_INIT(&acb->l2meta.dependent_requests); QLIST_INIT(&acb->l2meta.dependent_requests);
return acb; return acb;
} }
@ -530,12 +530,12 @@ static void run_dependent_requests(QCowL2Meta *m)
/* Take the request off the list of running requests */ /* Take the request off the list of running requests */
if (m->nb_clusters != 0) { if (m->nb_clusters != 0) {
LIST_REMOVE(m, next_in_flight); QLIST_REMOVE(m, next_in_flight);
} }
/* /*
* Restart all dependent requests. * 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 * any more after the callback (request could depend on a different
* request now) * request now)
*/ */
@ -545,7 +545,7 @@ static void run_dependent_requests(QCowL2Meta *m)
} }
/* Empty the list for the next part of the request */ /* 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) static void qcow_aio_write_cb(void *opaque, int ret)
@ -590,7 +590,7 @@ static void qcow_aio_write_cb(void *opaque, int ret)
/* Need to wait for another request? If so, we are done for now. */ /* Need to wait for another request? If so, we are done for now. */
if (!acb->cluster_offset && acb->l2meta.depends_on != NULL) { 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); acb, next_depend);
return; return;
} }
@ -690,7 +690,7 @@ static int preallocate(BlockDriverState *bs)
nb_sectors = bdrv_getlength(bs) >> 9; nb_sectors = bdrv_getlength(bs) >> 9;
offset = 0; offset = 0;
LIST_INIT(&meta.dependent_requests); QLIST_INIT(&meta.dependent_requests);
while (nb_sectors) { while (nb_sectors) {
num = MIN(nb_sectors, INT_MAX >> 9); num = MIN(nb_sectors, INT_MAX >> 9);

6
block/qcow2.h
View File

@ -98,7 +98,7 @@ typedef struct BDRVQcowState {
uint8_t *cluster_cache; uint8_t *cluster_cache;
uint8_t *cluster_data; uint8_t *cluster_data;
uint64_t cluster_cache_offset; 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;
uint64_t refcount_table_offset; uint64_t refcount_table_offset;
@ -139,9 +139,9 @@ typedef struct QCowL2Meta
int nb_available; int nb_available;
int nb_clusters; int nb_clusters;
struct QCowL2Meta *depends_on; 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; } QCowL2Meta;
static inline int size_to_clusters(BDRVQcowState *s, int64_t size) static inline int size_to_clusters(BDRVQcowState *s, int64_t size)

2
check-qdict.c
View File

@ -47,7 +47,7 @@ START_TEST(qdict_put_obj_test)
qdict_put_obj(qdict, "", QOBJECT(qint_from_int(num))); qdict_put_obj(qdict, "", QOBJECT(qint_from_int(num)));
fail_unless(qdict_size(qdict) == 1); 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); qi = qobject_to_qint(ent->value);
fail_unless(qint_get_int(qi) == num); fail_unless(qint_get_int(qi) == num);

10
cpu-defs.h
View File

@ -28,7 +28,7 @@
#include <inttypes.h> #include <inttypes.h>
#include <signal.h> #include <signal.h>
#include "osdep.h" #include "osdep.h"
#include "sys-queue.h" #include "qemu-queue.h"
#include "targphys.h" #include "targphys.h"
#ifndef TARGET_LONG_BITS #ifndef TARGET_LONG_BITS
@ -124,14 +124,14 @@ struct KVMState;
typedef struct CPUBreakpoint { typedef struct CPUBreakpoint {
target_ulong pc; target_ulong pc;
int flags; /* BP_* */ int flags; /* BP_* */
TAILQ_ENTRY(CPUBreakpoint) entry; QTAILQ_ENTRY(CPUBreakpoint) entry;
} CPUBreakpoint; } CPUBreakpoint;
typedef struct CPUWatchpoint { typedef struct CPUWatchpoint {
target_ulong vaddr; target_ulong vaddr;
target_ulong len_mask; target_ulong len_mask;
int flags; /* BP_* */ int flags; /* BP_* */
TAILQ_ENTRY(CPUWatchpoint) entry; QTAILQ_ENTRY(CPUWatchpoint) entry;
} CPUWatchpoint; } CPUWatchpoint;
#define CPU_TEMP_BUF_NLONGS 128 #define CPU_TEMP_BUF_NLONGS 128
@ -169,10 +169,10 @@ typedef struct CPUWatchpoint {
\ \
/* from this point: preserved by CPU reset */ \ /* from this point: preserved by CPU reset */ \
/* ice debug support */ \ /* ice debug support */ \
TAILQ_HEAD(breakpoints_head, CPUBreakpoint) breakpoints; \ QTAILQ_HEAD(breakpoints_head, CPUBreakpoint) breakpoints; \
int singlestep_enabled; \ int singlestep_enabled; \
\ \
TAILQ_HEAD(watchpoints_head, CPUWatchpoint) watchpoints; \ QTAILQ_HEAD(watchpoints_head, CPUWatchpoint) watchpoints; \
CPUWatchpoint *watchpoint_hit; \ CPUWatchpoint *watchpoint_hit; \
\ \
struct GDBRegisterState *gdb_regs; \ struct GDBRegisterState *gdb_regs; \

2
cpu-exec.c
View File

@ -202,7 +202,7 @@ static void cpu_handle_debug_exception(CPUState *env)
CPUWatchpoint *wp; CPUWatchpoint *wp;
if (!env->watchpoint_hit) if (!env->watchpoint_hit)
TAILQ_FOREACH(wp, &env->watchpoints, entry) QTAILQ_FOREACH(wp, &env->watchpoints, entry)
wp->flags &= ~BP_WATCHPOINT_HIT; wp->flags &= ~BP_WATCHPOINT_HIT;
if (debug_excp_handler) if (debug_excp_handler)

17
envlist.c
View File

@ -1,20 +1,19 @@
#include <sys/queue.h>
#include <assert.h> #include <assert.h>
#include <errno.h> #include <errno.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include "qemu-queue.h"
#include "envlist.h" #include "envlist.h"
struct envlist_entry { struct envlist_entry {
const char *ev_var; /* actual env value */ const char *ev_var; /* actual env value */
LIST_ENTRY(envlist_entry) ev_link; QLIST_ENTRY(envlist_entry) ev_link;
}; };
struct envlist { 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 */ size_t el_count; /* number of entries */
}; };
@ -33,7 +32,7 @@ envlist_create(void)
if ((envlist = malloc(sizeof (*envlist))) == NULL) if ((envlist = malloc(sizeof (*envlist))) == NULL)
return (NULL); return (NULL);
LIST_INIT(&envlist->el_entries); QLIST_INIT(&envlist->el_entries);
envlist->el_count = 0; envlist->el_count = 0;
return (envlist); return (envlist);
@ -51,7 +50,7 @@ envlist_free(envlist_t *envlist)
while (envlist->el_entries.lh_first != NULL) { while (envlist->el_entries.lh_first != NULL) {
entry = envlist->el_entries.lh_first; entry = envlist->el_entries.lh_first;
LIST_REMOVE(entry, ev_link); QLIST_REMOVE(entry, ev_link);
free((char *)entry->ev_var); free((char *)entry->ev_var);
free(entry); free(entry);
@ -159,7 +158,7 @@ envlist_setenv(envlist_t *envlist, const char *env)
} }
if (entry != NULL) { if (entry != NULL) {
LIST_REMOVE(entry, ev_link); QLIST_REMOVE(entry, ev_link);
free((char *)entry->ev_var); free((char *)entry->ev_var);
free(entry); free(entry);
} else { } else {
@ -172,7 +171,7 @@ envlist_setenv(envlist_t *envlist, const char *env)
free(entry); free(entry);
return (errno); return (errno);
} }
LIST_INSERT_HEAD(&envlist->el_entries, entry, ev_link); QLIST_INSERT_HEAD(&envlist->el_entries, entry, ev_link);
return (0); return (0);
} }
@ -205,7 +204,7 @@ envlist_unsetenv(envlist_t *envlist, const char *env)
break; break;
} }
if (entry != NULL) { if (entry != NULL) {
LIST_REMOVE(entry, ev_link); QLIST_REMOVE(entry, ev_link);
free((char *)entry->ev_var); free((char *)entry->ev_var);
free(entry); free(entry);

50
exec.c
View File

@ -586,8 +586,8 @@ void cpu_exec_init(CPUState *env)
} }
env->cpu_index = cpu_index; env->cpu_index = cpu_index;
env->numa_node = 0; env->numa_node = 0;
TAILQ_INIT(&env->breakpoints); QTAILQ_INIT(&env->breakpoints);
TAILQ_INIT(&env->watchpoints); QTAILQ_INIT(&env->watchpoints);
*penv = env; *penv = env;
#if defined(CONFIG_USER_ONLY) #if defined(CONFIG_USER_ONLY)
cpu_list_unlock(); cpu_list_unlock();
@ -1348,9 +1348,9 @@ int cpu_watchpoint_insert(CPUState *env, target_ulong addr, target_ulong len,
/* keep all GDB-injected watchpoints in front */ /* keep all GDB-injected watchpoints in front */
if (flags & BP_GDB) if (flags & BP_GDB)
TAILQ_INSERT_HEAD(&env->watchpoints, wp, entry); QTAILQ_INSERT_HEAD(&env->watchpoints, wp, entry);
else else
TAILQ_INSERT_TAIL(&env->watchpoints, wp, entry); QTAILQ_INSERT_TAIL(&env->watchpoints, wp, entry);
tlb_flush_page(env, addr); tlb_flush_page(env, addr);
@ -1366,7 +1366,7 @@ int cpu_watchpoint_remove(CPUState *env, target_ulong addr, target_ulong len,
target_ulong len_mask = ~(len - 1); target_ulong len_mask = ~(len - 1);
CPUWatchpoint *wp; CPUWatchpoint *wp;
TAILQ_FOREACH(wp, &env->watchpoints, entry) { QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
if (addr == wp->vaddr && len_mask == wp->len_mask if (addr == wp->vaddr && len_mask == wp->len_mask
&& flags == (wp->flags & ~BP_WATCHPOINT_HIT)) { && flags == (wp->flags & ~BP_WATCHPOINT_HIT)) {
cpu_watchpoint_remove_by_ref(env, wp); cpu_watchpoint_remove_by_ref(env, wp);
@ -1379,7 +1379,7 @@ int cpu_watchpoint_remove(CPUState *env, target_ulong addr, target_ulong len,
/* Remove a specific watchpoint by reference. */ /* Remove a specific watchpoint by reference. */
void cpu_watchpoint_remove_by_ref(CPUState *env, CPUWatchpoint *watchpoint) 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); tlb_flush_page(env, watchpoint->vaddr);
@ -1391,7 +1391,7 @@ void cpu_watchpoint_remove_all(CPUState *env, int mask)
{ {
CPUWatchpoint *wp, *next; CPUWatchpoint *wp, *next;
TAILQ_FOREACH_SAFE(wp, &env->watchpoints, entry, next) { QTAILQ_FOREACH_SAFE(wp, &env->watchpoints, entry, next) {
if (wp->flags & mask) if (wp->flags & mask)
cpu_watchpoint_remove_by_ref(env, wp); cpu_watchpoint_remove_by_ref(env, wp);
} }
@ -1411,9 +1411,9 @@ int cpu_breakpoint_insert(CPUState *env, target_ulong pc, int flags,
/* keep all GDB-injected breakpoints in front */ /* keep all GDB-injected breakpoints in front */
if (flags & BP_GDB) if (flags & BP_GDB)
TAILQ_INSERT_HEAD(&env->breakpoints, bp, entry); QTAILQ_INSERT_HEAD(&env->breakpoints, bp, entry);
else else
TAILQ_INSERT_TAIL(&env->breakpoints, bp, entry); QTAILQ_INSERT_TAIL(&env->breakpoints, bp, entry);
breakpoint_invalidate(env, pc); breakpoint_invalidate(env, pc);
@ -1431,7 +1431,7 @@ int cpu_breakpoint_remove(CPUState *env, target_ulong pc, int flags)
#if defined(TARGET_HAS_ICE) #if defined(TARGET_HAS_ICE)
CPUBreakpoint *bp; CPUBreakpoint *bp;
TAILQ_FOREACH(bp, &env->breakpoints, entry) { QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
if (bp->pc == pc && bp->flags == flags) { if (bp->pc == pc && bp->flags == flags) {
cpu_breakpoint_remove_by_ref(env, bp); cpu_breakpoint_remove_by_ref(env, bp);
return 0; return 0;
@ -1447,7 +1447,7 @@ int cpu_breakpoint_remove(CPUState *env, target_ulong pc, int flags)
void cpu_breakpoint_remove_by_ref(CPUState *env, CPUBreakpoint *breakpoint) void cpu_breakpoint_remove_by_ref(CPUState *env, CPUBreakpoint *breakpoint)
{ {
#if defined(TARGET_HAS_ICE) #if defined(TARGET_HAS_ICE)
TAILQ_REMOVE(&env->breakpoints, breakpoint, entry); QTAILQ_REMOVE(&env->breakpoints, breakpoint, entry);
breakpoint_invalidate(env, breakpoint->pc); breakpoint_invalidate(env, breakpoint->pc);
@ -1461,7 +1461,7 @@ void cpu_breakpoint_remove_all(CPUState *env, int mask)
#if defined(TARGET_HAS_ICE) #if defined(TARGET_HAS_ICE)
CPUBreakpoint *bp, *next; CPUBreakpoint *bp, *next;
TAILQ_FOREACH_SAFE(bp, &env->breakpoints, entry, next) { QTAILQ_FOREACH_SAFE(bp, &env->breakpoints, entry, next) {
if (bp->flags & mask) if (bp->flags & mask)
cpu_breakpoint_remove_by_ref(env, bp); cpu_breakpoint_remove_by_ref(env, bp);
} }
@ -1712,13 +1712,13 @@ CPUState *cpu_copy(CPUState *env)
/* Clone all break/watchpoints. /* Clone all break/watchpoints.
Note: Once we support ptrace with hw-debug register access, make sure Note: Once we support ptrace with hw-debug register access, make sure
BP_CPU break/watchpoints are handled correctly on clone. */ BP_CPU break/watchpoints are handled correctly on clone. */
TAILQ_INIT(&env->breakpoints); QTAILQ_INIT(&env->breakpoints);
TAILQ_INIT(&env->watchpoints); QTAILQ_INIT(&env->watchpoints);
#if defined(TARGET_HAS_ICE) #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); 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, cpu_watchpoint_insert(new_env, wp->vaddr, (~wp->len_mask) + 1,
wp->flags, NULL); wp->flags, NULL);
} }
@ -2009,7 +2009,7 @@ int tlb_set_page_exec(CPUState *env, target_ulong vaddr,
code_address = address; code_address = address;
/* Make accesses to pages with watchpoints go via the /* Make accesses to pages with watchpoints go via the
watchpoint trap routines. */ watchpoint trap routines. */
TAILQ_FOREACH(wp, &env->watchpoints, entry) { QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
if (vaddr == (wp->vaddr & TARGET_PAGE_MASK)) { if (vaddr == (wp->vaddr & TARGET_PAGE_MASK)) {
iotlb = io_mem_watch + paddr; iotlb = io_mem_watch + paddr;
/* TODO: The memory case can be optimized by not trapping /* TODO: The memory case can be optimized by not trapping
@ -2663,7 +2663,7 @@ static void check_watchpoint(int offset, int len_mask, int flags)
return; return;
} }
vaddr = (env->mem_io_vaddr & TARGET_PAGE_MASK) + offset; 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) || if ((vaddr == (wp->vaddr & len_mask) ||
(vaddr & wp->len_mask) == wp->vaddr) && (wp->flags & flags)) { (vaddr & wp->len_mask) == wp->vaddr) && (wp->flags & flags)) {
wp->flags |= BP_WATCHPOINT_HIT; wp->flags |= BP_WATCHPOINT_HIT;
@ -3169,11 +3169,11 @@ static BounceBuffer bounce;
typedef struct MapClient { typedef struct MapClient {
void *opaque; void *opaque;
void (*callback)(void *opaque); void (*callback)(void *opaque);
LIST_ENTRY(MapClient) link; QLIST_ENTRY(MapClient) link;
} MapClient; } MapClient;
static LIST_HEAD(map_client_list, MapClient) map_client_list static QLIST_HEAD(map_client_list, MapClient) map_client_list
= LIST_HEAD_INITIALIZER(map_client_list); = QLIST_HEAD_INITIALIZER(map_client_list);
void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque)) void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque))
{ {
@ -3181,7 +3181,7 @@ void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque))
client->opaque = opaque; client->opaque = opaque;
client->callback = callback; client->callback = callback;
LIST_INSERT_HEAD(&map_client_list, client, link); QLIST_INSERT_HEAD(&map_client_list, client, link);
return client; return client;
} }
@ -3189,7 +3189,7 @@ void cpu_unregister_map_client(void *_client)
{ {
MapClient *client = (MapClient *)_client; MapClient *client = (MapClient *)_client;
LIST_REMOVE(client, link); QLIST_REMOVE(client, link);
qemu_free(client); qemu_free(client);
} }
@ -3197,8 +3197,8 @@ static void cpu_notify_map_clients(void)
{ {
MapClient *client; MapClient *client;
while (!LIST_EMPTY(&map_client_list)) { while (!QLIST_EMPTY(&map_client_list)) {
client = LIST_FIRST(&map_client_list); client = QLIST_FIRST(&map_client_list);
client->callback(client->opaque); client->callback(client->opaque);
cpu_unregister_map_client(client); cpu_unregister_map_client(client);
} }

2
hw/device-hotplug.c
View File

@ -68,7 +68,7 @@ void destroy_bdrvs(dev_match_fn *match_fn, void *arg)
DriveInfo *dinfo; DriveInfo *dinfo;
struct BlockDriverState *bs; struct BlockDriverState *bs;
TAILQ_FOREACH(dinfo, &drives, next) { QTAILQ_FOREACH(dinfo, &drives, next) {
bs = dinfo->bdrv; bs = dinfo->bdrv;
if (bs) { if (bs) {
if (bs->private && match_fn(bs->private, arg)) { if (bs->private && match_fn(bs->private, arg)) {

2
hw/i2c.c
View File

@ -76,7 +76,7 @@ int i2c_start_transfer(i2c_bus *bus, int address, int recv)
DeviceState *qdev; DeviceState *qdev;
i2c_slave *slave = NULL; i2c_slave *slave = NULL;
LIST_FOREACH(qdev, &bus->qbus.children, sibling) { QLIST_FOREACH(qdev, &bus->qbus.children, sibling) {
slave = I2C_SLAVE_FROM_QDEV(qdev); slave = I2C_SLAVE_FROM_QDEV(qdev);
if (slave->address == address) if (slave->address == address)
break; break;

2
hw/pci-hotplug.c
View File

@ -84,7 +84,7 @@ void drive_hot_add(Monitor *mon, const QDict *qdict)
switch (type) { switch (type) {
case IF_SCSI: case IF_SCSI:
success = 1; 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), scsi_bus_legacy_add_drive(DO_UPCAST(SCSIBus, qbus, scsibus),
dinfo, dinfo->unit); dinfo, dinfo->unit);
break; break;

32
hw/qdev.c
View File

@ -101,7 +101,7 @@ DeviceState *qdev_create(BusState *bus, const char *name)
qdev_prop_set_defaults(dev, dev->info->props); qdev_prop_set_defaults(dev, dev->info->props);
qdev_prop_set_defaults(dev, dev->parent_bus->info->props); qdev_prop_set_defaults(dev, dev->parent_bus->info->props);
qdev_prop_set_compat(dev); qdev_prop_set_compat(dev);
LIST_INSERT_HEAD(&bus->children, dev, sibling); QLIST_INSERT_HEAD(&bus->children, dev, sibling);
return dev; return dev;
} }
@ -235,7 +235,7 @@ void qdev_free(DeviceState *dev)
#endif #endif
if (dev->info->reset) if (dev->info->reset)
qemu_unregister_reset(dev->info->reset, dev); qemu_unregister_reset(dev->info->reset, dev);
LIST_REMOVE(dev, sibling); QLIST_REMOVE(dev, sibling);
qemu_free(dev); qemu_free(dev);
} }
@ -321,7 +321,7 @@ BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
{ {
BusState *bus; BusState *bus;
LIST_FOREACH(bus, &dev->child_bus, sibling) { QLIST_FOREACH(bus, &dev->child_bus, sibling) {
if (strcmp(name, bus->name) == 0) { if (strcmp(name, bus->name) == 0) {
return bus; return bus;
} }
@ -346,8 +346,8 @@ static BusState *qbus_find_recursive(BusState *bus, const char *name,
return bus; return bus;
} }
LIST_FOREACH(dev, &bus->children, sibling) { QLIST_FOREACH(dev, &bus->children, sibling) {
LIST_FOREACH(child, &dev->child_bus, sibling) { QLIST_FOREACH(child, &dev->child_bus, sibling) {
ret = qbus_find_recursive(child, name, info); ret = qbus_find_recursive(child, name, info);
if (ret) { if (ret) {
return ret; return ret;
@ -365,7 +365,7 @@ static void qbus_list_bus(DeviceState *dev, char *dest, int len)
pos += snprintf(dest+pos, len-pos,"child busses at \"%s\":", pos += snprintf(dest+pos, len-pos,"child busses at \"%s\":",
dev->id ? dev->id : dev->info->name); 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); pos += snprintf(dest+pos, len-pos, "%s\"%s\"", sep, child->name);
sep = ", "; sep = ", ";
} }
@ -379,7 +379,7 @@ static void qbus_list_dev(BusState *bus, char *dest, int len)
pos += snprintf(dest+pos, len-pos, "devices at \"%s\":", pos += snprintf(dest+pos, len-pos, "devices at \"%s\":",
bus->name); bus->name);
LIST_FOREACH(dev, &bus->children, sibling) { QLIST_FOREACH(dev, &bus->children, sibling) {
pos += snprintf(dest+pos, len-pos, "%s\"%s\"", pos += snprintf(dest+pos, len-pos, "%s\"%s\"",
sep, dev->info->name); sep, dev->info->name);
if (dev->id) if (dev->id)
@ -392,7 +392,7 @@ static BusState *qbus_find_bus(DeviceState *dev, char *elem)
{ {
BusState *child; BusState *child;
LIST_FOREACH(child, &dev->child_bus, sibling) { QLIST_FOREACH(child, &dev->child_bus, sibling) {
if (strcmp(child->name, elem) == 0) { if (strcmp(child->name, elem) == 0) {
return child; return child;
} }
@ -410,17 +410,17 @@ static DeviceState *qbus_find_dev(BusState *bus, char *elem)
* (2) driver name * (2) driver name
* (3) driver alias, if present * (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) { if (dev->id && strcmp(dev->id, elem) == 0) {
return dev; return dev;
} }
} }
LIST_FOREACH(dev, &bus->children, sibling) { QLIST_FOREACH(dev, &bus->children, sibling) {
if (strcmp(dev->info->name, elem) == 0) { if (strcmp(dev->info->name, elem) == 0) {
return dev; return dev;
} }
} }
LIST_FOREACH(dev, &bus->children, sibling) { QLIST_FOREACH(dev, &bus->children, sibling) {
if (dev->info->alias && strcmp(dev->info->alias, elem) == 0) { if (dev->info->alias && strcmp(dev->info->alias, elem) == 0) {
return dev; return dev;
} }
@ -478,7 +478,7 @@ static BusState *qbus_find(const char *path)
qemu_error("device has no child bus (%s)\n", path); qemu_error("device has no child bus (%s)\n", path);
return NULL; return NULL;
case 1: case 1:
return LIST_FIRST(&dev->child_bus); return QLIST_FIRST(&dev->child_bus);
default: default:
qbus_list_bus(dev, msg, sizeof(msg)); qbus_list_bus(dev, msg, sizeof(msg));
qemu_error("device has multiple child busses (%s)\n%s\n", qemu_error("device has multiple child busses (%s)\n%s\n",
@ -532,9 +532,9 @@ BusState *qbus_create(BusInfo *info, DeviceState *parent, const char *name)
bus->name = buf; bus->name = buf;
} }
LIST_INIT(&bus->children); QLIST_INIT(&bus->children);
if (parent) { if (parent) {
LIST_INSERT_HEAD(&parent->child_bus, bus, sibling); QLIST_INSERT_HEAD(&parent->child_bus, bus, sibling);
parent->num_child_bus++; parent->num_child_bus++;
} }
return bus; return bus;
@ -575,7 +575,7 @@ static void qdev_print(Monitor *mon, DeviceState *dev, int indent)
qdev_print_props(mon, dev, dev->parent_bus->info->props, "bus", indent); qdev_print_props(mon, dev, dev->parent_bus->info->props, "bus", indent);
if (dev->parent_bus->info->print_dev) if (dev->parent_bus->info->print_dev)
dev->parent_bus->info->print_dev(mon, dev, indent); 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); qbus_print(mon, child, indent);
} }
} }
@ -587,7 +587,7 @@ static void qbus_print(Monitor *mon, BusState *bus, int indent)
qdev_printf("bus: %s\n", bus->name); qdev_printf("bus: %s\n", bus->name);
indent += 2; indent += 2;
qdev_printf("type %s\n", bus->info->name); 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); qdev_print(mon, dev, indent);
} }
} }

10
hw/qdev.h
View File

@ -3,7 +3,7 @@
#include "hw.h" #include "hw.h"
#include "sysemu.h" #include "sysemu.h"
#include "sys-queue.h" #include "qemu-queue.h"
#include "qemu-char.h" #include "qemu-char.h"
#include "qemu-option.h" #include "qemu-option.h"
@ -29,10 +29,10 @@ struct DeviceState {
qemu_irq *gpio_out; qemu_irq *gpio_out;
int num_gpio_in; int num_gpio_in;
qemu_irq *gpio_in; qemu_irq *gpio_in;
LIST_HEAD(, BusState) child_bus; QLIST_HEAD(, BusState) child_bus;
int num_child_bus; int num_child_bus;
NICInfo *nd; NICInfo *nd;
LIST_ENTRY(DeviceState) sibling; QLIST_ENTRY(DeviceState) sibling;
}; };
typedef void (*bus_dev_printfn)(Monitor *mon, DeviceState *dev, int indent); typedef void (*bus_dev_printfn)(Monitor *mon, DeviceState *dev, int indent);
@ -47,8 +47,8 @@ struct BusState {
DeviceState *parent; DeviceState *parent;
BusInfo *info; BusInfo *info;
const char *name; const char *name;
LIST_HEAD(, DeviceState) children; QLIST_HEAD(, DeviceState) children;
LIST_ENTRY(BusState) sibling; QLIST_ENTRY(BusState) sibling;
}; };
struct Property { struct Property {

6
hw/ssi.c
View File

@ -25,8 +25,8 @@ static int ssi_slave_init(DeviceState *dev, DeviceInfo *base_info)
SSIBus *bus; SSIBus *bus;
bus = FROM_QBUS(SSIBus, qdev_get_parent_bus(dev)); bus = FROM_QBUS(SSIBus, qdev_get_parent_bus(dev));
if (LIST_FIRST(&bus->qbus.children) != dev if (QLIST_FIRST(&bus->qbus.children) != dev
|| LIST_NEXT(dev, sibling) != NULL) { || QLIST_NEXT(dev, sibling) != NULL) {
hw_error("Too many devices on SSI bus"); hw_error("Too many devices on SSI bus");
} }
@ -61,7 +61,7 @@ uint32_t ssi_transfer(SSIBus *bus, uint32_t val)
{ {
DeviceState *dev; DeviceState *dev;
SSISlave *slave; SSISlave *slave;
dev = LIST_FIRST(&bus->qbus.children); dev = QLIST_FIRST(&bus->qbus.children);
if (!dev) { if (!dev) {
return 0; return 0;
} }

32
hw/usb-bus.c
View File

@ -12,7 +12,7 @@ static struct BusInfo usb_bus_info = {
.print_dev = usb_bus_dev_print, .print_dev = usb_bus_dev_print,
}; };
static int next_usb_bus = 0; 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) USBBus *usb_bus_new(DeviceState *host)
{ {
@ -20,9 +20,9 @@ USBBus *usb_bus_new(DeviceState *host)
bus = FROM_QBUS(USBBus, qbus_create(&usb_bus_info, host, NULL)); bus = FROM_QBUS(USBBus, qbus_create(&usb_bus_info, host, NULL));
bus->busnr = next_usb_bus++; bus->busnr = next_usb_bus++;
TAILQ_INIT(&bus->free); QTAILQ_INIT(&bus->free);
TAILQ_INIT(&bus->used); QTAILQ_INIT(&bus->used);
TAILQ_INSERT_TAIL(&busses, bus, next); QTAILQ_INSERT_TAIL(&busses, bus, next);
return bus; return bus;
} }
@ -31,8 +31,8 @@ USBBus *usb_bus_find(int busnr)
USBBus *bus; USBBus *bus;
if (-1 == busnr) if (-1 == busnr)
return TAILQ_FIRST(&busses); return QTAILQ_FIRST(&busses);
TAILQ_FOREACH(bus, &busses, next) { QTAILQ_FOREACH(bus, &busses, next) {
if (bus->busnr == busnr) if (bus->busnr == busnr)
return bus; return bus;
} }
@ -100,7 +100,7 @@ void usb_register_port(USBBus *bus, USBPort *port, void *opaque, int index,
port->opaque = opaque; port->opaque = opaque;
port->index = index; port->index = index;
port->attach = attach; port->attach = attach;
TAILQ_INSERT_TAIL(&bus->free, port, next); QTAILQ_INSERT_TAIL(&bus->free, port, next);
bus->nfree++; bus->nfree++;
} }
@ -116,13 +116,13 @@ static void do_attach(USBDevice *dev)
} }
dev->attached++; dev->attached++;
port = TAILQ_FIRST(&bus->free); port = QTAILQ_FIRST(&bus->free);
TAILQ_REMOVE(&bus->free, port, next); QTAILQ_REMOVE(&bus->free, port, next);
bus->nfree--; bus->nfree--;
usb_attach(port, dev); usb_attach(port, dev);
TAILQ_INSERT_TAIL(&bus->used, port, next); QTAILQ_INSERT_TAIL(&bus->used, port, next);
bus->nused++; bus->nused++;
} }
@ -149,7 +149,7 @@ int usb_device_delete_addr(int busnr, int addr)
if (!bus) if (!bus)
return -1; return -1;
TAILQ_FOREACH(port, &bus->used, next) { QTAILQ_FOREACH(port, &bus->used, next) {
if (port->dev->addr == addr) if (port->dev->addr == addr)
break; break;
} }
@ -157,13 +157,13 @@ int usb_device_delete_addr(int busnr, int addr)
return -1; return -1;
dev = port->dev; dev = port->dev;
TAILQ_REMOVE(&bus->used, port, next); QTAILQ_REMOVE(&bus->used, port, next);
bus->nused--; bus->nused--;
usb_attach(port, NULL); usb_attach(port, NULL);
dev->info->handle_destroy(dev); dev->info->handle_destroy(dev);
TAILQ_INSERT_TAIL(&bus->free, port, next); QTAILQ_INSERT_TAIL(&bus->free, port, next);
bus->nfree++; bus->nfree++;
return 0; return 0;
} }
@ -196,13 +196,13 @@ void usb_info(Monitor *mon)
USBDevice *dev; USBDevice *dev;
USBPort *port; USBPort *port;
if (TAILQ_EMPTY(&busses)) { if (QTAILQ_EMPTY(&busses)) {
monitor_printf(mon, "USB support not enabled\n"); monitor_printf(mon, "USB support not enabled\n");
return; return;
} }
TAILQ_FOREACH(bus, &busses, next) { QTAILQ_FOREACH(bus, &busses, next) {
TAILQ_FOREACH(port, &bus->used, next) { QTAILQ_FOREACH(port, &bus->used, next) {
dev = port->dev; dev = port->dev;
if (!dev) if (!dev)
continue; continue;

14
hw/usb-net.c
View File

@ -26,7 +26,7 @@
#include "qemu-common.h" #include "qemu-common.h"
#include "usb.h" #include "usb.h"
#include "net.h" #include "net.h"
#include "sys-queue.h" #include "qemu-queue.h"
/*#define TRAFFIC_DEBUG*/ /*#define TRAFFIC_DEBUG*/
/* Thanks to NetChip Technologies for donating this product ID. /* Thanks to NetChip Technologies for donating this product ID.
@ -595,7 +595,7 @@ static const uint32_t oid_supported_list[] =
#define NDIS_MAC_OPTION_8021P_PRIORITY (1 << 6) #define NDIS_MAC_OPTION_8021P_PRIORITY (1 << 6)
struct rndis_response { struct rndis_response {
TAILQ_ENTRY(rndis_response) entries; QTAILQ_ENTRY(rndis_response) entries;
uint32_t length; uint32_t length;
uint8_t buf[0]; uint8_t buf[0];
}; };
@ -621,7 +621,7 @@ typedef struct USBNetState {
char usbstring_mac[13]; char usbstring_mac[13];
VLANClientState *vc; VLANClientState *vc;
TAILQ_HEAD(rndis_resp_head, rndis_response) rndis_resp; QTAILQ_HEAD(rndis_resp_head, rndis_response) rndis_resp;
} USBNetState; } USBNetState;
static int ndis_query(USBNetState *s, uint32_t oid, static int ndis_query(USBNetState *s, uint32_t oid,
@ -812,7 +812,7 @@ static int rndis_get_response(USBNetState *s, uint8_t *buf)
if (!r) if (!r)
return ret; return ret;
TAILQ_REMOVE(&s->rndis_resp, r, entries); QTAILQ_REMOVE(&s->rndis_resp, r, entries);
ret = r->length; ret = r->length;
memcpy(buf, r->buf, r->length); memcpy(buf, r->buf, r->length);
qemu_free(r); qemu_free(r);
@ -825,7 +825,7 @@ static void *rndis_queue_response(USBNetState *s, unsigned int length)
struct rndis_response *r = struct rndis_response *r =
qemu_mallocz(sizeof(struct rndis_response) + length); 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; r->length = length;
return &r->buf[0]; return &r->buf[0];
@ -836,7 +836,7 @@ static void rndis_clear_responsequeue(USBNetState *s)
struct rndis_response *r; struct rndis_response *r;
while ((r = s->rndis_resp.tqh_first)) { while ((r = s->rndis_resp.tqh_first)) {
TAILQ_REMOVE(&s->rndis_resp, r, entries); QTAILQ_REMOVE(&s->rndis_resp, r, entries);
qemu_free(r); qemu_free(r);
} }
} }
@ -1440,7 +1440,7 @@ static int usb_net_initfn(USBDevice *dev)
s->rndis = 1; s->rndis = 1;
s->rndis_state = RNDIS_UNINITIALIZED; s->rndis_state = RNDIS_UNINITIALIZED;
TAILQ_INIT(&s->rndis_resp); QTAILQ_INIT(&s->rndis_resp);
s->medium = 0; /* NDIS_MEDIUM_802_3 */ s->medium = 0; /* NDIS_MEDIUM_802_3 */
s->speed = 1000000; /* 100MBps, in 100Bps units */ s->speed = 1000000; /* 100MBps, in 100Bps units */

10
hw/usb.h
View File

@ -24,7 +24,7 @@
#include "block.h" #include "block.h"
#include "qdev.h" #include "qdev.h"
#include "sys-queue.h" #include "qemu-queue.h"
#define USB_TOKEN_SETUP 0x2d #define USB_TOKEN_SETUP 0x2d
#define USB_TOKEN_IN 0x69 /* device -> host */ #define USB_TOKEN_IN 0x69 /* device -> host */
@ -193,7 +193,7 @@ struct USBPort {
usb_attachfn attach; usb_attachfn attach;
void *opaque; void *opaque;
int index; /* internal port index, may be used with the 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); typedef void USBCallback(USBPacket * packet, void *opaque);
@ -298,9 +298,9 @@ struct USBBus {
int busnr; int busnr;
int nfree; int nfree;
int nused; int nused;
TAILQ_HEAD(, USBPort) free; QTAILQ_HEAD(, USBPort) free;
TAILQ_HEAD(, USBPort) used; QTAILQ_HEAD(, USBPort) used;
TAILQ_ENTRY(USBBus) next; QTAILQ_ENTRY(USBBus) next;
}; };
USBBus *usb_bus_new(DeviceState *host); USBBus *usb_bus_new(DeviceState *host);

12
hw/watchdog.c
View File

@ -22,7 +22,7 @@
#include "qemu-common.h" #include "qemu-common.h"
#include "qemu-option.h" #include "qemu-option.h"
#include "qemu-config.h" #include "qemu-config.h"
#include "sys-queue.h" #include "qemu-queue.h"
#include "sysemu.h" #include "sysemu.h"
#include "hw/watchdog.h" #include "hw/watchdog.h"
@ -35,11 +35,11 @@
#define WDT_NONE 6 /* Do nothing. */ #define WDT_NONE 6 /* Do nothing. */
static int watchdog_action = WDT_RESET; 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) void watchdog_add_model(WatchdogTimerModel *model)
{ {
LIST_INSERT_HEAD(&watchdog_list, model, entry); QLIST_INSERT_HEAD(&watchdog_list, model, entry);
} }
/* Returns: /* Returns:
@ -54,14 +54,14 @@ int select_watchdog(const char *p)
/* -watchdog ? lists available devices and exits cleanly. */ /* -watchdog ? lists available devices and exits cleanly. */
if (strcmp(p, "?") == 0) { if (strcmp(p, "?") == 0) {
LIST_FOREACH(model, &watchdog_list, entry) { QLIST_FOREACH(model, &watchdog_list, entry) {
fprintf(stderr, "\t%s\t%s\n", fprintf(stderr, "\t%s\t%s\n",
model->wdt_name, model->wdt_description); model->wdt_name, model->wdt_description);
} }
return 2; return 2;
} }
LIST_FOREACH(model, &watchdog_list, entry) { QLIST_FOREACH(model, &watchdog_list, entry) {
if (strcasecmp(model->wdt_name, p) == 0) { if (strcasecmp(model->wdt_name, p) == 0) {
/* add the device */ /* add the device */
opts = qemu_opts_create(&qemu_device_opts, NULL, 0); opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
@ -71,7 +71,7 @@ int select_watchdog(const char *p)
} }
fprintf(stderr, "Unknown -watchdog device. Supported devices are:\n"); 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", fprintf(stderr, "\t%s\t%s\n",
model->wdt_name, model->wdt_description); model->wdt_name, model->wdt_description);
} }

2
hw/watchdog.h
View File

@ -23,7 +23,7 @@
#define QEMU_WATCHDOG_H #define QEMU_WATCHDOG_H
struct WatchdogTimerModel { struct WatchdogTimerModel {
LIST_ENTRY(WatchdogTimerModel) entry; QLIST_ENTRY(WatchdogTimerModel) entry;
/* Short name of the device - used to select it on the command line. */ /* Short name of the device - used to select it on the command line. */
const char *wdt_name; const char *wdt_name;

10
hw/xen_backend.c
View File

@ -48,7 +48,7 @@ struct xs_handle *xenstore = NULL;
const char *xen_protocol; const char *xen_protocol;
/* private */ /* 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; static int debug = 0;
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
@ -165,7 +165,7 @@ struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev)
{ {
struct XenDevice *xendev; struct XenDevice *xendev;
TAILQ_FOREACH(xendev, &xendevs, next) { QTAILQ_FOREACH(xendev, &xendevs, next) {
if (xendev->dom != dom) if (xendev->dom != dom)
continue; continue;
if (xendev->dev != dev) if (xendev->dev != dev)
@ -227,7 +227,7 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev,
xendev->gnttabdev = -1; xendev->gnttabdev = -1;
} }
TAILQ_INSERT_TAIL(&xendevs, xendev, next); QTAILQ_INSERT_TAIL(&xendevs, xendev, next);
if (xendev->ops->alloc) if (xendev->ops->alloc)
xendev->ops->alloc(xendev); xendev->ops->alloc(xendev);
@ -243,7 +243,7 @@ static struct XenDevice *xen_be_del_xendev(int dom, int dev)
struct XenDevice *xendev, *xnext; 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. * we save the next pointer in xnext because we might free xendev.
*/ */
xnext = xendevs.tqh_first; xnext = xendevs.tqh_first;
@ -271,7 +271,7 @@ static struct XenDevice *xen_be_del_xendev(int dom, int dev)
if (xendev->gnttabdev >= 0) if (xendev->gnttabdev >= 0)
xc_gnttab_close(xendev->gnttabdev); xc_gnttab_close(xendev->gnttabdev);
TAILQ_REMOVE(&xendevs, xendev, next); QTAILQ_REMOVE(&xendevs, xendev, next);
qemu_free(xendev); qemu_free(xendev);
} }
return NULL; return NULL;

2
hw/xen_backend.h
View File

@ -50,7 +50,7 @@ struct XenDevice {
int gnttabdev; int gnttabdev;
struct XenDevOps *ops; struct XenDevOps *ops;
TAILQ_ENTRY(XenDevice) next; QTAILQ_ENTRY(XenDevice) next;
}; };
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */

8
hw/xen_devconfig.c
View File

@ -4,9 +4,9 @@
struct xs_dirs { struct xs_dirs {
char *xs_dir; 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) static void xen_config_cleanup_dir(char *dir)
{ {
@ -14,14 +14,14 @@ static void xen_config_cleanup_dir(char *dir)
d = qemu_malloc(sizeof(*d)); d = qemu_malloc(sizeof(*d));
d->xs_dir = dir; d->xs_dir = dir;
TAILQ_INSERT_TAIL(&xs_cleanup, d, list); QTAILQ_INSERT_TAIL(&xs_cleanup, d, list);
} }
void xen_config_cleanup(void) void xen_config_cleanup(void)
{ {
struct xs_dirs *d; struct xs_dirs *d;
TAILQ_FOREACH(d, &xs_cleanup, list) { QTAILQ_FOREACH(d, &xs_cleanup, list) {
xs_rm(xenstore, 0, d->xs_dir); xs_rm(xenstore, 0, d->xs_dir);
} }
} }

40
hw/xen_disk.c
View File

@ -77,7 +77,7 @@ struct ioreq {
int aio_errors; int aio_errors;
struct XenBlkDev *blkdev; struct XenBlkDev *blkdev;
LIST_ENTRY(ioreq) list; QLIST_ENTRY(ioreq) list;
}; };
struct XenBlkDev { struct XenBlkDev {
@ -99,9 +99,9 @@ struct XenBlkDev {
int cnt_map; int cnt_map;
/* request lists */ /* request lists */
LIST_HEAD(inflight_head, ioreq) inflight; QLIST_HEAD(inflight_head, ioreq) inflight;
LIST_HEAD(finished_head, ioreq) finished; QLIST_HEAD(finished_head, ioreq) finished;
LIST_HEAD(freelist_head, ioreq) freelist; QLIST_HEAD(freelist_head, ioreq) freelist;
int requests_total; int requests_total;
int requests_inflight; int requests_inflight;
int requests_finished; int requests_finished;
@ -118,7 +118,7 @@ static struct ioreq *ioreq_start(struct XenBlkDev *blkdev)
{ {
struct ioreq *ioreq = NULL; struct ioreq *ioreq = NULL;
if (LIST_EMPTY(&blkdev->freelist)) { if (QLIST_EMPTY(&blkdev->freelist)) {
if (blkdev->requests_total >= max_requests) if (blkdev->requests_total >= max_requests)
goto out; goto out;
/* allocate new struct */ /* allocate new struct */
@ -128,11 +128,11 @@ static struct ioreq *ioreq_start(struct XenBlkDev *blkdev)
qemu_iovec_init(&ioreq->v, BLKIF_MAX_SEGMENTS_PER_REQUEST); qemu_iovec_init(&ioreq->v, BLKIF_MAX_SEGMENTS_PER_REQUEST);
} else { } else {
/* get one from freelist */ /* get one from freelist */
ioreq = LIST_FIRST(&blkdev->freelist); ioreq = QLIST_FIRST(&blkdev->freelist);
LIST_REMOVE(ioreq, list); QLIST_REMOVE(ioreq, list);
qemu_iovec_reset(&ioreq->v); qemu_iovec_reset(&ioreq->v);
} }
LIST_INSERT_HEAD(&blkdev->inflight, ioreq, list); QLIST_INSERT_HEAD(&blkdev->inflight, ioreq, list);
blkdev->requests_inflight++; blkdev->requests_inflight++;
out: out:
@ -143,8 +143,8 @@ static void ioreq_finish(struct ioreq *ioreq)
{ {
struct XenBlkDev *blkdev = ioreq->blkdev; struct XenBlkDev *blkdev = ioreq->blkdev;
LIST_REMOVE(ioreq, list); QLIST_REMOVE(ioreq, list);
LIST_INSERT_HEAD(&blkdev->finished, ioreq, list); QLIST_INSERT_HEAD(&blkdev->finished, ioreq, list);
blkdev->requests_inflight--; blkdev->requests_inflight--;
blkdev->requests_finished++; blkdev->requests_finished++;
} }
@ -153,10 +153,10 @@ static void ioreq_release(struct ioreq *ioreq)
{ {
struct XenBlkDev *blkdev = ioreq->blkdev; struct XenBlkDev *blkdev = ioreq->blkdev;
LIST_REMOVE(ioreq, list); QLIST_REMOVE(ioreq, list);
memset(ioreq, 0, sizeof(*ioreq)); memset(ioreq, 0, sizeof(*ioreq));
ioreq->blkdev = blkdev; ioreq->blkdev = blkdev;
LIST_INSERT_HEAD(&blkdev->freelist, ioreq, list); QLIST_INSERT_HEAD(&blkdev->freelist, ioreq, list);
blkdev->requests_finished--; blkdev->requests_finished--;
} }
@ -476,8 +476,8 @@ static void blk_send_response_all(struct XenBlkDev *blkdev)
struct ioreq *ioreq; struct ioreq *ioreq;
int send_notify = 0; int send_notify = 0;
while (!LIST_EMPTY(&blkdev->finished)) { while (!QLIST_EMPTY(&blkdev->finished)) {
ioreq = LIST_FIRST(&blkdev->finished); ioreq = QLIST_FIRST(&blkdev->finished);
send_notify += blk_send_response_one(ioreq); send_notify += blk_send_response_one(ioreq);
ioreq_release(ioreq); ioreq_release(ioreq);
} }
@ -564,9 +564,9 @@ static void blk_alloc(struct XenDevice *xendev)
{ {
struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
LIST_INIT(&blkdev->inflight); QLIST_INIT(&blkdev->inflight);
LIST_INIT(&blkdev->finished); QLIST_INIT(&blkdev->finished);
LIST_INIT(&blkdev->freelist); QLIST_INIT(&blkdev->freelist);
blkdev->bh = qemu_bh_new(blk_bh, blkdev); blkdev->bh = qemu_bh_new(blk_bh, blkdev);
if (xen_mode != XEN_EMULATE) if (xen_mode != XEN_EMULATE)
batch_maps = 1; batch_maps = 1;
@ -750,9 +750,9 @@ static int blk_free(struct XenDevice *xendev)
struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
struct ioreq *ioreq; struct ioreq *ioreq;
while (!LIST_EMPTY(&blkdev->freelist)) { while (!QLIST_EMPTY(&blkdev->freelist)) {
ioreq = LIST_FIRST(&blkdev->freelist); ioreq = QLIST_FIRST(&blkdev->freelist);
LIST_REMOVE(ioreq, list); QLIST_REMOVE(ioreq, list);
qemu_iovec_destroy(&ioreq->v); qemu_iovec_destroy(&ioreq->v);
qemu_free(ioreq); qemu_free(ioreq);
} }

12
kvm-all.c
View File

@ -428,7 +428,7 @@ int kvm_init(int smp_cpus)
s = qemu_mallocz(sizeof(KVMState)); s = qemu_mallocz(sizeof(KVMState));
#ifdef KVM_CAP_SET_GUEST_DEBUG #ifdef KVM_CAP_SET_GUEST_DEBUG
TAILQ_INIT(&s->kvm_sw_breakpoints); QTAILQ_INIT(&s->kvm_sw_breakpoints);
#endif #endif
for (i = 0; i < ARRAY_SIZE(s->slots); i++) for (i = 0; i < ARRAY_SIZE(s->slots); i++)
s->slots[i].slot = i; s->slots[i].slot = i;
@ -917,7 +917,7 @@ struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *env,
{ {
struct kvm_sw_breakpoint *bp; 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) if (bp->pc == pc)
return bp; return bp;
} }
@ -926,7 +926,7 @@ struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *env,
int kvm_sw_breakpoints_active(CPUState *env) int kvm_sw_breakpoints_active(CPUState *env)
{ {
return !TAILQ_EMPTY(&env->kvm_state->kvm_sw_breakpoints); return !QTAILQ_EMPTY(&env->kvm_state->kvm_sw_breakpoints);
} }
struct kvm_set_guest_debug_data { struct kvm_set_guest_debug_data {
@ -983,7 +983,7 @@ int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
return err; return err;
} }
TAILQ_INSERT_HEAD(&current_env->kvm_state->kvm_sw_breakpoints, QTAILQ_INSERT_HEAD(&current_env->kvm_state->kvm_sw_breakpoints,
bp, entry); bp, entry);
} else { } else {
err = kvm_arch_insert_hw_breakpoint(addr, len, type); err = kvm_arch_insert_hw_breakpoint(addr, len, type);
@ -1020,7 +1020,7 @@ int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
if (err) if (err)
return err; return err;
TAILQ_REMOVE(&current_env->kvm_state->kvm_sw_breakpoints, bp, entry); QTAILQ_REMOVE(&current_env->kvm_state->kvm_sw_breakpoints, bp, entry);
qemu_free(bp); qemu_free(bp);
} else { } else {
err = kvm_arch_remove_hw_breakpoint(addr, len, type); err = kvm_arch_remove_hw_breakpoint(addr, len, type);
@ -1042,7 +1042,7 @@ void kvm_remove_all_breakpoints(CPUState *current_env)
KVMState *s = current_env->kvm_state; KVMState *s = current_env->kvm_state;
CPUState *env; 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) { if (kvm_arch_remove_sw_breakpoint(current_env, bp) != 0) {
/* Try harder to find a CPU that currently sees the breakpoint. */ /* Try harder to find a CPU that currently sees the breakpoint. */
for (env = first_cpu; env != NULL; env = env->next_cpu) { for (env = first_cpu; env != NULL; env = env->next_cpu) {

6
kvm.h
View File

@ -15,7 +15,7 @@
#define QEMU_KVM_H #define QEMU_KVM_H
#include "config.h" #include "config.h"
#include "sys-queue.h" #include "qemu-queue.h"
#ifdef CONFIG_KVM #ifdef CONFIG_KVM
extern int kvm_allowed; extern int kvm_allowed;
@ -100,10 +100,10 @@ struct kvm_sw_breakpoint {
target_ulong pc; target_ulong pc;
target_ulong saved_insn; target_ulong saved_insn;
int use_count; 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); int kvm_arch_debug(struct kvm_debug_exit_arch *arch_info);

28
linux-user/elfload.c
View File

@ -1844,7 +1844,7 @@ struct target_elf_prpsinfo {
/* Here is the structure in which status of each thread is captured. */ /* Here is the structure in which status of each thread is captured. */
struct elf_thread_status { 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 */ struct target_elf_prstatus prstatus; /* NT_PRSTATUS */
#if 0 #if 0
elf_fpregset_t fpu; /* NT_PRFPREG */ elf_fpregset_t fpu; /* NT_PRFPREG */
@ -1860,7 +1860,7 @@ struct elf_note_info {
struct target_elf_prstatus *prstatus; /* NT_PRSTATUS */ struct target_elf_prstatus *prstatus; /* NT_PRSTATUS */
struct target_elf_prpsinfo *psinfo; /* NT_PRPSINFO */ 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 #if 0
/* /*
* Current version of ELF coredump doesn't support * Current version of ELF coredump doesn't support
@ -1878,11 +1878,11 @@ struct vm_area_struct {
abi_ulong vma_start; /* start vaddr of memory region */ abi_ulong vma_start; /* start vaddr of memory region */
abi_ulong vma_end; /* end vaddr of memory region */ abi_ulong vma_end; /* end vaddr of memory region */
abi_ulong vma_flags; /* protection etc. flags for the 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 { struct mm_struct {
TAILQ_HEAD(, vm_area_struct) mm_mmap; QTAILQ_HEAD(, vm_area_struct) mm_mmap;
int mm_count; /* number of mappings */ int mm_count; /* number of mappings */
}; };
@ -1962,7 +1962,7 @@ static struct mm_struct *vma_init(void)
return (NULL); return (NULL);
mm->mm_count = 0; mm->mm_count = 0;
TAILQ_INIT(&mm->mm_mmap); QTAILQ_INIT(&mm->mm_mmap);
return (mm); return (mm);
} }
@ -1972,7 +1972,7 @@ static void vma_delete(struct mm_struct *mm)
struct vm_area_struct *vma; struct vm_area_struct *vma;
while ((vma = vma_first(mm)) != NULL) { 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(vma);
} }
qemu_free(mm); qemu_free(mm);
@ -1990,7 +1990,7 @@ static int vma_add_mapping(struct mm_struct *mm, abi_ulong start,
vma->vma_end = end; vma->vma_end = end;
vma->vma_flags = flags; 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++; mm->mm_count++;
return (0); return (0);
@ -1998,12 +1998,12 @@ static int vma_add_mapping(struct mm_struct *mm, abi_ulong start,
static struct vm_area_struct *vma_first(const struct mm_struct *mm) 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) 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) static int vma_get_mapping_count(const struct mm_struct *mm)
@ -2328,7 +2328,7 @@ static void fill_thread_info(struct elf_note_info *info, const CPUState *env)
fill_note(&ets->notes[0], "CORE", NT_PRSTATUS, sizeof (ets->prstatus), fill_note(&ets->notes[0], "CORE", NT_PRSTATUS, sizeof (ets->prstatus),
&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]); info->notes_size += note_size(&ets->notes[0]);
} }
@ -2343,7 +2343,7 @@ static int fill_note_info(struct elf_note_info *info,
(void) memset(info, 0, sizeof (*info)); (void) memset(info, 0, sizeof (*info));
TAILQ_INIT(&info->thread_list); QTAILQ_INIT(&info->thread_list);
info->notes = qemu_mallocz(NUMNOTES * sizeof (struct memelfnote)); info->notes = qemu_mallocz(NUMNOTES * sizeof (struct memelfnote));
if (info->notes == NULL) if (info->notes == NULL)
@ -2389,9 +2389,9 @@ static void free_note_info(struct elf_note_info *info)
{ {
struct elf_thread_status *ets; struct elf_thread_status *ets;
while (!TAILQ_EMPTY(&info->thread_list)) { while (!QTAILQ_EMPTY(&info->thread_list)) {
ets = TAILQ_FIRST(&info->thread_list); ets = QTAILQ_FIRST(&info->thread_list);
TAILQ_REMOVE(&info->thread_list, ets, ets_link); QTAILQ_REMOVE(&info->thread_list, ets, ets_link);
qemu_free(ets); qemu_free(ets);
} }

2
linux-user/qemu.h
View File

@ -18,7 +18,7 @@
#include "syscall.h" #include "syscall.h"
#include "target_signal.h" #include "target_signal.h"
#include "gdbstub.h" #include "gdbstub.h"
#include "sys-queue.h" #include "qemu-queue.h"
#if defined(CONFIG_USE_NPTL) #if defined(CONFIG_USE_NPTL)
#define THREAD __thread #define THREAD __thread

12
module.c
View File

@ -12,17 +12,17 @@
*/ */
#include "qemu-common.h" #include "qemu-common.h"
#include "sys-queue.h" #include "qemu-queue.h"
#include "module.h" #include "module.h"
typedef struct ModuleEntry typedef struct ModuleEntry
{ {
module_init_type type; module_init_type type;
void (*init)(void); void (*init)(void);
TAILQ_ENTRY(ModuleEntry) node; QTAILQ_ENTRY(ModuleEntry) node;
} ModuleEntry; } ModuleEntry;
typedef TAILQ_HEAD(, ModuleEntry) ModuleTypeList; typedef QTAILQ_HEAD(, ModuleEntry) ModuleTypeList;
static ModuleTypeList init_type_list[MODULE_INIT_MAX]; static ModuleTypeList init_type_list[MODULE_INIT_MAX];
@ -36,7 +36,7 @@ static void init_types(void)
} }
for (i = 0; i < MODULE_INIT_MAX; i++) { for (i = 0; i < MODULE_INIT_MAX; i++) {
TAILQ_INIT(&init_type_list[i]); QTAILQ_INIT(&init_type_list[i]);
} }
inited = 1; inited = 1;
@ -64,7 +64,7 @@ void register_module_init(void (*fn)(void), module_init_type type)
l = find_type(type); l = find_type(type);
TAILQ_INSERT_TAIL(l, e, node); QTAILQ_INSERT_TAIL(l, e, node);
} }
void module_call_init(module_init_type type) void module_call_init(module_init_type type)
@ -74,7 +74,7 @@ void module_call_init(module_init_type type)
l = find_type(type); l = find_type(type);
TAILQ_FOREACH(e, l, node) { QTAILQ_FOREACH(e, l, node) {
e->init(); e->init();
} }
} }

32
monitor.c
View File

@ -80,7 +80,7 @@ typedef struct mon_fd_t mon_fd_t;
struct mon_fd_t { struct mon_fd_t {
char *name; char *name;
int fd; int fd;
LIST_ENTRY(mon_fd_t) next; QLIST_ENTRY(mon_fd_t) next;
}; };
struct Monitor { struct Monitor {
@ -95,11 +95,11 @@ struct Monitor {
CPUState *mon_cpu; CPUState *mon_cpu;
BlockDriverCompletionFunc *password_completion_cb; BlockDriverCompletionFunc *password_completion_cb;
void *password_opaque; void *password_opaque;
LIST_HEAD(,mon_fd_t) fds; QLIST_HEAD(,mon_fd_t) fds;
LIST_ENTRY(Monitor) entry; 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 mon_cmds[];
static const mon_cmd_t info_cmds[]; static const mon_cmd_t info_cmds[];
@ -270,7 +270,7 @@ static void do_commit(Monitor *mon, const QDict *qdict)
const char *device = qdict_get_str(qdict, "device"); const char *device = qdict_get_str(qdict, "device");
all_devices = !strcmp(device, "all"); all_devices = !strcmp(device, "all");
TAILQ_FOREACH(dinfo, &drives, next) { QTAILQ_FOREACH(dinfo, &drives, next) {
if (!all_devices) if (!all_devices)
if (strcmp(bdrv_get_device_name(dinfo->bdrv), device)) if (strcmp(bdrv_get_device_name(dinfo->bdrv), device))
continue; continue;
@ -1477,7 +1477,7 @@ static void do_info_profile(Monitor *mon)
#endif #endif
/* Capture support */ /* 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) static void do_info_capture(Monitor *mon)
{ {
@ -1500,7 +1500,7 @@ static void do_stop_capture(Monitor *mon, const QDict *qdict)
for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) { for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
if (i == n) { if (i == n) {
s->ops.destroy (s->opaque); s->ops.destroy (s->opaque);
LIST_REMOVE (s, entries); QLIST_REMOVE (s, entries);
qemu_free (s); qemu_free (s);
return; return;
} }
@ -1528,7 +1528,7 @@ static void do_wav_capture(Monitor *mon, const QDict *qdict)
monitor_printf(mon, "Faied to add wave capture\n"); monitor_printf(mon, "Faied to add wave capture\n");
qemu_free (s); qemu_free (s);
} }
LIST_INSERT_HEAD (&capture_head, s, entries); QLIST_INSERT_HEAD (&capture_head, s, entries);
} }
#endif #endif
@ -1600,7 +1600,7 @@ static void do_acl_show(Monitor *mon, const QDict *qdict)
if (acl) { if (acl) {
monitor_printf(mon, "policy: %s\n", monitor_printf(mon, "policy: %s\n",
acl->defaultDeny ? "deny" : "allow"); acl->defaultDeny ? "deny" : "allow");
TAILQ_FOREACH(entry, &acl->entries, next) { QTAILQ_FOREACH(entry, &acl->entries, next) {
i++; i++;
monitor_printf(mon, "%d: %s %s\n", i, monitor_printf(mon, "%d: %s %s\n", i,
entry->deny ? "deny" : "allow", entry->match); entry->deny ? "deny" : "allow", entry->match);
@ -1729,7 +1729,7 @@ static void do_getfd(Monitor *mon, const QDict *qdict)
return; return;
} }
LIST_FOREACH(monfd, &mon->fds, next) { QLIST_FOREACH(monfd, &mon->fds, next) {
if (strcmp(monfd->name, fdname) != 0) { if (strcmp(monfd->name, fdname) != 0) {
continue; continue;
} }
@ -1743,7 +1743,7 @@ static void do_getfd(Monitor *mon, const QDict *qdict)
monfd->name = qemu_strdup(fdname); monfd->name = qemu_strdup(fdname);
monfd->fd = fd; 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) static void do_closefd(Monitor *mon, const QDict *qdict)
@ -1751,12 +1751,12 @@ static void do_closefd(Monitor *mon, const QDict *qdict)
const char *fdname = qdict_get_str(qdict, "fdname"); const char *fdname = qdict_get_str(qdict, "fdname");
mon_fd_t *monfd; mon_fd_t *monfd;
LIST_FOREACH(monfd, &mon->fds, next) { QLIST_FOREACH(monfd, &mon->fds, next) {
if (strcmp(monfd->name, fdname) != 0) { if (strcmp(monfd->name, fdname) != 0) {
continue; continue;
} }
LIST_REMOVE(monfd, next); QLIST_REMOVE(monfd, next);
close(monfd->fd); close(monfd->fd);
qemu_free(monfd->name); qemu_free(monfd->name);
qemu_free(monfd); qemu_free(monfd);
@ -1782,7 +1782,7 @@ int monitor_get_fd(Monitor *mon, const char *fdname)
{ {
mon_fd_t *monfd; mon_fd_t *monfd;
LIST_FOREACH(monfd, &mon->fds, next) { QLIST_FOREACH(monfd, &mon->fds, next) {
int fd; int fd;
if (strcmp(monfd->name, fdname) != 0) { if (strcmp(monfd->name, fdname) != 0) {
@ -1792,7 +1792,7 @@ int monitor_get_fd(Monitor *mon, const char *fdname)
fd = monfd->fd; fd = monfd->fd;
/* caller takes ownership of fd */ /* caller takes ownership of fd */
LIST_REMOVE(monfd, next); QLIST_REMOVE(monfd, next);
qemu_free(monfd->name); qemu_free(monfd->name);
qemu_free(monfd); qemu_free(monfd);
@ -3178,7 +3178,7 @@ void monitor_init(CharDriverState *chr, int flags)
qemu_chr_add_handlers(chr, monitor_can_read, monitor_read, monitor_event, qemu_chr_add_handlers(chr, monitor_can_read, monitor_read, monitor_event,
mon); mon);
LIST_INSERT_HEAD(&mon_list, mon, entry); QLIST_INSERT_HEAD(&mon_list, mon, entry);
if (!cur_mon || (flags & MONITOR_IS_DEFAULT)) if (!cur_mon || (flags & MONITOR_IS_DEFAULT))
cur_mon = mon; cur_mon = mon;
} }

51
net.c
View File

@ -31,8 +31,6 @@
/* Needed early for CONFIG_BSD etc. */ /* Needed early for CONFIG_BSD etc. */
#include "config-host.h" #include "config-host.h"
/* Needed early to override system queue definitions on BSD */
#include "sys-queue.h"
#ifndef _WIN32 #ifndef _WIN32
#include <sys/times.h> #include <sys/times.h>
@ -114,6 +112,7 @@
#include "qemu-log.h" #include "qemu-log.h"
#include "slirp/libslirp.h" #include "slirp/libslirp.h"
#include "qemu-queue.h"
static VLANState *first_vlan; static VLANState *first_vlan;
@ -440,9 +439,9 @@ void qemu_purge_queued_packets(VLANClientState *vc)
{ {
VLANPacket *packet, *next; 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) { if (packet->sender == vc) {
TAILQ_REMOVE(&vc->vlan->send_queue, packet, entry); QTAILQ_REMOVE(&vc->vlan->send_queue, packet, entry);
qemu_free(packet); qemu_free(packet);
} }
} }
@ -450,16 +449,16 @@ void qemu_purge_queued_packets(VLANClientState *vc)
void qemu_flush_queued_packets(VLANClientState *vc) void qemu_flush_queued_packets(VLANClientState *vc)
{ {
while (!TAILQ_EMPTY(&vc->vlan->send_queue)) { while (!QTAILQ_EMPTY(&vc->vlan->send_queue)) {
VLANPacket *packet; VLANPacket *packet;
int ret; int ret;
packet = TAILQ_FIRST(&vc->vlan->send_queue); packet = QTAILQ_FIRST(&vc->vlan->send_queue);
TAILQ_REMOVE(&vc->vlan->send_queue, packet, entry); QTAILQ_REMOVE(&vc->vlan->send_queue, packet, entry);
ret = qemu_deliver_packet(packet->sender, packet->data, packet->size); ret = qemu_deliver_packet(packet->sender, packet->data, packet->size);
if (ret == 0 && packet->sent_cb != NULL) { 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; break;
} }
@ -482,7 +481,7 @@ static void qemu_enqueue_packet(VLANClientState *sender,
packet->sent_cb = sent_cb; packet->sent_cb = sent_cb;
memcpy(packet->data, buf, size); 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, ssize_t qemu_send_packet_async(VLANClientState *sender,
@ -605,7 +604,7 @@ static ssize_t qemu_enqueue_packet_iov(VLANClientState *sender,
packet->size += len; packet->size += len;
} }
TAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry); QTAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry);
return packet->size; return packet->size;
} }
@ -671,7 +670,7 @@ struct slirp_config_str {
}; };
typedef struct SlirpState { typedef struct SlirpState {
TAILQ_ENTRY(SlirpState) entry; QTAILQ_ENTRY(SlirpState) entry;
VLANClientState *vc; VLANClientState *vc;
Slirp *slirp; Slirp *slirp;
#ifndef _WIN32 #ifndef _WIN32
@ -682,8 +681,8 @@ typedef struct SlirpState {
static struct slirp_config_str *slirp_configs; static struct slirp_config_str *slirp_configs;
const char *legacy_tftp_prefix; const char *legacy_tftp_prefix;
const char *legacy_bootp_filename; const char *legacy_bootp_filename;
static TAILQ_HEAD(slirp_stacks, SlirpState) slirp_stacks = static QTAILQ_HEAD(slirp_stacks, SlirpState) slirp_stacks =
TAILQ_HEAD_INITIALIZER(slirp_stacks); QTAILQ_HEAD_INITIALIZER(slirp_stacks);
static void slirp_hostfwd(SlirpState *s, Monitor *mon, const char *redir_str, static void slirp_hostfwd(SlirpState *s, Monitor *mon, const char *redir_str,
int legacy_format); int legacy_format);
@ -736,7 +735,7 @@ static void net_slirp_cleanup(VLANClientState *vc)
slirp_cleanup(s->slirp); slirp_cleanup(s->slirp);
slirp_smb_cleanup(s); slirp_smb_cleanup(s);
TAILQ_REMOVE(&slirp_stacks, s, entry); QTAILQ_REMOVE(&slirp_stacks, s, entry);
qemu_free(s); qemu_free(s);
} }
@ -844,7 +843,7 @@ static int net_slirp_init(Monitor *mon, VLANState *vlan, const char *model,
s = qemu_mallocz(sizeof(SlirpState)); s = qemu_mallocz(sizeof(SlirpState));
s->slirp = slirp_init(restricted, net, mask, host, vhostname, s->slirp = slirp_init(restricted, net, mask, host, vhostname,
tftp_export, bootfile, dhcp, dns, s); tftp_export, bootfile, dhcp, dns, s);
TAILQ_INSERT_TAIL(&slirp_stacks, s, entry); QTAILQ_INSERT_TAIL(&slirp_stacks, s, entry);
while (slirp_configs) { while (slirp_configs) {
struct slirp_config_str *config = slirp_configs; struct slirp_config_str *config = slirp_configs;
@ -891,11 +890,11 @@ static SlirpState *slirp_lookup(Monitor *mon, const char *vlan,
} }
return vc->opaque; return vc->opaque;
} else { } else {
if (TAILQ_EMPTY(&slirp_stacks)) { if (QTAILQ_EMPTY(&slirp_stacks)) {
monitor_printf(mon, "user mode network stack not in use\n"); monitor_printf(mon, "user mode network stack not in use\n");
return NULL; return NULL;
} }
return TAILQ_FIRST(&slirp_stacks); return QTAILQ_FIRST(&slirp_stacks);
} }
} }
@ -946,7 +945,7 @@ void net_slirp_hostfwd_remove(Monitor *mon, const QDict *qdict)
host_port = atoi(p); 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); host_addr, host_port);
monitor_printf(mon, "host forwarding rule for %s %s\n", src_str, monitor_printf(mon, "host forwarding rule for %s %s\n", src_str,
@ -1045,7 +1044,7 @@ void net_slirp_redir(const char *redir_str)
{ {
struct slirp_config_str *config; struct slirp_config_str *config;
if (TAILQ_EMPTY(&slirp_stacks)) { if (QTAILQ_EMPTY(&slirp_stacks)) {
config = qemu_malloc(sizeof(*config)); config = qemu_malloc(sizeof(*config));
pstrcpy(config->str, sizeof(config->str), redir_str); pstrcpy(config->str, sizeof(config->str), redir_str);
config->flags = SLIRP_CFG_HOSTFWD | SLIRP_CFG_LEGACY; config->flags = SLIRP_CFG_HOSTFWD | SLIRP_CFG_LEGACY;
@ -1054,7 +1053,7 @@ void net_slirp_redir(const char *redir_str)
return; return;
} }
slirp_hostfwd(TAILQ_FIRST(&slirp_stacks), NULL, redir_str, 1); slirp_hostfwd(QTAILQ_FIRST(&slirp_stacks), NULL, redir_str, 1);
} }
#ifndef _WIN32 #ifndef _WIN32
@ -1137,8 +1136,8 @@ void net_slirp_smb(const char *exported_dir)
exit(1); exit(1);
} }
legacy_smb_export = exported_dir; legacy_smb_export = exported_dir;
if (!TAILQ_EMPTY(&slirp_stacks)) { if (!QTAILQ_EMPTY(&slirp_stacks)) {
slirp_smb(TAILQ_FIRST(&slirp_stacks), NULL, exported_dir, slirp_smb(QTAILQ_FIRST(&slirp_stacks), NULL, exported_dir,
vserver_addr); vserver_addr);
} }
} }
@ -1233,7 +1232,7 @@ void do_info_usernet(Monitor *mon)
{ {
SlirpState *s; 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); monitor_printf(mon, "VLAN %d (%s):\n", s->vc->vlan->id, s->vc->name);
slirp_connection_info(s->slirp, mon); slirp_connection_info(s->slirp, mon);
} }
@ -2330,7 +2329,7 @@ VLANState *qemu_find_vlan(int id, int allocate)
} }
vlan = qemu_mallocz(sizeof(VLANState)); vlan = qemu_mallocz(sizeof(VLANState));
vlan->id = id; vlan->id = id;
TAILQ_INIT(&vlan->send_queue); QTAILQ_INIT(&vlan->send_queue);
vlan->next = NULL; vlan->next = NULL;
pvlan = &first_vlan; pvlan = &first_vlan;
while (*pvlan != NULL) while (*pvlan != NULL)
@ -2594,7 +2593,7 @@ int net_client_init(Monitor *mon, const char *device, const char *p)
qemu_free(smb_export); qemu_free(smb_export);
qemu_free(vsmbsrv); qemu_free(vsmbsrv);
} else if (!strcmp(device, "channel")) { } else if (!strcmp(device, "channel")) {
if (TAILQ_EMPTY(&slirp_stacks)) { if (QTAILQ_EMPTY(&slirp_stacks)) {
struct slirp_config_str *config; struct slirp_config_str *config;
config = qemu_malloc(sizeof(*config)); config = qemu_malloc(sizeof(*config));
@ -2603,7 +2602,7 @@ int net_client_init(Monitor *mon, const char *device, const char *p)
config->next = slirp_configs; config->next = slirp_configs;
slirp_configs = config; slirp_configs = config;
} else { } else {
slirp_guestfwd(TAILQ_FIRST(&slirp_stacks), mon, p, 1); slirp_guestfwd(QTAILQ_FIRST(&slirp_stacks), mon, p, 1);
} }
ret = 0; ret = 0;
} else } else

6
net.h
View File

@ -1,7 +1,7 @@
#ifndef QEMU_NET_H #ifndef QEMU_NET_H
#define QEMU_NET_H #define QEMU_NET_H
#include "sys-queue.h" #include "qemu-queue.h"
#include "qemu-common.h" #include "qemu-common.h"
#include "qdict.h" #include "qdict.h"
@ -37,7 +37,7 @@ typedef struct VLANPacket VLANPacket;
typedef void (NetPacketSent) (VLANClientState *, ssize_t); typedef void (NetPacketSent) (VLANClientState *, ssize_t);
struct VLANPacket { struct VLANPacket {
TAILQ_ENTRY(VLANPacket) entry; QTAILQ_ENTRY(VLANPacket) entry;
VLANClientState *sender; VLANClientState *sender;
int size; int size;
NetPacketSent *sent_cb; NetPacketSent *sent_cb;
@ -49,7 +49,7 @@ struct VLANState {
VLANClientState *first_client; VLANClientState *first_client;
struct VLANState *next; struct VLANState *next;
unsigned int nb_guest_devs, nb_host_devs; unsigned int nb_guest_devs, nb_host_devs;
TAILQ_HEAD(send_queue, VLANPacket) send_queue; QTAILQ_HEAD(send_queue, VLANPacket) send_queue;
int delivering; int delivering;
}; };

20
posix-aio-compat.c
View File

@ -22,7 +22,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include "sys-queue.h" #include "qemu-queue.h"
#include "osdep.h" #include "osdep.h"
#include "qemu-common.h" #include "qemu-common.h"
#include "block_int.h" #include "block_int.h"
@ -43,7 +43,7 @@ struct qemu_paiocb {
int ev_signo; int ev_signo;
off_t aio_offset; off_t aio_offset;
TAILQ_ENTRY(qemu_paiocb) node; QTAILQ_ENTRY(qemu_paiocb) node;
int aio_type; int aio_type;
ssize_t ret; ssize_t ret;
int active; int active;
@ -63,7 +63,7 @@ static pthread_attr_t attr;
static int max_threads = 64; static int max_threads = 64;
static int cur_threads = 0; static int cur_threads = 0;
static int idle_threads = 0; static int idle_threads = 0;
static TAILQ_HEAD(, qemu_paiocb) request_list; static QTAILQ_HEAD(, qemu_paiocb) request_list;
#ifdef CONFIG_PREADV #ifdef CONFIG_PREADV
static int preadv_present = 1; static int preadv_present = 1;
@ -321,16 +321,16 @@ static void *aio_thread(void *unused)
mutex_lock(&lock); mutex_lock(&lock);
while (TAILQ_EMPTY(&request_list) && while (QTAILQ_EMPTY(&request_list) &&
!(ret == ETIMEDOUT)) { !(ret == ETIMEDOUT)) {
ret = cond_timedwait(&cond, &lock, &ts); ret = cond_timedwait(&cond, &lock, &ts);
} }
if (TAILQ_EMPTY(&request_list)) if (QTAILQ_EMPTY(&request_list))
break; break;
aiocb = TAILQ_FIRST(&request_list); aiocb = QTAILQ_FIRST(&request_list);
TAILQ_REMOVE(&request_list, aiocb, node); QTAILQ_REMOVE(&request_list, aiocb, node);
aiocb->active = 1; aiocb->active = 1;
idle_threads--; idle_threads--;
mutex_unlock(&lock); mutex_unlock(&lock);
@ -381,7 +381,7 @@ static void qemu_paio_submit(struct qemu_paiocb *aiocb)
mutex_lock(&lock); mutex_lock(&lock);
if (idle_threads == 0 && cur_threads < max_threads) if (idle_threads == 0 && cur_threads < max_threads)
spawn_thread(); spawn_thread();
TAILQ_INSERT_TAIL(&request_list, aiocb, node); QTAILQ_INSERT_TAIL(&request_list, aiocb, node);
mutex_unlock(&lock); mutex_unlock(&lock);
cond_signal(&cond); cond_signal(&cond);
} }
@ -509,7 +509,7 @@ static void paio_cancel(BlockDriverAIOCB *blockacb)
mutex_lock(&lock); mutex_lock(&lock);
if (!acb->active) { if (!acb->active) {
TAILQ_REMOVE(&request_list, acb, node); QTAILQ_REMOVE(&request_list, acb, node);
acb->ret = -ECANCELED; acb->ret = -ECANCELED;
} else if (acb->ret == -EINPROGRESS) { } else if (acb->ret == -EINPROGRESS) {
active = 1; active = 1;
@ -619,7 +619,7 @@ void *paio_init(void)
if (ret) if (ret)
die2(ret, "pthread_attr_setdetachstate"); die2(ret, "pthread_attr_setdetachstate");
TAILQ_INIT(&request_list); QTAILQ_INIT(&request_list);
posix_aio_state = s; posix_aio_state = s;

14
qdict.c
View File

@ -14,7 +14,7 @@
#include "qdict.h" #include "qdict.h"
#include "qstring.h" #include "qstring.h"
#include "qobject.h" #include "qobject.h"
#include "sys-queue.h" #include "qemu-queue.h"
#include "qemu-common.h" #include "qemu-common.h"
static void qdict_destroy_obj(QObject *obj); static void qdict_destroy_obj(QObject *obj);
@ -88,7 +88,7 @@ static QDictEntry *qdict_find(const QDict *qdict,
{ {
QDictEntry *entry; QDictEntry *entry;
LIST_FOREACH(entry, &qdict->table[hash], next) QLIST_FOREACH(entry, &qdict->table[hash], next)
if (!strcmp(entry->key, key)) if (!strcmp(entry->key, key))
return entry; return entry;
@ -120,7 +120,7 @@ void qdict_put_obj(QDict *qdict, const char *key, QObject *value)
} else { } else {
/* allocate a new entry */ /* allocate a new entry */
entry = alloc_entry(key, value); entry = alloc_entry(key, value);
LIST_INSERT_HEAD(&qdict->table[hash], entry, next); QLIST_INSERT_HEAD(&qdict->table[hash], entry, next);
} }
qdict->size++; qdict->size++;
@ -266,7 +266,7 @@ void qdict_del(QDict *qdict, const char *key)
entry = qdict_find(qdict, key, tdb_hash(key) % QDICT_HASH_SIZE); entry = qdict_find(qdict, key, tdb_hash(key) % QDICT_HASH_SIZE);
if (entry) { if (entry) {
LIST_REMOVE(entry, next); QLIST_REMOVE(entry, next);
qentry_destroy(entry); qentry_destroy(entry);
qdict->size--; qdict->size--;
} }
@ -284,10 +284,10 @@ static void qdict_destroy_obj(QObject *obj)
qdict = qobject_to_qdict(obj); qdict = qobject_to_qdict(obj);
for (i = 0; i < QDICT_HASH_SIZE; i++) { for (i = 0; i < QDICT_HASH_SIZE; i++) {
QDictEntry *entry = LIST_FIRST(&qdict->table[i]); QDictEntry *entry = QLIST_FIRST(&qdict->table[i]);
while (entry) { while (entry) {
QDictEntry *tmp = LIST_NEXT(entry, next); QDictEntry *tmp = QLIST_NEXT(entry, next);
LIST_REMOVE(entry, next); QLIST_REMOVE(entry, next);
qentry_destroy(entry); qentry_destroy(entry);
entry = tmp; entry = tmp;
} }

6
qdict.h
View File

@ -2,7 +2,7 @@
#define QDICT_H #define QDICT_H
#include "qobject.h" #include "qobject.h"
#include "sys-queue.h" #include "qemu-queue.h"
#include <stdint.h> #include <stdint.h>
#define QDICT_HASH_SIZE 512 #define QDICT_HASH_SIZE 512
@ -10,13 +10,13 @@
typedef struct QDictEntry { typedef struct QDictEntry {
char *key; char *key;
QObject *value; QObject *value;
LIST_ENTRY(QDictEntry) next; QLIST_ENTRY(QDictEntry) next;
} QDictEntry; } QDictEntry;
typedef struct QDict { typedef struct QDict {
QObject_HEAD; QObject_HEAD;
size_t size; size_t size;
LIST_HEAD(,QDictEntry) table[QDICT_HASH_SIZE]; QLIST_HEAD(,QDictEntry) table[QDICT_HASH_SIZE];
} QDict; } QDict;
/* Object API */ /* Object API */

18
qemu-char.c
View File

@ -106,8 +106,8 @@
/***********************************************************/ /***********************************************************/
/* character device */ /* character device */
static TAILQ_HEAD(CharDriverStateHead, CharDriverState) chardevs = static QTAILQ_HEAD(CharDriverStateHead, CharDriverState) chardevs =
TAILQ_HEAD_INITIALIZER(chardevs); QTAILQ_HEAD_INITIALIZER(chardevs);
static int initial_reset_issued; static int initial_reset_issued;
static void qemu_chr_event(CharDriverState *s, int event) static void qemu_chr_event(CharDriverState *s, int event)
@ -139,7 +139,7 @@ void qemu_chr_initial_reset(void)
initial_reset_issued = 1; initial_reset_issued = 1;
TAILQ_FOREACH(chr, &chardevs, next) { QTAILQ_FOREACH(chr, &chardevs, next) {
qemu_chr_reset(chr); qemu_chr_reset(chr);
} }
} }
@ -352,7 +352,7 @@ static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
case 's': case 's':
{ {
DriveInfo *dinfo; DriveInfo *dinfo;
TAILQ_FOREACH(dinfo, &drives, next) { QTAILQ_FOREACH(dinfo, &drives, next) {
bdrv_commit(dinfo->bdrv); bdrv_commit(dinfo->bdrv);
} }
} }
@ -2400,7 +2400,7 @@ CharDriverState *qemu_chr_open_opts(QemuOpts *opts,
if (!chr->filename) if (!chr->filename)
chr->filename = qemu_strdup(qemu_opt_get(opts, "backend")); chr->filename = qemu_strdup(qemu_opt_get(opts, "backend"));
chr->init = init; chr->init = init;
TAILQ_INSERT_TAIL(&chardevs, chr, next); QTAILQ_INSERT_TAIL(&chardevs, chr, next);
if (qemu_opt_get_bool(opts, "mux", 0)) { if (qemu_opt_get_bool(opts, "mux", 0)) {
CharDriverState *base = chr; CharDriverState *base = chr;
@ -2409,7 +2409,7 @@ CharDriverState *qemu_chr_open_opts(QemuOpts *opts,
snprintf(base->label, len, "%s-base", qemu_opts_id(opts)); snprintf(base->label, len, "%s-base", qemu_opts_id(opts));
chr = qemu_chr_open_mux(base); chr = qemu_chr_open_mux(base);
chr->filename = base->filename; chr->filename = base->filename;
TAILQ_INSERT_TAIL(&chardevs, chr, next); QTAILQ_INSERT_TAIL(&chardevs, chr, next);
} }
chr->label = qemu_strdup(qemu_opts_id(opts)); chr->label = qemu_strdup(qemu_opts_id(opts));
return chr; return chr;
@ -2438,7 +2438,7 @@ CharDriverState *qemu_chr_open(const char *label, const char *filename, void (*i
void qemu_chr_close(CharDriverState *chr) void qemu_chr_close(CharDriverState *chr)
{ {
TAILQ_REMOVE(&chardevs, chr, next); QTAILQ_REMOVE(&chardevs, chr, next);
if (chr->chr_close) if (chr->chr_close)
chr->chr_close(chr); chr->chr_close(chr);
qemu_free(chr->filename); qemu_free(chr->filename);
@ -2450,7 +2450,7 @@ void qemu_chr_info(Monitor *mon)
{ {
CharDriverState *chr; CharDriverState *chr;
TAILQ_FOREACH(chr, &chardevs, next) { QTAILQ_FOREACH(chr, &chardevs, next) {
monitor_printf(mon, "%s: filename=%s\n", chr->label, chr->filename); monitor_printf(mon, "%s: filename=%s\n", chr->label, chr->filename);
} }
} }
@ -2459,7 +2459,7 @@ CharDriverState *qemu_chr_find(const char *name)
{ {
CharDriverState *chr; CharDriverState *chr;
TAILQ_FOREACH(chr, &chardevs, next) { QTAILQ_FOREACH(chr, &chardevs, next) {
if (strcmp(chr->label, name) != 0) if (strcmp(chr->label, name) != 0)
continue; continue;
return chr; return chr;

4
qemu-char.h
View File

@ -2,7 +2,7 @@
#define QEMU_CHAR_H #define QEMU_CHAR_H
#include "qemu-common.h" #include "qemu-common.h"
#include "sys-queue.h" #include "qemu-queue.h"
#include "qemu-option.h" #include "qemu-option.h"
#include "qemu-config.h" #include "qemu-config.h"
@ -66,7 +66,7 @@ struct CharDriverState {
QEMUBH *bh; QEMUBH *bh;
char *label; char *label;
char *filename; char *filename;
TAILQ_ENTRY(CharDriverState) next; QTAILQ_ENTRY(CharDriverState) next;
}; };
CharDriverState *qemu_chr_open_opts(QemuOpts *opts, CharDriverState *qemu_chr_open_opts(QemuOpts *opts,

6
qemu-config.c
View File

@ -4,7 +4,7 @@
QemuOptsList qemu_drive_opts = { QemuOptsList qemu_drive_opts = {
.name = "drive", .name = "drive",
.head = TAILQ_HEAD_INITIALIZER(qemu_drive_opts.head), .head = QTAILQ_HEAD_INITIALIZER(qemu_drive_opts.head),
.desc = { .desc = {
{ {
.name = "bus", .name = "bus",
@ -77,7 +77,7 @@ QemuOptsList qemu_drive_opts = {
QemuOptsList qemu_chardev_opts = { QemuOptsList qemu_chardev_opts = {
.name = "chardev", .name = "chardev",
.head = TAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head), .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head),
.desc = { .desc = {
{ {
.name = "backend", .name = "backend",
@ -140,7 +140,7 @@ QemuOptsList qemu_chardev_opts = {
QemuOptsList qemu_device_opts = { QemuOptsList qemu_device_opts = {
.name = "device", .name = "device",
.head = TAILQ_HEAD_INITIALIZER(qemu_device_opts.head), .head = QTAILQ_HEAD_INITIALIZER(qemu_device_opts.head),
.desc = { .desc = {
/* /*
* no elements => accept any * no elements => accept any

28
qemu-option.c
View File

@ -477,21 +477,21 @@ struct QemuOpt {
} value; } value;
QemuOpts *opts; QemuOpts *opts;
TAILQ_ENTRY(QemuOpt) next; QTAILQ_ENTRY(QemuOpt) next;
}; };
struct QemuOpts { struct QemuOpts {
const char *id; const char *id;
QemuOptsList *list; QemuOptsList *list;
TAILQ_HEAD(, QemuOpt) head; QTAILQ_HEAD(, QemuOpt) head;
TAILQ_ENTRY(QemuOpts) next; QTAILQ_ENTRY(QemuOpts) next;
}; };
static QemuOpt *qemu_opt_find(QemuOpts *opts, const char *name) static QemuOpt *qemu_opt_find(QemuOpts *opts, const char *name)
{ {
QemuOpt *opt; QemuOpt *opt;
TAILQ_FOREACH(opt, &opts->head, next) { QTAILQ_FOREACH(opt, &opts->head, next) {
if (strcmp(opt->name, name) != 0) if (strcmp(opt->name, name) != 0)
continue; continue;
return opt; return opt;
@ -556,7 +556,7 @@ static int qemu_opt_parse(QemuOpt *opt)
static void qemu_opt_del(QemuOpt *opt) static void qemu_opt_del(QemuOpt *opt)
{ {
TAILQ_REMOVE(&opt->opts->head, opt, next); QTAILQ_REMOVE(&opt->opts->head, opt, next);
qemu_free((/* !const */ char*)opt->name); qemu_free((/* !const */ char*)opt->name);
qemu_free((/* !const */ char*)opt->str); qemu_free((/* !const */ char*)opt->str);
qemu_free(opt); qemu_free(opt);
@ -588,7 +588,7 @@ int qemu_opt_set(QemuOpts *opts, const char *name, const char *value)
opt = qemu_mallocz(sizeof(*opt)); opt = qemu_mallocz(sizeof(*opt));
opt->name = qemu_strdup(name); opt->name = qemu_strdup(name);
opt->opts = opts; opt->opts = opts;
TAILQ_INSERT_TAIL(&opts->head, opt, next); QTAILQ_INSERT_TAIL(&opts->head, opt, next);
if (desc[i].name != NULL) { if (desc[i].name != NULL) {
opt->desc = desc+i; opt->desc = desc+i;
} }
@ -613,7 +613,7 @@ int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque,
QemuOpt *opt; QemuOpt *opt;
int rc = 0; int rc = 0;
TAILQ_FOREACH(opt, &opts->head, next) { QTAILQ_FOREACH(opt, &opts->head, next) {
rc = func(opt->name, opt->str, opaque); rc = func(opt->name, opt->str, opaque);
if (abort_on_failure && rc != 0) if (abort_on_failure && rc != 0)
break; break;
@ -625,7 +625,7 @@ QemuOpts *qemu_opts_find(QemuOptsList *list, const char *id)
{ {
QemuOpts *opts; QemuOpts *opts;
TAILQ_FOREACH(opts, &list->head, next) { QTAILQ_FOREACH(opts, &list->head, next) {
if (!opts->id) { if (!opts->id) {
continue; continue;
} }
@ -658,8 +658,8 @@ QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id, int fail_if_exist
opts->id = qemu_strdup(id); opts->id = qemu_strdup(id);
} }
opts->list = list; opts->list = list;
TAILQ_INIT(&opts->head); QTAILQ_INIT(&opts->head);
TAILQ_INSERT_TAIL(&list->head, opts, next); QTAILQ_INSERT_TAIL(&list->head, opts, next);
return opts; return opts;
} }
@ -687,12 +687,12 @@ void qemu_opts_del(QemuOpts *opts)
QemuOpt *opt; QemuOpt *opt;
for (;;) { for (;;) {
opt = TAILQ_FIRST(&opts->head); opt = QTAILQ_FIRST(&opts->head);
if (opt == NULL) if (opt == NULL)
break; break;
qemu_opt_del(opt); qemu_opt_del(opt);
} }
TAILQ_REMOVE(&opts->list->head, opts, next); QTAILQ_REMOVE(&opts->list->head, opts, next);
qemu_free(opts); qemu_free(opts);
} }
@ -702,7 +702,7 @@ int qemu_opts_print(QemuOpts *opts, void *dummy)
fprintf(stderr, "%s: %s:", opts->list->name, fprintf(stderr, "%s: %s:", opts->list->name,
opts->id ? opts->id : "<noid>"); 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, " %s=\"%s\"", opt->name, opt->str);
} }
fprintf(stderr, "\n"); fprintf(stderr, "\n");
@ -788,7 +788,7 @@ int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func, void *opaque,
QemuOpts *opts; QemuOpts *opts;
int rc = 0; int rc = 0;
TAILQ_FOREACH(opts, &list->head, next) { QTAILQ_FOREACH(opts, &list->head, next) {
rc = func(opts, opaque); rc = func(opts, opaque);
if (abort_on_failure && rc != 0) if (abort_on_failure && rc != 0)
break; break;

4
qemu-option.h
View File

@ -26,7 +26,7 @@
#ifndef QEMU_OPTIONS_H #ifndef QEMU_OPTIONS_H
#define QEMU_OPTIONS_H #define QEMU_OPTIONS_H
#include "sys-queue.h" #include "qemu-queue.h"
enum QEMUOptionParType { enum QEMUOptionParType {
OPT_FLAG, OPT_FLAG,
@ -95,7 +95,7 @@ typedef struct QemuOptDesc {
struct QemuOptsList { struct QemuOptsList {
const char *name; const char *name;
TAILQ_HEAD(, QemuOpts) head; QTAILQ_HEAD(, QemuOpts) head;
QemuOptDesc desc[]; QemuOptDesc desc[];
}; };

106
sys-queue.h → qemu-queue.h
View File

@ -36,8 +36,8 @@
* @(#)queue.h 8.5 (Berkeley) 8/20/94 * @(#)queue.h 8.5 (Berkeley) 8/20/94
*/ */
#ifndef _SYS_QUEUE_H_ #ifndef QEMU_SYS_QUEUE_H_
#define _SYS_QUEUE_H_ #define QEMU_SYS_QUEUE_H_
/* /*
* This file defines three types of data structures: * This file defines three types of data structures:
@ -71,15 +71,15 @@
/* /*
* List definitions. * List definitions.
*/ */
#define LIST_HEAD(name, type) \ #define QLIST_HEAD(name, type) \
struct name { \ struct name { \
struct type *lh_first; /* first element */ \ struct type *lh_first; /* first element */ \
} }
#define LIST_HEAD_INITIALIZER(head) \ #define QLIST_HEAD_INITIALIZER(head) \
{ NULL } { NULL }
#define LIST_ENTRY(type) \ #define QLIST_ENTRY(type) \
struct { \ struct { \
struct type *le_next; /* next element */ \ struct type *le_next; /* next element */ \
struct type **le_prev; /* address of previous next element */ \ struct type **le_prev; /* address of previous next element */ \
@ -88,11 +88,11 @@ struct { \
/* /*
* List functions. * List functions.
*/ */
#define LIST_INIT(head) do { \ #define QLIST_INIT(head) do { \
(head)->lh_first = NULL; \ (head)->lh_first = NULL; \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define LIST_INSERT_AFTER(listelm, elm, field) do { \ #define QLIST_INSERT_AFTER(listelm, elm, field) do { \
if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \ if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \
(listelm)->field.le_next->field.le_prev = \ (listelm)->field.le_next->field.le_prev = \
&(elm)->field.le_next; \ &(elm)->field.le_next; \
@ -100,33 +100,33 @@ struct { \
(elm)->field.le_prev = &(listelm)->field.le_next; \ (elm)->field.le_prev = &(listelm)->field.le_next; \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define LIST_INSERT_BEFORE(listelm, elm, field) do { \ #define QLIST_INSERT_BEFORE(listelm, elm, field) do { \
(elm)->field.le_prev = (listelm)->field.le_prev; \ (elm)->field.le_prev = (listelm)->field.le_prev; \
(elm)->field.le_next = (listelm); \ (elm)->field.le_next = (listelm); \
*(listelm)->field.le_prev = (elm); \ *(listelm)->field.le_prev = (elm); \
(listelm)->field.le_prev = &(elm)->field.le_next; \ (listelm)->field.le_prev = &(elm)->field.le_next; \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define LIST_INSERT_HEAD(head, elm, field) do { \ #define QLIST_INSERT_HEAD(head, elm, field) do { \
if (((elm)->field.le_next = (head)->lh_first) != NULL) \ if (((elm)->field.le_next = (head)->lh_first) != NULL) \
(head)->lh_first->field.le_prev = &(elm)->field.le_next;\ (head)->lh_first->field.le_prev = &(elm)->field.le_next;\
(head)->lh_first = (elm); \ (head)->lh_first = (elm); \
(elm)->field.le_prev = &(head)->lh_first; \ (elm)->field.le_prev = &(head)->lh_first; \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define LIST_REMOVE(elm, field) do { \ #define QLIST_REMOVE(elm, field) do { \
if ((elm)->field.le_next != NULL) \ if ((elm)->field.le_next != NULL) \
(elm)->field.le_next->field.le_prev = \ (elm)->field.le_next->field.le_prev = \
(elm)->field.le_prev; \ (elm)->field.le_prev; \
*(elm)->field.le_prev = (elm)->field.le_next; \ *(elm)->field.le_prev = (elm)->field.le_next; \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define LIST_FOREACH(var, head, field) \ #define QLIST_FOREACH(var, head, field) \
for ((var) = ((head)->lh_first); \ for ((var) = ((head)->lh_first); \
(var); \ (var); \
(var) = ((var)->field.le_next)) (var) = ((var)->field.le_next))
#define LIST_FOREACH_SAFE(var, head, field, next_var) \ #define QLIST_FOREACH_SAFE(var, head, field, next_var) \
for ((var) = ((head)->lh_first); \ for ((var) = ((head)->lh_first); \
(var) && ((next_var) = ((var)->field.le_next), 1); \ (var) && ((next_var) = ((var)->field.le_next), 1); \
(var) = (next_var)) (var) = (next_var))
@ -134,40 +134,40 @@ struct { \
/* /*
* List access methods. * List access methods.
*/ */
#define LIST_EMPTY(head) ((head)->lh_first == NULL) #define QLIST_EMPTY(head) ((head)->lh_first == NULL)
#define LIST_FIRST(head) ((head)->lh_first) #define QLIST_FIRST(head) ((head)->lh_first)
#define LIST_NEXT(elm, field) ((elm)->field.le_next) #define QLIST_NEXT(elm, field) ((elm)->field.le_next)
/* /*
* Tail queue definitions. * Tail queue definitions.
*/ */
#define _TAILQ_HEAD(name, type, qual) \ #define Q_TAILQ_HEAD(name, type, qual) \
struct name { \ struct name { \
qual type *tqh_first; /* first element */ \ qual type *tqh_first; /* first element */ \
qual type *qual *tqh_last; /* addr of last next element */ \ qual type *qual *tqh_last; /* addr of last next element */ \
} }
#define TAILQ_HEAD(name, type) _TAILQ_HEAD(name, struct type,) #define QTAILQ_HEAD(name, type) Q_TAILQ_HEAD(name, struct type,)
#define TAILQ_HEAD_INITIALIZER(head) \ #define QTAILQ_HEAD_INITIALIZER(head) \
{ NULL, &(head).tqh_first } { NULL, &(head).tqh_first }
#define _TAILQ_ENTRY(type, qual) \ #define Q_TAILQ_ENTRY(type, qual) \
struct { \ struct { \
qual type *tqe_next; /* next element */ \ qual type *tqe_next; /* next element */ \
qual type *qual *tqe_prev; /* address of previous next element */\ qual type *qual *tqe_prev; /* address of previous next element */\
} }
#define TAILQ_ENTRY(type) _TAILQ_ENTRY(struct type,) #define QTAILQ_ENTRY(type) Q_TAILQ_ENTRY(struct type,)
/* /*
* Tail queue functions. * Tail queue functions.
*/ */
#define TAILQ_INIT(head) do { \ #define QTAILQ_INIT(head) do { \
(head)->tqh_first = NULL; \ (head)->tqh_first = NULL; \
(head)->tqh_last = &(head)->tqh_first; \ (head)->tqh_last = &(head)->tqh_first; \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define TAILQ_INSERT_HEAD(head, elm, field) do { \ #define QTAILQ_INSERT_HEAD(head, elm, field) do { \
if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \ if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \
(head)->tqh_first->field.tqe_prev = \ (head)->tqh_first->field.tqe_prev = \
&(elm)->field.tqe_next; \ &(elm)->field.tqe_next; \
@ -177,14 +177,14 @@ struct { \
(elm)->field.tqe_prev = &(head)->tqh_first; \ (elm)->field.tqe_prev = &(head)->tqh_first; \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define TAILQ_INSERT_TAIL(head, elm, field) do { \ #define QTAILQ_INSERT_TAIL(head, elm, field) do { \
(elm)->field.tqe_next = NULL; \ (elm)->field.tqe_next = NULL; \
(elm)->field.tqe_prev = (head)->tqh_last; \ (elm)->field.tqe_prev = (head)->tqh_last; \
*(head)->tqh_last = (elm); \ *(head)->tqh_last = (elm); \
(head)->tqh_last = &(elm)->field.tqe_next; \ (head)->tqh_last = &(elm)->field.tqe_next; \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ #define QTAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\ if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
(elm)->field.tqe_next->field.tqe_prev = \ (elm)->field.tqe_next->field.tqe_prev = \
&(elm)->field.tqe_next; \ &(elm)->field.tqe_next; \
@ -194,14 +194,14 @@ struct { \
(elm)->field.tqe_prev = &(listelm)->field.tqe_next; \ (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ #define QTAILQ_INSERT_BEFORE(listelm, elm, field) do { \
(elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
(elm)->field.tqe_next = (listelm); \ (elm)->field.tqe_next = (listelm); \
*(listelm)->field.tqe_prev = (elm); \ *(listelm)->field.tqe_prev = (elm); \
(listelm)->field.tqe_prev = &(elm)->field.tqe_next; \ (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define TAILQ_REMOVE(head, elm, field) do { \ #define QTAILQ_REMOVE(head, elm, field) do { \
if (((elm)->field.tqe_next) != NULL) \ if (((elm)->field.tqe_next) != NULL) \
(elm)->field.tqe_next->field.tqe_prev = \ (elm)->field.tqe_next->field.tqe_prev = \
(elm)->field.tqe_prev; \ (elm)->field.tqe_prev; \
@ -210,17 +210,17 @@ struct { \
*(elm)->field.tqe_prev = (elm)->field.tqe_next; \ *(elm)->field.tqe_prev = (elm)->field.tqe_next; \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define TAILQ_FOREACH(var, head, field) \ #define QTAILQ_FOREACH(var, head, field) \
for ((var) = ((head)->tqh_first); \ for ((var) = ((head)->tqh_first); \
(var); \ (var); \
(var) = ((var)->field.tqe_next)) (var) = ((var)->field.tqe_next))
#define TAILQ_FOREACH_SAFE(var, head, field, next_var) \ #define QTAILQ_FOREACH_SAFE(var, head, field, next_var) \
for ((var) = ((head)->tqh_first); \ for ((var) = ((head)->tqh_first); \
(var) && ((next_var) = ((var)->field.tqe_next), 1); \ (var) && ((next_var) = ((var)->field.tqe_next), 1); \
(var) = (next_var)) (var) = (next_var))
#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ #define QTAILQ_FOREACH_REVERSE(var, head, headname, field) \
for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last)); \ for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last)); \
(var); \ (var); \
(var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last))) (var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last)))
@ -228,29 +228,29 @@ struct { \
/* /*
* Tail queue access methods. * Tail queue access methods.
*/ */
#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL) #define QTAILQ_EMPTY(head) ((head)->tqh_first == NULL)
#define TAILQ_FIRST(head) ((head)->tqh_first) #define QTAILQ_FIRST(head) ((head)->tqh_first)
#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) #define QTAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
#define TAILQ_LAST(head, headname) \ #define QTAILQ_LAST(head, headname) \
(*(((struct headname *)((head)->tqh_last))->tqh_last)) (*(((struct headname *)((head)->tqh_last))->tqh_last))
#define TAILQ_PREV(elm, headname, field) \ #define QTAILQ_PREV(elm, headname, field) \
(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
/* /*
* Circular queue definitions. * Circular queue definitions.
*/ */
#define CIRCLEQ_HEAD(name, type) \ #define QCIRCLEQ_HEAD(name, type) \
struct name { \ struct name { \
struct type *cqh_first; /* first element */ \ struct type *cqh_first; /* first element */ \
struct type *cqh_last; /* last element */ \ struct type *cqh_last; /* last element */ \
} }
#define CIRCLEQ_HEAD_INITIALIZER(head) \ #define QCIRCLEQ_HEAD_INITIALIZER(head) \
{ (void *)&head, (void *)&head } { (void *)&head, (void *)&head }
#define CIRCLEQ_ENTRY(type) \ #define QCIRCLEQ_ENTRY(type) \
struct { \ struct { \
struct type *cqe_next; /* next element */ \ struct type *cqe_next; /* next element */ \
struct type *cqe_prev; /* previous element */ \ struct type *cqe_prev; /* previous element */ \
@ -259,12 +259,12 @@ struct { \
/* /*
* Circular queue functions. * Circular queue functions.
*/ */
#define CIRCLEQ_INIT(head) do { \ #define QCIRCLEQ_INIT(head) do { \
(head)->cqh_first = (void *)(head); \ (head)->cqh_first = (void *)(head); \
(head)->cqh_last = (void *)(head); \ (head)->cqh_last = (void *)(head); \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ #define QCIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
(elm)->field.cqe_next = (listelm)->field.cqe_next; \ (elm)->field.cqe_next = (listelm)->field.cqe_next; \
(elm)->field.cqe_prev = (listelm); \ (elm)->field.cqe_prev = (listelm); \
if ((listelm)->field.cqe_next == (void *)(head)) \ if ((listelm)->field.cqe_next == (void *)(head)) \
@ -274,7 +274,7 @@ struct { \
(listelm)->field.cqe_next = (elm); \ (listelm)->field.cqe_next = (elm); \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \ #define QCIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \
(elm)->field.cqe_next = (listelm); \ (elm)->field.cqe_next = (listelm); \
(elm)->field.cqe_prev = (listelm)->field.cqe_prev; \ (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \
if ((listelm)->field.cqe_prev == (void *)(head)) \ if ((listelm)->field.cqe_prev == (void *)(head)) \
@ -284,7 +284,7 @@ struct { \
(listelm)->field.cqe_prev = (elm); \ (listelm)->field.cqe_prev = (elm); \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \ #define QCIRCLEQ_INSERT_HEAD(head, elm, field) do { \
(elm)->field.cqe_next = (head)->cqh_first; \ (elm)->field.cqe_next = (head)->cqh_first; \
(elm)->field.cqe_prev = (void *)(head); \ (elm)->field.cqe_prev = (void *)(head); \
if ((head)->cqh_last == (void *)(head)) \ if ((head)->cqh_last == (void *)(head)) \
@ -294,7 +294,7 @@ struct { \
(head)->cqh_first = (elm); \ (head)->cqh_first = (elm); \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \ #define QCIRCLEQ_INSERT_TAIL(head, elm, field) do { \
(elm)->field.cqe_next = (void *)(head); \ (elm)->field.cqe_next = (void *)(head); \
(elm)->field.cqe_prev = (head)->cqh_last; \ (elm)->field.cqe_prev = (head)->cqh_last; \
if ((head)->cqh_first == (void *)(head)) \ if ((head)->cqh_first == (void *)(head)) \
@ -304,7 +304,7 @@ struct { \
(head)->cqh_last = (elm); \ (head)->cqh_last = (elm); \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define CIRCLEQ_REMOVE(head, elm, field) do { \ #define QCIRCLEQ_REMOVE(head, elm, field) do { \
if ((elm)->field.cqe_next == (void *)(head)) \ if ((elm)->field.cqe_next == (void *)(head)) \
(head)->cqh_last = (elm)->field.cqe_prev; \ (head)->cqh_last = (elm)->field.cqe_prev; \
else \ else \
@ -317,12 +317,12 @@ struct { \
(elm)->field.cqe_next; \ (elm)->field.cqe_next; \
} while (/*CONSTCOND*/0) } while (/*CONSTCOND*/0)
#define CIRCLEQ_FOREACH(var, head, field) \ #define QCIRCLEQ_FOREACH(var, head, field) \
for ((var) = ((head)->cqh_first); \ for ((var) = ((head)->cqh_first); \
(var) != (const void *)(head); \ (var) != (const void *)(head); \
(var) = ((var)->field.cqe_next)) (var) = ((var)->field.cqe_next))
#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \ #define QCIRCLEQ_FOREACH_REVERSE(var, head, field) \
for ((var) = ((head)->cqh_last); \ for ((var) = ((head)->cqh_last); \
(var) != (const void *)(head); \ (var) != (const void *)(head); \
(var) = ((var)->field.cqe_prev)) (var) = ((var)->field.cqe_prev))
@ -330,19 +330,19 @@ struct { \
/* /*
* Circular queue access methods. * Circular queue access methods.
*/ */
#define CIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head)) #define QCIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head))
#define CIRCLEQ_FIRST(head) ((head)->cqh_first) #define QCIRCLEQ_FIRST(head) ((head)->cqh_first)
#define CIRCLEQ_LAST(head) ((head)->cqh_last) #define QCIRCLEQ_LAST(head) ((head)->cqh_last)
#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next) #define QCIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next)
#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev) #define QCIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev)
#define CIRCLEQ_LOOP_NEXT(head, elm, field) \ #define QCIRCLEQ_LOOP_NEXT(head, elm, field) \
(((elm)->field.cqe_next == (void *)(head)) \ (((elm)->field.cqe_next == (void *)(head)) \
? ((head)->cqh_first) \ ? ((head)->cqh_first) \
: (elm->field.cqe_next)) : (elm->field.cqe_next))
#define CIRCLEQ_LOOP_PREV(head, elm, field) \ #define QCIRCLEQ_LOOP_PREV(head, elm, field) \
(((elm)->field.cqe_prev == (void *)(head)) \ (((elm)->field.cqe_prev == (void *)(head)) \
? ((head)->cqh_last) \ ? ((head)->cqh_last) \
: (elm->field.cqe_prev)) : (elm->field.cqe_prev))
#endif /* !_SYS_QUEUE_H_ */ #endif /* !QEMU_SYS_QUEUE_H_ */

2
qemu-sockets.c
View File

@ -32,7 +32,7 @@ static const int on=1, off=0;
/* used temporarely until all users are converted to QemuOpts */ /* used temporarely until all users are converted to QemuOpts */
QemuOptsList dummy_opts = { QemuOptsList dummy_opts = {
.name = "dummy", .name = "dummy",
.head = TAILQ_HEAD_INITIALIZER(dummy_opts.head), .head = QTAILQ_HEAD_INITIALIZER(dummy_opts.head),
.desc = { .desc = {
{ {
.name = "path", .name = "path",

57
savevm.c
View File

@ -31,8 +31,6 @@
/* Needed early for CONFIG_BSD etc. */ /* Needed early for CONFIG_BSD etc. */
#include "config-host.h" #include "config-host.h"
/* Needed early to override system queue definitions on BSD */
#include "sys-queue.h"
#ifndef _WIN32 #ifndef _WIN32
#include <sys/times.h> #include <sys/times.h>
@ -92,6 +90,7 @@
#include "audio/audio.h" #include "audio/audio.h"
#include "migration.h" #include "migration.h"
#include "qemu_socket.h" #include "qemu_socket.h"
#include "qemu-queue.h"
/* point to the block driver where the snapshots are managed */ /* point to the block driver where the snapshots are managed */
static BlockDriverState *bs_snapshots; static BlockDriverState *bs_snapshots;
@ -912,7 +911,7 @@ const VMStateInfo vmstate_info_buffer = {
}; };
typedef struct SaveStateEntry { typedef struct SaveStateEntry {
TAILQ_ENTRY(SaveStateEntry) entry; QTAILQ_ENTRY(SaveStateEntry) entry;
char idstr[256]; char idstr[256];
int instance_id; int instance_id;
int version_id; int version_id;
@ -924,8 +923,8 @@ typedef struct SaveStateEntry {
void *opaque; void *opaque;
} SaveStateEntry; } SaveStateEntry;
static TAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers = static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers =
TAILQ_HEAD_INITIALIZER(savevm_handlers); QTAILQ_HEAD_INITIALIZER(savevm_handlers);
static int global_section_id; static int global_section_id;
static int calculate_new_instance_id(const char *idstr) static int calculate_new_instance_id(const char *idstr)
@ -933,7 +932,7 @@ static int calculate_new_instance_id(const char *idstr)
SaveStateEntry *se; SaveStateEntry *se;
int instance_id = 0; int instance_id = 0;
TAILQ_FOREACH(se, &savevm_handlers, entry) { QTAILQ_FOREACH(se, &savevm_handlers, entry) {
if (strcmp(idstr, se->idstr) == 0 if (strcmp(idstr, se->idstr) == 0
&& instance_id <= se->instance_id) { && instance_id <= se->instance_id) {
instance_id = se->instance_id + 1; instance_id = se->instance_id + 1;
@ -972,7 +971,7 @@ int register_savevm_live(const char *idstr,
se->instance_id = instance_id; se->instance_id = instance_id;
} }
/* add at the end of list */ /* add at the end of list */
TAILQ_INSERT_TAIL(&savevm_handlers, se, entry); QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
return 0; return 0;
} }
@ -991,9 +990,9 @@ void unregister_savevm(const char *idstr, void *opaque)
{ {
SaveStateEntry *se, *new_se; 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) { if (strcmp(se->idstr, idstr) == 0 && se->opaque == opaque) {
TAILQ_REMOVE(&savevm_handlers, se, entry); QTAILQ_REMOVE(&savevm_handlers, se, entry);
qemu_free(se); qemu_free(se);
} }
} }
@ -1020,7 +1019,7 @@ int vmstate_register(int instance_id, const VMStateDescription *vmsd,
se->instance_id = instance_id; se->instance_id = instance_id;
} }
/* add at the end of list */ /* add at the end of list */
TAILQ_INSERT_TAIL(&savevm_handlers, se, entry); QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry);
return 0; return 0;
} }
@ -1028,9 +1027,9 @@ void vmstate_unregister(const VMStateDescription *vmsd, void *opaque)
{ {
SaveStateEntry *se, *new_se; 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) { if (se->vmsd == vmsd && se->opaque == opaque) {
TAILQ_REMOVE(&savevm_handlers, se, entry); QTAILQ_REMOVE(&savevm_handlers, se, entry);
qemu_free(se); qemu_free(se);
} }
} }
@ -1160,7 +1159,7 @@ int qemu_savevm_state_begin(QEMUFile *f)
qemu_put_be32(f, QEMU_VM_FILE_MAGIC); qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
qemu_put_be32(f, QEMU_VM_FILE_VERSION); qemu_put_be32(f, QEMU_VM_FILE_VERSION);
TAILQ_FOREACH(se, &savevm_handlers, entry) { QTAILQ_FOREACH(se, &savevm_handlers, entry) {
int len; int len;
if (se->save_live_state == NULL) if (se->save_live_state == NULL)
@ -1192,7 +1191,7 @@ int qemu_savevm_state_iterate(QEMUFile *f)
SaveStateEntry *se; SaveStateEntry *se;
int ret = 1; int ret = 1;
TAILQ_FOREACH(se, &savevm_handlers, entry) { QTAILQ_FOREACH(se, &savevm_handlers, entry) {
if (se->save_live_state == NULL) if (se->save_live_state == NULL)
continue; continue;
@ -1216,7 +1215,7 @@ int qemu_savevm_state_complete(QEMUFile *f)
{ {
SaveStateEntry *se; SaveStateEntry *se;
TAILQ_FOREACH(se, &savevm_handlers, entry) { QTAILQ_FOREACH(se, &savevm_handlers, entry) {
if (se->save_live_state == NULL) if (se->save_live_state == NULL)
continue; continue;
@ -1227,7 +1226,7 @@ int qemu_savevm_state_complete(QEMUFile *f)
se->save_live_state(f, QEMU_VM_SECTION_END, se->opaque); 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; int len;
if (se->save_state == NULL && se->vmsd == NULL) if (se->save_state == NULL && se->vmsd == NULL)
@ -1292,7 +1291,7 @@ static SaveStateEntry *find_se(const char *idstr, int instance_id)
{ {
SaveStateEntry *se; SaveStateEntry *se;
TAILQ_FOREACH(se, &savevm_handlers, entry) { QTAILQ_FOREACH(se, &savevm_handlers, entry) {
if (!strcmp(se->idstr, idstr) && if (!strcmp(se->idstr, idstr) &&
instance_id == se->instance_id) instance_id == se->instance_id)
return se; return se;
@ -1301,7 +1300,7 @@ static SaveStateEntry *find_se(const char *idstr, int instance_id)
} }
typedef struct LoadStateEntry { typedef struct LoadStateEntry {
LIST_ENTRY(LoadStateEntry) entry; QLIST_ENTRY(LoadStateEntry) entry;
SaveStateEntry *se; SaveStateEntry *se;
int section_id; int section_id;
int version_id; int version_id;
@ -1309,8 +1308,8 @@ typedef struct LoadStateEntry {
int qemu_loadvm_state(QEMUFile *f) int qemu_loadvm_state(QEMUFile *f)
{ {
LIST_HEAD(, LoadStateEntry) loadvm_handlers = QLIST_HEAD(, LoadStateEntry) loadvm_handlers =
LIST_HEAD_INITIALIZER(loadvm_handlers); QLIST_HEAD_INITIALIZER(loadvm_handlers);
LoadStateEntry *le, *new_le; LoadStateEntry *le, *new_le;
uint8_t section_type; uint8_t section_type;
unsigned int v; unsigned int v;
@ -1367,7 +1366,7 @@ int qemu_loadvm_state(QEMUFile *f)
le->se = se; le->se = se;
le->section_id = section_id; le->section_id = section_id;
le->version_id = version_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); ret = vmstate_load(f, le->se, le->version_id);
if (ret < 0) { if (ret < 0) {
@ -1380,7 +1379,7 @@ int qemu_loadvm_state(QEMUFile *f)
case QEMU_VM_SECTION_END: case QEMU_VM_SECTION_END:
section_id = qemu_get_be32(f); section_id = qemu_get_be32(f);
LIST_FOREACH(le, &loadvm_handlers, entry) { QLIST_FOREACH(le, &loadvm_handlers, entry) {
if (le->section_id == section_id) { if (le->section_id == section_id) {
break; break;
} }
@ -1408,8 +1407,8 @@ int qemu_loadvm_state(QEMUFile *f)
ret = 0; ret = 0;
out: out:
LIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) { QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
LIST_REMOVE(le, entry); QLIST_REMOVE(le, entry);
qemu_free(le); qemu_free(le);
} }
@ -1442,7 +1441,7 @@ static BlockDriverState *get_bs_snapshots(void)
if (bs_snapshots) if (bs_snapshots)
return bs_snapshots; return bs_snapshots;
TAILQ_FOREACH(dinfo, &drives, next) { QTAILQ_FOREACH(dinfo, &drives, next) {
bs = dinfo->bdrv; bs = dinfo->bdrv;
if (bdrv_can_snapshot(bs)) if (bdrv_can_snapshot(bs))
goto ok; goto ok;
@ -1547,7 +1546,7 @@ void do_savevm(Monitor *mon, const QDict *qdict)
/* create the snapshots */ /* create the snapshots */
TAILQ_FOREACH(dinfo, &drives, next) { QTAILQ_FOREACH(dinfo, &drives, next) {
bs1 = dinfo->bdrv; bs1 = dinfo->bdrv;
if (bdrv_has_snapshot(bs1)) { if (bdrv_has_snapshot(bs1)) {
if (must_delete) { if (must_delete) {
@ -1590,7 +1589,7 @@ int load_vmstate(Monitor *mon, const char *name)
/* Flush all IO requests so they don't interfere with the new state. */ /* Flush all IO requests so they don't interfere with the new state. */
qemu_aio_flush(); qemu_aio_flush();
TAILQ_FOREACH(dinfo, &drives, next) { QTAILQ_FOREACH(dinfo, &drives, next) {
bs1 = dinfo->bdrv; bs1 = dinfo->bdrv;
if (bdrv_has_snapshot(bs1)) { if (bdrv_has_snapshot(bs1)) {
ret = bdrv_snapshot_goto(bs1, name); ret = bdrv_snapshot_goto(bs1, name);
@ -1653,7 +1652,7 @@ void do_delvm(Monitor *mon, const QDict *qdict)
return; return;
} }
TAILQ_FOREACH(dinfo, &drives, next) { QTAILQ_FOREACH(dinfo, &drives, next) {
bs1 = dinfo->bdrv; bs1 = dinfo->bdrv;
if (bdrv_has_snapshot(bs1)) { if (bdrv_has_snapshot(bs1)) {
ret = bdrv_snapshot_delete(bs1, name); ret = bdrv_snapshot_delete(bs1, name);
@ -1684,7 +1683,7 @@ void do_info_snapshots(Monitor *mon)
return; return;
} }
monitor_printf(mon, "Snapshot devices:"); monitor_printf(mon, "Snapshot devices:");
TAILQ_FOREACH(dinfo, &drives, next) { QTAILQ_FOREACH(dinfo, &drives, next) {
bs1 = dinfo->bdrv; bs1 = dinfo->bdrv;
if (bdrv_has_snapshot(bs1)) { if (bdrv_has_snapshot(bs1)) {
if (bs == bs1) if (bs == bs1)

16
slirp/slirp.c
View File

@ -44,8 +44,8 @@ u_int curtime;
static u_int time_fasttimo, last_slowtimo; static u_int time_fasttimo, last_slowtimo;
static int do_slowtimo; static int do_slowtimo;
static TAILQ_HEAD(slirp_instances, Slirp) slirp_instances = static QTAILQ_HEAD(slirp_instances, Slirp) slirp_instances =
TAILQ_HEAD_INITIALIZER(slirp_instances); QTAILQ_HEAD_INITIALIZER(slirp_instances);
static struct in_addr dns_addr; static struct in_addr dns_addr;
static u_int dns_addr_time; static u_int dns_addr_time;
@ -234,14 +234,14 @@ Slirp *slirp_init(int restricted, struct in_addr vnetwork,
register_savevm("slirp", 0, 3, slirp_state_save, slirp_state_load, slirp); 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; return slirp;
} }
void slirp_cleanup(Slirp *slirp) void slirp_cleanup(Slirp *slirp)
{ {
TAILQ_REMOVE(&slirp_instances, slirp, entry); QTAILQ_REMOVE(&slirp_instances, slirp, entry);
unregister_savevm("slirp", slirp); unregister_savevm("slirp", slirp);
@ -261,7 +261,7 @@ void slirp_select_fill(int *pnfds,
struct socket *so, *so_next; struct socket *so, *so_next;
int nfds; int nfds;
if (TAILQ_EMPTY(&slirp_instances)) { if (QTAILQ_EMPTY(&slirp_instances)) {
return; return;
} }
@ -276,7 +276,7 @@ void slirp_select_fill(int *pnfds,
*/ */
do_slowtimo = 0; do_slowtimo = 0;
TAILQ_FOREACH(slirp, &slirp_instances, entry) { QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
/* /*
* *_slowtimo needs calling if there are IP fragments * *_slowtimo needs calling if there are IP fragments
* in the fragment queue, or there are TCP connections active * in the fragment queue, or there are TCP connections active
@ -384,7 +384,7 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
struct socket *so, *so_next; struct socket *so, *so_next;
int ret; int ret;
if (TAILQ_EMPTY(&slirp_instances)) { if (QTAILQ_EMPTY(&slirp_instances)) {
return; return;
} }
@ -394,7 +394,7 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
curtime = qemu_get_clock(rt_clock); curtime = qemu_get_clock(rt_clock);
TAILQ_FOREACH(slirp, &slirp_instances, entry) { QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
/* /*
* See if anything has timed out * See if anything has timed out
*/ */

4
slirp/slirp.h
View File

@ -174,7 +174,7 @@ int inet_aton(const char *cp, struct in_addr *ia);
#include "debug.h" #include "debug.h"
#include "sys-queue.h" #include "qemu-queue.h"
#include "libslirp.h" #include "libslirp.h"
#include "ip.h" #include "ip.h"
@ -198,7 +198,7 @@ int inet_aton(const char *cp, struct in_addr *ia);
#include "tftp.h" #include "tftp.h"
struct Slirp { struct Slirp {
TAILQ_ENTRY(Slirp) entry; QTAILQ_ENTRY(Slirp) entry;
/* virtual network configuration */ /* virtual network configuration */
struct in_addr vnetwork_addr; struct in_addr vnetwork_addr;

8
sysemu.h
View File

@ -4,7 +4,7 @@
#include "qemu-common.h" #include "qemu-common.h"
#include "qemu-option.h" #include "qemu-option.h"
#include "sys-queue.h" #include "qemu-queue.h"
#include "qdict.h" #include "qdict.h"
#ifdef _WIN32 #ifdef _WIN32
@ -174,15 +174,15 @@ typedef struct DriveInfo {
QemuOpts *opts; QemuOpts *opts;
BlockInterfaceErrorAction onerror; BlockInterfaceErrorAction onerror;
char serial[BLOCK_SERIAL_STRLEN + 1]; char serial[BLOCK_SERIAL_STRLEN + 1];
TAILQ_ENTRY(DriveInfo) next; QTAILQ_ENTRY(DriveInfo) next;
} DriveInfo; } DriveInfo;
#define MAX_IDE_DEVS 2 #define MAX_IDE_DEVS 2
#define MAX_SCSI_DEVS 7 #define MAX_SCSI_DEVS 7
#define MAX_DRIVES 32 #define MAX_DRIVES 32
extern TAILQ_HEAD(drivelist, DriveInfo) drives; extern QTAILQ_HEAD(drivelist, DriveInfo) drives;
extern TAILQ_HEAD(driveoptlist, DriveOpt) driveopts; extern QTAILQ_HEAD(driveoptlist, DriveOpt) driveopts;
extern DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit); extern DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit);
extern DriveInfo *drive_get_by_id(const char *id); extern DriveInfo *drive_get_by_id(const char *id);

4
target-alpha/translate.c
View File

@ -2367,8 +2367,8 @@ static inline void gen_intermediate_code_internal(CPUState *env,
gen_icount_start(); gen_icount_start();
for (ret = 0; ret == 0;) { for (ret = 0; ret == 0;) {
if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
TAILQ_FOREACH(bp, &env->breakpoints, entry) { QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
if (bp->pc == ctx.pc) { if (bp->pc == ctx.pc) {
gen_excp(&ctx, EXCP_DEBUG, 0); gen_excp(&ctx, EXCP_DEBUG, 0);
break; break;

4
target-arm/translate.c
View File

@ -8770,8 +8770,8 @@ static inline void gen_intermediate_code_internal(CPUState *env,
} }
#endif #endif
if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
TAILQ_FOREACH(bp, &env->breakpoints, entry) { QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
if (bp->pc == dc->pc) { if (bp->pc == dc->pc) {
gen_set_condexec(dc); gen_set_condexec(dc);
gen_set_pc_im(dc->pc); gen_set_pc_im(dc->pc);

4
target-cris/translate.c
View File

@ -3082,8 +3082,8 @@ static void check_breakpoint(CPUState *env, DisasContext *dc)
{ {
CPUBreakpoint *bp; CPUBreakpoint *bp;
if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
TAILQ_FOREACH(bp, &env->breakpoints, entry) { QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
if (bp->pc == dc->pc) { if (bp->pc == dc->pc) {
cris_evaluate_flags (dc); cris_evaluate_flags (dc);
tcg_gen_movi_tl(env_pc, dc->pc); tcg_gen_movi_tl(env_pc, dc->pc);

2
target-i386/helper.c
View File

@ -1522,7 +1522,7 @@ static void breakpoint_handler(CPUState *env)
cpu_resume_from_signal(env, NULL); cpu_resume_from_signal(env, NULL);
} }
} else { } else {
TAILQ_FOREACH(bp, &env->breakpoints, entry) QTAILQ_FOREACH(bp, &env->breakpoints, entry)
if (bp->pc == env->eip) { if (bp->pc == env->eip) {
if (bp->flags & BP_CPU) { if (bp->flags & BP_CPU) {
check_hw_breakpoints(env, 1); check_hw_breakpoints(env, 1);

4
target-i386/translate.c
View File

@ -7687,8 +7687,8 @@ static inline void gen_intermediate_code_internal(CPUState *env,
gen_icount_start(); gen_icount_start();
for(;;) { for(;;) {
if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
TAILQ_FOREACH(bp, &env->breakpoints, entry) { QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
if (bp->pc == pc_ptr && if (bp->pc == pc_ptr &&
!((bp->flags & BP_CPU) && (tb->flags & HF_RF_MASK))) { !((bp->flags & BP_CPU) && (tb->flags & HF_RF_MASK))) {
gen_debug(dc, pc_ptr - dc->cs_base); gen_debug(dc, pc_ptr - dc->cs_base);

4
target-m68k/translate.c
View File

@ -2999,8 +2999,8 @@ gen_intermediate_code_internal(CPUState *env, TranslationBlock *tb,
do { do {
pc_offset = dc->pc - pc_start; pc_offset = dc->pc - pc_start;
gen_throws_exception = NULL; gen_throws_exception = NULL;
if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
TAILQ_FOREACH(bp, &env->breakpoints, entry) { QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
if (bp->pc == dc->pc) { if (bp->pc == dc->pc) {
gen_exception(dc, dc->pc, EXCP_DEBUG); gen_exception(dc, dc->pc, EXCP_DEBUG);
dc->is_jmp = DISAS_JUMP; dc->is_jmp = DISAS_JUMP;

4
target-microblaze/translate.c
View File

@ -1230,8 +1230,8 @@ static void check_breakpoint(CPUState *env, DisasContext *dc)
{ {
CPUBreakpoint *bp; CPUBreakpoint *bp;
if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
TAILQ_FOREACH(bp, &env->breakpoints, entry) { QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
if (bp->pc == dc->pc) { if (bp->pc == dc->pc) {
t_gen_raise_exception(dc, EXCP_DEBUG); t_gen_raise_exception(dc, EXCP_DEBUG);
dc->is_jmp = DISAS_UPDATE; dc->is_jmp = DISAS_UPDATE;

4
target-mips/translate.c
View File

@ -8314,8 +8314,8 @@ gen_intermediate_code_internal (CPUState *env, TranslationBlock *tb,
LOG_DISAS("\ntb %p idx %d hflags %04x\n", tb, ctx.mem_idx, ctx.hflags); LOG_DISAS("\ntb %p idx %d hflags %04x\n", tb, ctx.mem_idx, ctx.hflags);
gen_icount_start(); gen_icount_start();
while (ctx.bstate == BS_NONE) { while (ctx.bstate == BS_NONE) {
if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
TAILQ_FOREACH(bp, &env->breakpoints, entry) { QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
if (bp->pc == ctx.pc) { if (bp->pc == ctx.pc) {
save_cpu_state(&ctx, 1); save_cpu_state(&ctx, 1);
ctx.bstate = BS_BRANCH; ctx.bstate = BS_BRANCH;

4
target-ppc/translate.c
View File

@ -9000,8 +9000,8 @@ static inline void gen_intermediate_code_internal(CPUState *env,
gen_icount_start(); gen_icount_start();
/* Set env in case of segfault during code fetch */ /* Set env in case of segfault during code fetch */
while (ctx.exception == POWERPC_EXCP_NONE && gen_opc_ptr < gen_opc_end) { while (ctx.exception == POWERPC_EXCP_NONE && gen_opc_ptr < gen_opc_end) {
if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
TAILQ_FOREACH(bp, &env->breakpoints, entry) { QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
if (bp->pc == ctx.nip) { if (bp->pc == ctx.nip) {
gen_debug_exception(ctxp); gen_debug_exception(ctxp);
break; break;

4
target-sh4/translate.c
View File

@ -1927,8 +1927,8 @@ gen_intermediate_code_internal(CPUState * env, TranslationBlock * tb,
max_insns = CF_COUNT_MASK; max_insns = CF_COUNT_MASK;
gen_icount_start(); gen_icount_start();
while (ctx.bstate == BS_NONE && gen_opc_ptr < gen_opc_end) { while (ctx.bstate == BS_NONE && gen_opc_ptr < gen_opc_end) {
if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
TAILQ_FOREACH(bp, &env->breakpoints, entry) { QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
if (ctx.pc == bp->pc) { if (ctx.pc == bp->pc) {
/* We have hit a breakpoint - make sure PC is up-to-date */ /* We have hit a breakpoint - make sure PC is up-to-date */
tcg_gen_movi_i32(cpu_pc, ctx.pc); tcg_gen_movi_i32(cpu_pc, ctx.pc);

4
target-sparc/translate.c
View File

@ -4706,8 +4706,8 @@ static inline void gen_intermediate_code_internal(TranslationBlock * tb,
max_insns = CF_COUNT_MASK; max_insns = CF_COUNT_MASK;
gen_icount_start(); gen_icount_start();
do { do {
if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
TAILQ_FOREACH(bp, &env->breakpoints, entry) { QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
if (bp->pc == dc->pc) { if (bp->pc == dc->pc) {
if (dc->pc != pc_start) if (dc->pc != pc_start)
save_state(dc, cpu_cond); save_state(dc, cpu_cond);

56
vl.c
View File

@ -31,8 +31,6 @@
/* Needed early for CONFIG_BSD etc. */ /* Needed early for CONFIG_BSD etc. */
#include "config-host.h" #include "config-host.h"
/* Needed early to override system queue definitions on BSD */
#include "sys-queue.h"
#ifndef _WIN32 #ifndef _WIN32
#include <libgen.h> #include <libgen.h>
@ -168,6 +166,8 @@ int main(int argc, char **argv)
#include "slirp/libslirp.h" #include "slirp/libslirp.h"
#include "qemu-queue.h"
//#define DEBUG_NET //#define DEBUG_NET
//#define DEBUG_SLIRP //#define DEBUG_SLIRP
@ -180,8 +180,8 @@ static const char *data_dir;
const char *bios_name = NULL; const char *bios_name = NULL;
/* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
to store the VM snapshots */ to store the VM snapshots */
struct drivelist drives = TAILQ_HEAD_INITIALIZER(drives); struct drivelist drives = QTAILQ_HEAD_INITIALIZER(drives);
struct driveoptlist driveopts = TAILQ_HEAD_INITIALIZER(driveopts); struct driveoptlist driveopts = QTAILQ_HEAD_INITIALIZER(driveopts);
enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB; enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
static DisplayState *display_state; static DisplayState *display_state;
DisplayType display_type = DT_DEFAULT; DisplayType display_type = DT_DEFAULT;
@ -1810,7 +1810,7 @@ DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)
/* seek interface, bus and unit */ /* seek interface, bus and unit */
TAILQ_FOREACH(dinfo, &drives, next) { QTAILQ_FOREACH(dinfo, &drives, next) {
if (dinfo->type == type && if (dinfo->type == type &&
dinfo->bus == bus && dinfo->bus == bus &&
dinfo->unit == unit) dinfo->unit == unit)
@ -1824,7 +1824,7 @@ DriveInfo *drive_get_by_id(const char *id)
{ {
DriveInfo *dinfo; DriveInfo *dinfo;
TAILQ_FOREACH(dinfo, &drives, next) { QTAILQ_FOREACH(dinfo, &drives, next) {
if (strcmp(id, dinfo->id)) if (strcmp(id, dinfo->id))
continue; continue;
return dinfo; return dinfo;
@ -1838,7 +1838,7 @@ int drive_get_max_bus(BlockInterfaceType type)
DriveInfo *dinfo; DriveInfo *dinfo;
max_bus = -1; max_bus = -1;
TAILQ_FOREACH(dinfo, &drives, next) { QTAILQ_FOREACH(dinfo, &drives, next) {
if(dinfo->type == type && if(dinfo->type == type &&
dinfo->bus > max_bus) dinfo->bus > max_bus)
max_bus = dinfo->bus; max_bus = dinfo->bus;
@ -1850,7 +1850,7 @@ const char *drive_get_serial(BlockDriverState *bdrv)
{ {
DriveInfo *dinfo; DriveInfo *dinfo;
TAILQ_FOREACH(dinfo, &drives, next) { QTAILQ_FOREACH(dinfo, &drives, next) {
if (dinfo->bdrv == bdrv) if (dinfo->bdrv == bdrv)
return dinfo->serial; return dinfo->serial;
} }
@ -1862,7 +1862,7 @@ BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv)
{ {
DriveInfo *dinfo; DriveInfo *dinfo;
TAILQ_FOREACH(dinfo, &drives, next) { QTAILQ_FOREACH(dinfo, &drives, next) {
if (dinfo->bdrv == bdrv) if (dinfo->bdrv == bdrv)
return dinfo->onerror; return dinfo->onerror;
} }
@ -1879,11 +1879,11 @@ void drive_uninit(BlockDriverState *bdrv)
{ {
DriveInfo *dinfo; DriveInfo *dinfo;
TAILQ_FOREACH(dinfo, &drives, next) { QTAILQ_FOREACH(dinfo, &drives, next) {
if (dinfo->bdrv != bdrv) if (dinfo->bdrv != bdrv)
continue; continue;
qemu_opts_del(dinfo->opts); qemu_opts_del(dinfo->opts);
TAILQ_REMOVE(&drives, dinfo, next); QTAILQ_REMOVE(&drives, dinfo, next);
qemu_free(dinfo); qemu_free(dinfo);
break; break;
} }
@ -2170,7 +2170,7 @@ DriveInfo *drive_init(QemuOpts *opts, void *opaque,
dinfo->opts = opts; dinfo->opts = opts;
if (serial) if (serial)
strncpy(dinfo->serial, serial, sizeof(serial)); strncpy(dinfo->serial, serial, sizeof(serial));
TAILQ_INSERT_TAIL(&drives, dinfo, next); QTAILQ_INSERT_TAIL(&drives, dinfo, next);
switch(type) { switch(type) {
case IF_IDE: case IF_IDE:
@ -3145,10 +3145,10 @@ static void nographic_update(void *opaque)
struct vm_change_state_entry { struct vm_change_state_entry {
VMChangeStateHandler *cb; VMChangeStateHandler *cb;
void *opaque; 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, VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
void *opaque) void *opaque)
@ -3159,13 +3159,13 @@ VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
e->cb = cb; e->cb = cb;
e->opaque = opaque; e->opaque = opaque;
LIST_INSERT_HEAD(&vm_change_state_head, e, entries); QLIST_INSERT_HEAD(&vm_change_state_head, e, entries);
return e; return e;
} }
void qemu_del_vm_change_state_handler(VMChangeStateEntry *e) void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
{ {
LIST_REMOVE (e, entries); QLIST_REMOVE (e, entries);
qemu_free (e); qemu_free (e);
} }
@ -3195,13 +3195,13 @@ void vm_start(void)
/* reset/shutdown handler */ /* reset/shutdown handler */
typedef struct QEMUResetEntry { typedef struct QEMUResetEntry {
TAILQ_ENTRY(QEMUResetEntry) entry; QTAILQ_ENTRY(QEMUResetEntry) entry;
QEMUResetHandler *func; QEMUResetHandler *func;
void *opaque; void *opaque;
} QEMUResetEntry; } QEMUResetEntry;
static TAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers = static QTAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers =
TAILQ_HEAD_INITIALIZER(reset_handlers); QTAILQ_HEAD_INITIALIZER(reset_handlers);
static int reset_requested; static int reset_requested;
static int shutdown_requested; static int shutdown_requested;
static int powerdown_requested; static int powerdown_requested;
@ -3259,16 +3259,16 @@ void qemu_register_reset(QEMUResetHandler *func, void *opaque)
re->func = func; re->func = func;
re->opaque = opaque; 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) void qemu_unregister_reset(QEMUResetHandler *func, void *opaque)
{ {
QEMUResetEntry *re; QEMUResetEntry *re;
TAILQ_FOREACH(re, &reset_handlers, entry) { QTAILQ_FOREACH(re, &reset_handlers, entry) {
if (re->func == func && re->opaque == opaque) { if (re->func == func && re->opaque == opaque) {
TAILQ_REMOVE(&reset_handlers, re, entry); QTAILQ_REMOVE(&reset_handlers, re, entry);
qemu_free(re); qemu_free(re);
return; return;
} }
@ -3280,7 +3280,7 @@ void qemu_system_reset(void)
QEMUResetEntry *re, *nre; QEMUResetEntry *re, *nre;
/* reset all devices */ /* reset all devices */
TAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) { QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) {
re->func(re->opaque); re->func(re->opaque);
} }
} }
@ -4579,9 +4579,9 @@ struct device_config {
DEV_BT, /* -bt */ DEV_BT, /* -bt */
} type; } type;
const char *cmdline; 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) static void add_device_config(int type, const char *cmdline)
{ {
@ -4590,7 +4590,7 @@ static void add_device_config(int type, const char *cmdline)
conf = qemu_mallocz(sizeof(*conf)); conf = qemu_mallocz(sizeof(*conf));
conf->type = type; conf->type = type;
conf->cmdline = cmdline; 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)) static int foreach_device_config(int type, int (*func)(const char *cmdline))
@ -4598,7 +4598,7 @@ static int foreach_device_config(int type, int (*func)(const char *cmdline))
struct device_config *conf; struct device_config *conf;
int rc; int rc;
TAILQ_FOREACH(conf, &device_configs, next) { QTAILQ_FOREACH(conf, &device_configs, next) {
if (conf->type != type) if (conf->type != type)
continue; continue;
rc = func(conf->cmdline); rc = func(conf->cmdline);
@ -4655,7 +4655,7 @@ int main(int argc, char **argv, char **envp)
qemu_errors_to_file(stderr); qemu_errors_to_file(stderr);
qemu_cache_utils_init(envp); qemu_cache_utils_init(envp);
LIST_INIT (&vm_change_state_head); QLIST_INIT (&vm_change_state_head);
#ifndef _WIN32 #ifndef _WIN32
{ {
struct sigaction act; struct sigaction act;