diff options
| author |   Marcelo Tosatti <mtosatti@redhat.com> | 2009-09-14 08:48:43 -0300 |
|---|---|---|
| committer | Marcelo Tosatti <mtosatti@redhat.com> | 2009-09-14 08:48:43 -0300 |
| commit | 184b194ef1a8b8ce035d48c3fbdd72e3b4732869 (patch) | |
| tree | a4e50b03279f2a140a99aca8689973090afa151d | |
| parent | Merge commit '2637c754ccdb286890ed2a8d0d1da775dbd062af' into upstream-merge (diff) | |
| parent | Fix sys-queue.h conflict for good (diff) | |
| download | qemu-kvm-184b194ef1a8b8ce035d48c3fbdd72e3b4732869.tar.gz qemu-kvm-184b194ef1a8b8ce035d48c3fbdd72e3b4732869.tar.bz2 qemu-kvm-184b194ef1a8b8ce035d48c3fbdd72e3b4732869.zip | |
Merge commit '72cf2d4f0e181d0d3a3122e04129c58a95da713e' into upstream-merge
* commit '72cf2d4f0e181d0d3a3122e04129c58a95da713e':
Fix sys-queue.h conflict for good
Try to fix BSD breakage by 806b60248218bd5f74a8b070f5a99a864e8e51c6
Include sys-queue.h early to override system queue definitions on BSD
Unbreak BSD: use qemu_fdatasync instead of fdatasync
Use proper format conversion specifier when printing size_t value
audio: remove lsbindex/popcount in favour of host-utils's ctz32
alsa: poll mode handling
oss: poll mode handling
audio: poll mode infrastructure
gus: Do not manually free the state, qdev does it for us
oss: Unbreak mmaping the ability to mmap oss fd on Linux
Conflicts:
exec.c
kvm.h
sysemu.h
vl.c
Signed-off-by: Marcelo Tosatti <mtosatti@redhat.com>
75 files changed, 911 insertions, 582 deletions
@@ -64,7 +64,7 @@ qemu_acl *qemu_acl_init(const char *aclname) acl->defaultDeny = 1; acl->nentries = 0; - TAILQ_INIT(&acl->entries); + QTAILQ_INIT(&acl->entries); acls = qemu_realloc(acls, sizeof(*acls) * (nacls +1)); acls[nacls] = acl; @@ -78,7 +78,7 @@ int qemu_acl_party_is_allowed(qemu_acl *acl, { qemu_acl_entry *entry; - TAILQ_FOREACH(entry, &acl->entries, next) { + QTAILQ_FOREACH(entry, &acl->entries, next) { #ifdef CONFIG_FNMATCH if (fnmatch(entry->match, party, 0) == 0) return entry->deny ? 0 : 1; @@ -102,8 +102,8 @@ void qemu_acl_reset(qemu_acl *acl) * of "open access" while the user re-initializes the * access control list */ acl->defaultDeny = 1; - TAILQ_FOREACH(entry, &acl->entries, next) { - TAILQ_REMOVE(&acl->entries, entry, next); + QTAILQ_FOREACH(entry, &acl->entries, next) { + QTAILQ_REMOVE(&acl->entries, entry, next); free(entry->match); free(entry); } @@ -121,7 +121,7 @@ int qemu_acl_append(qemu_acl *acl, entry->match = qemu_strdup(match); entry->deny = deny; - TAILQ_INSERT_TAIL(&acl->entries, entry, next); + QTAILQ_INSERT_TAIL(&acl->entries, entry, next); acl->nentries++; return acl->nentries; @@ -147,10 +147,10 @@ int qemu_acl_insert(qemu_acl *acl, entry->match = qemu_strdup(match); entry->deny = deny; - TAILQ_FOREACH(tmp, &acl->entries, next) { + QTAILQ_FOREACH(tmp, &acl->entries, next) { i++; if (i == index) { - TAILQ_INSERT_BEFORE(tmp, entry, next); + QTAILQ_INSERT_BEFORE(tmp, entry, next); acl->nentries++; break; } @@ -165,10 +165,10 @@ int qemu_acl_remove(qemu_acl *acl, qemu_acl_entry *entry; int i = 0; - TAILQ_FOREACH(entry, &acl->entries, next) { + QTAILQ_FOREACH(entry, &acl->entries, next) { i++; if (strcmp(entry->match, match) == 0) { - TAILQ_REMOVE(&acl->entries, entry, next); + QTAILQ_REMOVE(&acl->entries, entry, next); return i; } } @@ -25,7 +25,7 @@ #ifndef __QEMU_ACL_H__ #define __QEMU_ACL_H__ -#include "sys-queue.h" +#include "qemu-queue.h" typedef struct qemu_acl_entry qemu_acl_entry; typedef struct qemu_acl qemu_acl; @@ -34,13 +34,13 @@ struct qemu_acl_entry { char *match; int deny; - TAILQ_ENTRY(qemu_acl_entry) next; + QTAILQ_ENTRY(qemu_acl_entry) next; }; struct qemu_acl { char *aclname; unsigned int nentries; - TAILQ_HEAD(,qemu_acl_entry) entries; + QTAILQ_HEAD(,qemu_acl_entry) entries; int defaultDeny; }; @@ -13,13 +13,13 @@ #include "qemu-common.h" #include "block.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "qemu_socket.h" typedef struct AioHandler AioHandler; /* The list of registered AIO handlers */ -static LIST_HEAD(, AioHandler) aio_handlers; +static QLIST_HEAD(, AioHandler) aio_handlers; /* This is a simple lock used to protect the aio_handlers list. Specifically, * it's used to ensure that no callbacks are removed while we're walking and @@ -35,14 +35,14 @@ struct AioHandler AioFlushHandler *io_flush; int deleted; void *opaque; - LIST_ENTRY(AioHandler) node; + QLIST_ENTRY(AioHandler) node; }; static AioHandler *find_aio_handler(int fd) { AioHandler *node; - LIST_FOREACH(node, &aio_handlers, node) { + QLIST_FOREACH(node, &aio_handlers, node) { if (node->fd == fd) if (!node->deleted) return node; @@ -72,7 +72,7 @@ int qemu_aio_set_fd_handler(int fd, * deleted because deleted nodes are only cleaned up after * releasing the walking_handlers lock. */ - LIST_REMOVE(node, node); + QLIST_REMOVE(node, node); qemu_free(node); } } @@ -81,7 +81,7 @@ int qemu_aio_set_fd_handler(int fd, /* Alloc and insert if it's not already there */ node = qemu_mallocz(sizeof(AioHandler)); node->fd = fd; - LIST_INSERT_HEAD(&aio_handlers, node, node); + QLIST_INSERT_HEAD(&aio_handlers, node, node); } /* Update handler with latest information */ node->io_read = io_read; @@ -109,7 +109,7 @@ void qemu_aio_flush(void) */ qemu_aio_wait(); - LIST_FOREACH(node, &aio_handlers, node) { + QLIST_FOREACH(node, &aio_handlers, node) { ret |= node->io_flush(node->opaque); } } while (qemu_bh_poll() || ret > 0); @@ -133,7 +133,7 @@ void qemu_aio_wait(void) FD_ZERO(&wrfds); /* fill fd sets */ - LIST_FOREACH(node, &aio_handlers, node) { + QLIST_FOREACH(node, &aio_handlers, node) { /* If there aren't pending AIO operations, don't invoke callbacks. * Otherwise, if there are no AIO requests, qemu_aio_wait() would * wait indefinitely. @@ -168,7 +168,7 @@ void qemu_aio_wait(void) /* we have to walk very carefully in case * qemu_aio_set_fd_handler is called while we're walking */ - node = LIST_FIRST(&aio_handlers); + node = QLIST_FIRST(&aio_handlers); while (node) { AioHandler *tmp; @@ -184,10 +184,10 @@ void qemu_aio_wait(void) } tmp = node; - node = LIST_NEXT(node, node); + node = QLIST_NEXT(node, node); if (tmp->deleted) { - LIST_REMOVE(tmp, node); + QLIST_REMOVE(tmp, node); qemu_free(tmp); } } diff --git a/audio/alsaaudio.c b/audio/alsaaudio.c index 5ea49a692..28c245dc7 100644 --- a/audio/alsaaudio.c +++ b/audio/alsaaudio.c @@ -23,6 +23,7 @@ */ #include <alsa/asoundlib.h> #include "qemu-common.h" +#include "qemu-char.h" #include "audio.h" #if QEMU_GNUC_PREREQ(4, 3) @@ -32,16 +33,24 @@ #define AUDIO_CAP "alsa" #include "audio_int.h" +struct pollhlp { + snd_pcm_t *handle; + struct pollfd *pfds; + int count; +}; + typedef struct ALSAVoiceOut { HWVoiceOut hw; void *pcm_buf; snd_pcm_t *handle; + struct pollhlp pollhlp; } ALSAVoiceOut; typedef struct ALSAVoiceIn { HWVoiceIn hw; snd_pcm_t *handle; void *pcm_buf; + struct pollhlp pollhlp; } ALSAVoiceIn; static struct { @@ -123,6 +132,156 @@ static void alsa_anal_close (snd_pcm_t **handlep) *handlep = NULL; } +static int alsa_recover (snd_pcm_t *handle) +{ + int err = snd_pcm_prepare (handle); + if (err < 0) { + alsa_logerr (err, "Failed to prepare handle %p\n", handle); + return -1; + } + return 0; +} + +static int alsa_resume (snd_pcm_t *handle) +{ + int err = snd_pcm_resume (handle); + if (err < 0) { + alsa_logerr (err, "Failed to resume handle %p\n", handle); + return -1; + } + return 0; +} + +static void alsa_poll_handler (void *opaque) +{ + int err, count; + snd_pcm_state_t state; + struct pollhlp *hlp = opaque; + unsigned short revents; + + count = poll (hlp->pfds, hlp->count, 0); + if (count < 0) { + dolog ("alsa_poll_handler: poll %s\n", strerror (errno)); + return; + } + + if (!count) { + return; + } + + /* XXX: ALSA example uses initial count, not the one returned by + poll, correct? */ + err = snd_pcm_poll_descriptors_revents (hlp->handle, hlp->pfds, + hlp->count, &revents); + if (err < 0) { + alsa_logerr (err, "snd_pcm_poll_descriptors_revents"); + return; + } + + if (!(revents & POLLOUT)) { + if (conf.verbose) { + dolog ("revents = %d\n", revents); + } + return; + } + + state = snd_pcm_state (hlp->handle); + switch (state) { + case SND_PCM_STATE_XRUN: + alsa_recover (hlp->handle); + break; + + case SND_PCM_STATE_SUSPENDED: + alsa_resume (hlp->handle); + break; + + case SND_PCM_STATE_PREPARED: + audio_run ("alsa run (prepared)"); + break; + + case SND_PCM_STATE_RUNNING: + audio_run ("alsa run (running)"); + break; + + default: + dolog ("Unexpected state %d\n", state); + } +} + +static int alsa_poll_helper (snd_pcm_t *handle, struct pollhlp *hlp) +{ + int i, count, err; + struct pollfd *pfds; + + count = snd_pcm_poll_descriptors_count (handle); + if (count <= 0) { + dolog ("Could not initialize poll mode\n" + "Invalid number of poll descriptors %d\n", count); + return -1; + } + + pfds = audio_calloc ("alsa_poll_helper", count, sizeof (*pfds)); + if (!pfds) { + dolog ("Could not initialize poll mode\n"); + return -1; + } + + err = snd_pcm_poll_descriptors (handle, pfds, count); + if (err < 0) { + alsa_logerr (err, "Could not initialize poll mode\n" + "Could not obtain poll descriptors\n"); + qemu_free (pfds); + return -1; + } + + for (i = 0; i < count; ++i) { + if (pfds[i].events & POLLIN) { + err = qemu_set_fd_handler (pfds[i].fd, alsa_poll_handler, + NULL, hlp); + } + if (pfds[i].events & POLLOUT) { + if (conf.verbose) { + dolog ("POLLOUT %d %d\n", i, pfds[i].fd); + } + err = qemu_set_fd_handler (pfds[i].fd, NULL, + alsa_poll_handler, hlp); + } + if (conf.verbose) { + dolog ("Set handler events=%#x index=%d fd=%d err=%d\n", + pfds[i].events, i, pfds[i].fd, err); + } + + if (err) { + dolog ("Failed to set handler events=%#x index=%d fd=%d err=%d\n", + pfds[i].events, i, pfds[i].fd, err); + + while (i--) { + qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL); + } + qemu_free (pfds); + return -1; + } + } + hlp->pfds = pfds; + hlp->count = count; + hlp->handle = handle; + return 0; +} + +static int alsa_poll_out (HWVoiceOut *hw) +{ + ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; + + return alsa_poll_helper (alsa->handle, &alsa->pollhlp); +} + +static int alsa_poll_in (HWVoiceIn *hw) +{ + ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; + + return alsa_poll_helper (alsa->handle, &alsa->pollhlp); +} + static int alsa_write (SWVoiceOut *sw, void *buf, int len) { return audio_pcm_sw_write (sw, buf, len); @@ -493,26 +652,6 @@ static int alsa_open (int in, struct alsa_params_req *req, return -1; } -static int alsa_recover (snd_pcm_t *handle) -{ - int err = snd_pcm_prepare (handle); - if (err < 0) { - alsa_logerr (err, "Failed to prepare handle %p\n", handle); - return -1; - } - return 0; -} - -static int alsa_resume (snd_pcm_t *handle) -{ - int err = snd_pcm_resume (handle); - if (err < 0) { - alsa_logerr (err, "Failed to resume handle %p\n", handle); - return -1; - } - return 0; -} - static snd_pcm_sframes_t alsa_get_avail (snd_pcm_t *handle) { snd_pcm_sframes_t avail; @@ -626,6 +765,22 @@ static int alsa_run_out (HWVoiceOut *hw) return decr; } +static void alsa_fini_poll (struct pollhlp *hlp) +{ + int i; + struct pollfd *pfds = hlp->pfds; + + if (pfds) { + for (i = 0; i < hlp->count; ++i) { + qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL); + } + qemu_free (pfds); + } + hlp->pfds = NULL; + hlp->count = 0; + hlp->handle = NULL; +} + static void alsa_fini_out (HWVoiceOut *hw) { ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; @@ -637,6 +792,8 @@ static void alsa_fini_out (HWVoiceOut *hw) qemu_free (alsa->pcm_buf); alsa->pcm_buf = NULL; } + + alsa_fini_poll (&alsa->pollhlp); } static int alsa_init_out (HWVoiceOut *hw, struct audsettings *as) @@ -705,11 +862,21 @@ static int alsa_voice_ctl (snd_pcm_t *handle, const char *typ, int pause) static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...) { + va_list ap; + int poll_mode; ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; + va_start (ap, cmd); + poll_mode = va_arg (ap, int); + va_end (ap); + switch (cmd) { case VOICE_ENABLE: ldebug ("enabling voice\n"); + if (poll_mode && alsa_poll_out (hw)) { + poll_mode = 0; + } + hw->poll_mode = poll_mode; return alsa_voice_ctl (alsa->handle, "playback", 0); case VOICE_DISABLE: @@ -772,6 +939,7 @@ static void alsa_fini_in (HWVoiceIn *hw) qemu_free (alsa->pcm_buf); alsa->pcm_buf = NULL; } + alsa_fini_poll (&alsa->pollhlp); } static int alsa_run_in (HWVoiceIn *hw) @@ -909,15 +1077,30 @@ static int alsa_read (SWVoiceIn *sw, void *buf, int size) static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...) { + va_list ap; + int poll_mode; ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; + va_start (ap, cmd); + poll_mode = va_arg (ap, int); + va_end (ap); + switch (cmd) { case VOICE_ENABLE: ldebug ("enabling voice\n"); + if (poll_mode && alsa_poll_in (hw)) { + poll_mode = 0; + } + hw->poll_mode = poll_mode; + return alsa_voice_ctl (alsa->handle, "capture", 0); case VOICE_DISABLE: ldebug ("disabling voice\n"); + if (hw->poll_mode) { + hw->poll_mode = 0; + alsa_fini_poll (&alsa->pollhlp); + } return alsa_voice_ctl (alsa->handle, "capture", 1); } @@ -1014,7 +1197,7 @@ static struct audio_pcm_ops alsa_pcm_ops = { .fini_in = alsa_fini_in, .run_in = alsa_run_in, .read = alsa_read, - .ctl_in = alsa_ctl_in + .ctl_in = alsa_ctl_in, }; struct audio_driver alsa_audio_driver = { diff --git a/audio/audio.c b/audio/audio.c index f247f4214..e223cf3e8 100644 --- a/audio/audio.c +++ b/audio/audio.c @@ -34,6 +34,7 @@ /* #define DEBUG_LIVE */ /* #define DEBUG_OUT */ /* #define DEBUG_CAPTURE */ +/* #define DEBUG_POLL */ #define SW_NAME(sw) (sw)->name ? (sw)->name : "unknown" @@ -64,6 +65,8 @@ static struct { } period; int plive; int log_to_monitor; + int try_poll_in; + int try_poll_out; } conf = { .fixed_out = { /* DAC fixed settings */ .enabled = 1, @@ -92,6 +95,8 @@ static struct { .period = { .hertz = 250 }, .plive = 0, .log_to_monitor = 0, + .try_poll_in = 1, + .try_poll_out = 1, }; static AudioState glob_audio_state; @@ -107,23 +112,6 @@ struct mixeng_volume nominal_volume = { #endif }; -/* http://www.df.lth.se/~john_e/gems/gem002d.html */ -/* http://www.multi-platforms.com/Tips/PopCount.htm */ -uint32_t popcount (uint32_t u) -{ - u = ((u&0x55555555) + ((u>>1)&0x55555555)); - u = ((u&0x33333333) + ((u>>2)&0x33333333)); - u = ((u&0x0f0f0f0f) + ((u>>4)&0x0f0f0f0f)); - u = ((u&0x00ff00ff) + ((u>>8)&0x00ff00ff)); - u = ( u&0x0000ffff) + (u>>16); - return u; -} - -inline uint32_t lsbindex (uint32_t u) -{ - return popcount ((u&-u)-1); -} - #ifdef AUDIO_IS_FLAWLESS_AND_NO_CHECKS_ARE_REQURIED #error No its not #else @@ -778,8 +766,8 @@ static void audio_detach_capture (HWVoiceOut *hw) sw->rate = NULL; } - LIST_REMOVE (sw, entries); - LIST_REMOVE (sc, entries); + QLIST_REMOVE (sw, entries); + QLIST_REMOVE (sc, entries); qemu_free (sc); if (was_active) { /* We have removed soft voice from the capture: @@ -823,8 +811,8 @@ static int audio_attach_capture (HWVoiceOut *hw) qemu_free (sw); return -1; } - LIST_INSERT_HEAD (&hw_cap->sw_head, sw, entries); - LIST_INSERT_HEAD (&hw->cap_head, sc, entries); + QLIST_INSERT_HEAD (&hw_cap->sw_head, sw, entries); + QLIST_INSERT_HEAD (&hw->cap_head, sc, entries); #ifdef DEBUG_CAPTURE asprintf (&sw->name, "for %p %d,%d,%d", hw, sw->info.freq, sw->info.bits, sw->info.nchannels); @@ -1082,6 +1070,47 @@ static void audio_pcm_print_info (const char *cap, struct audio_pcm_info *info) #undef DAC #include "audio_template.h" +/* + * Timer + */ +static void audio_timer (void *opaque) +{ + AudioState *s = opaque; + + audio_run ("timer"); + qemu_mod_timer (s->ts, qemu_get_clock (vm_clock) + conf.period.ticks); +} + + +static int audio_is_timer_needed (void) +{ + HWVoiceIn *hwi = NULL; + HWVoiceOut *hwo = NULL; + + while ((hwo = audio_pcm_hw_find_any_enabled_out (hwo))) { + if (!hwo->poll_mode) return 1; + } + while ((hwi = audio_pcm_hw_find_any_enabled_in (hwi))) { + if (!hwi->poll_mode) return 1; + } + return 0; +} + +static void audio_reset_timer (void) +{ + AudioState *s = &glob_audio_state; + + if (audio_is_timer_needed ()) { + qemu_mod_timer (s->ts, qemu_get_clock (vm_clock) + 1); + } + else { + qemu_del_timer (s->ts); + } +} + +/* + * Public API + */ int AUD_write (SWVoiceOut *sw, void *buf, int size) { int bytes; @@ -1142,7 +1171,8 @@ void AUD_set_active_out (SWVoiceOut *sw, int on) if (!hw->enabled) { hw->enabled = 1; if (s->vm_running) { - hw->pcm_ops->ctl_out (hw, VOICE_ENABLE); + hw->pcm_ops->ctl_out (hw, VOICE_ENABLE, conf.try_poll_out); + audio_reset_timer (); } } } @@ -1186,7 +1216,7 @@ void AUD_set_active_in (SWVoiceIn *sw, int on) if (!hw->enabled) { hw->enabled = 1; if (s->vm_running) { - hw->pcm_ops->ctl_in (hw, VOICE_ENABLE); + hw->pcm_ops->ctl_in (hw, VOICE_ENABLE, conf.try_poll_in); } } sw->total_hw_samples_acquired = hw->total_samples_captured; @@ -1480,15 +1510,29 @@ static void audio_run_capture (AudioState *s) } } -static void audio_timer (void *opaque) +void audio_run (const char *msg) { - AudioState *s = opaque; + AudioState *s = &glob_audio_state; audio_run_out (s); audio_run_in (s); audio_run_capture (s); +#ifdef DEBUG_POLL + { + static double prevtime; + double currtime; + struct timeval tv; - qemu_mod_timer (s->ts, qemu_get_clock (vm_clock) + conf.period.ticks); + if (gettimeofday (&tv, NULL)) { + perror ("audio_run: gettimeofday"); + return; + } + + currtime = tv.tv_sec + tv.tv_usec * 1e-6; + dolog ("Elapsed since last %s: %f\n", msg, currtime - prevtime); + prevtime = currtime; + } +#endif } static struct audio_option audio_options[] = { @@ -1523,6 +1567,12 @@ static struct audio_option audio_options[] = { .valp = &conf.fixed_out.nb_voices, .descr = "Number of voices for DAC" }, + { + .name = "DAC_TRY_POLL", + .tag = AUD_OPT_BOOL, + .valp = &conf.try_poll_out, + .descr = "Attempt using poll mode for DAC" + }, /* ADC */ { .name = "ADC_FIXED_SETTINGS", @@ -1554,6 +1604,12 @@ static struct audio_option audio_options[] = { .valp = &conf.fixed_in.nb_voices, .descr = "Number of voices for ADC" }, + { + .name = "ADC_TRY_POLL", + .tag = AUD_OPT_BOOL, + .valp = &conf.try_poll_out, + .descr = "Attempt using poll mode for ADC" + }, /* Misc */ { .name = "TIMER_PERIOD", @@ -1571,7 +1627,7 @@ static struct audio_option audio_options[] = { .name = "LOG_TO_MONITOR", .tag = AUD_OPT_BOOL, .valp = &conf.log_to_monitor, - .descr = "print logging messages to monitor instead of stderr" + .descr = "Print logging messages to monitor instead of stderr" }, { /* End of list */ } }; @@ -1676,12 +1732,13 @@ static void audio_vm_change_state_handler (void *opaque, int running, s->vm_running = running; while ((hwo = audio_pcm_hw_find_any_enabled_out (hwo))) { - hwo->pcm_ops->ctl_out (hwo, op); + hwo->pcm_ops->ctl_out (hwo, op, conf.try_poll_out); } while ((hwi = audio_pcm_hw_find_any_enabled_in (hwi))) { - hwi->pcm_ops->ctl_in (hwi, op); + hwi->pcm_ops->ctl_in (hwi, op, conf.try_poll_in); } + audio_reset_timer (); } static void audio_atexit (void) @@ -1739,15 +1796,16 @@ static void audio_init (void) size_t i; int done = 0; const char *drvname; + VMChangeStateEntry *e; AudioState *s = &glob_audio_state; if (s->drv) { return; } - LIST_INIT (&s->hw_head_out); - LIST_INIT (&s->hw_head_in); - LIST_INIT (&s->cap_head); + QLIST_INIT (&s->hw_head_out); + QLIST_INIT (&s->hw_head_in); + QLIST_INIT (&s->cap_head); atexit (audio_atexit); s->ts = qemu_new_timer (vm_clock, audio_timer, s); @@ -1812,8 +1870,6 @@ static void audio_init (void) } } - VMChangeStateEntry *e; - if (conf.period.hertz <= 0) { if (conf.period.hertz < 0) { dolog ("warning: Timer period is negative - %d " @@ -1831,9 +1887,8 @@ static void audio_init (void) "(Audio can continue looping even after stopping the VM)\n"); } - LIST_INIT (&s->card_head); + QLIST_INIT (&s->card_head); register_savevm ("audio", 0, 1, audio_save, audio_load, s); - qemu_mod_timer (s->ts, qemu_get_clock (vm_clock) + conf.period.ticks); } void AUD_register_card (const char *name, QEMUSoundCard *card) @@ -1841,12 +1896,12 @@ void AUD_register_card (const char *name, QEMUSoundCard *card) audio_init (); card->name = qemu_strdup (name); memset (&card->entries, 0, sizeof (card->entries)); - LIST_INSERT_HEAD (&glob_audio_state.card_head, card, entries); + QLIST_INSERT_HEAD (&glob_audio_state.card_head, card, entries); } void AUD_remove_card (QEMUSoundCard *card) { - LIST_REMOVE (card, entries); + QLIST_REMOVE (card, entries); qemu_free (card->name); } @@ -1878,7 +1933,7 @@ CaptureVoiceOut *AUD_add_capture ( cap = audio_pcm_capture_find_specific (as); if (cap) { - LIST_INSERT_HEAD (&cap->cb_head, cb, entries); + QLIST_INSERT_HEAD (&cap->cb_head, cb, entries); return cap; } else { @@ -1893,8 +1948,8 @@ CaptureVoiceOut *AUD_add_capture ( } hw = &cap->hw; - LIST_INIT (&hw->sw_head); - LIST_INIT (&cap->cb_head); + QLIST_INIT (&hw->sw_head); + QLIST_INIT (&cap->cb_head); /* XXX find a more elegant way */ hw->samples = 4096 * 4; @@ -1922,8 +1977,8 @@ CaptureVoiceOut *AUD_add_capture ( [hw->info.swap_endianness] [audio_bits_to_index (hw->info.bits)]; - LIST_INSERT_HEAD (&s->cap_head, cap, entries); - LIST_INSERT_HEAD (&cap->cb_head, cb, entries); + QLIST_INSERT_HEAD (&s->cap_head, cap, entries); + QLIST_INSERT_HEAD (&cap->cb_head, cb, entries); hw = NULL; while ((hw = audio_pcm_hw_find_any_out (hw))) { @@ -1949,7 +2004,7 @@ void AUD_del_capture (CaptureVoiceOut *cap, void *cb_opaque) for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { if (cb->opaque == cb_opaque) { cb->ops.destroy (cb_opaque); - LIST_REMOVE (cb, entries); + QLIST_REMOVE (cb, entries); qemu_free (cb); if (!cap->cb_head.lh_first) { @@ -1966,12 +2021,12 @@ void AUD_del_capture (CaptureVoiceOut *cap, void *cb_opaque) st_rate_stop (sw->rate); sw->rate = NULL; } - LIST_REMOVE (sw, entries); - LIST_REMOVE (sc, entries); + QLIST_REMOVE (sw, entries); + QLIST_REMOVE (sc, entries); qemu_free (sc); sw = sw1; } - LIST_REMOVE (cap, entries); + QLIST_REMOVE (cap, entries); qemu_free (cap); } return; diff --git a/audio/audio.h b/audio/audio.h index fda2af342..f234ad0f5 100644 --- a/audio/audio.h +++ b/audio/audio.h @@ -25,7 +25,7 @@ #define QEMU_AUDIO_H #include "config-host.h" -#include "sys-queue.h" +#include "qemu-queue.h" typedef void (*audio_callback_fn_t) (void *opaque, int avail); @@ -70,7 +70,7 @@ struct capture_ops { typedef struct CaptureState { void *opaque; struct capture_ops ops; - LIST_ENTRY (CaptureState) entries; + QLIST_ENTRY (CaptureState) entries; } CaptureState; typedef struct SWVoiceOut SWVoiceOut; @@ -79,7 +79,7 @@ typedef struct SWVoiceIn SWVoiceIn; typedef struct QEMUSoundCard { char *name; - LIST_ENTRY (QEMUSoundCard) entries; + QLIST_ENTRY (QEMUSoundCard) entries; } QEMUSoundCard; typedef struct QEMUAudioTimeStamp { @@ -147,9 +147,6 @@ static inline void *advance (void *p, int incr) return (d + incr); } -uint32_t popcount (uint32_t u); -uint32_t lsbindex (uint32_t u); - #ifdef __GNUC__ #define audio_MIN(a, b) ( __extension__ ({ \ __typeof (a) ta = a; \ diff --git a/audio/audio_int.h b/audio/audio_int.h index f3cd0be0a..ce791ee46 100644 --- a/audio/audio_int.h +++ b/audio/audio_int.h @@ -68,6 +68,7 @@ typedef struct SWVoiceCap SWVoiceCap; typedef struct HWVoiceOut { int enabled; + int poll_mode; int pending_disable; struct audio_pcm_info info; @@ -79,14 +80,15 @@ typedef struct HWVoiceOut { struct st_sample *mix_buf; int samples; - LIST_HEAD (sw_out_listhead, SWVoiceOut) sw_head; - LIST_HEAD (sw_cap_listhead, SWVoiceCap) cap_head; + QLIST_HEAD (sw_out_listhead, SWVoiceOut) sw_head; + QLIST_HEAD (sw_cap_listhead, SWVoiceCap) cap_head; struct audio_pcm_ops *pcm_ops; - LIST_ENTRY (HWVoiceOut) entries; + QLIST_ENTRY (HWVoiceOut) entries; } HWVoiceOut; typedef struct HWVoiceIn { int enabled; + int poll_mode; struct audio_pcm_info info; t_sample *conv; @@ -98,9 +100,9 @@ typedef struct HWVoiceIn { struct st_sample *conv_buf; int samples; - LIST_HEAD (sw_in_listhead, SWVoiceIn) sw_head; + QLIST_HEAD (sw_in_listhead, SWVoiceIn) sw_head; struct audio_pcm_ops *pcm_ops; - LIST_ENTRY (HWVoiceIn) entries; + QLIST_ENTRY (HWVoiceIn) entries; } HWVoiceIn; struct SWVoiceOut { @@ -117,7 +119,7 @@ struct SWVoiceOut { char *name; struct mixeng_volume vol; struct audio_callback callback; - LIST_ENTRY (SWVoiceOut) entries; + QLIST_ENTRY (SWVoiceOut) entries; }; struct SWVoiceIn { @@ -133,7 +135,7 @@ struct SWVoiceIn { char *name; struct mixeng_volume vol; struct audio_callback callback; - LIST_ENTRY (SWVoiceIn) entries; + QLIST_ENTRY (SWVoiceIn) entries; }; struct audio_driver { @@ -167,20 +169,20 @@ struct audio_pcm_ops { struct capture_callback { struct audio_capture_ops ops; void *opaque; - LIST_ENTRY (capture_callback) entries; + QLIST_ENTRY (capture_callback) entries; }; struct CaptureVoiceOut { HWVoiceOut hw; void *buf; - LIST_HEAD (cb_listhead, capture_callback) cb_head; - LIST_ENTRY (CaptureVoiceOut) entries; + QLIST_HEAD (cb_listhead, capture_callback) cb_head; + QLIST_ENTRY (CaptureVoiceOut) entries; }; struct SWVoiceCap { SWVoiceOut sw; CaptureVoiceOut *cap; - LIST_ENTRY (SWVoiceCap) entries; + QLIST_ENTRY (SWVoiceCap) entries; }; struct AudioState { @@ -188,10 +190,10 @@ struct AudioState { void *drv_opaque; QEMUTimer *ts; - LIST_HEAD (card_listhead, QEMUSoundCard) card_head; - LIST_HEAD (hw_in_listhead, HWVoiceIn) hw_head_in; - LIST_HEAD (hw_out_listhead, HWVoiceOut) hw_head_out; - LIST_HEAD (cap_listhead, CaptureVoiceOut) cap_head; + QLIST_HEAD (card_listhead, QEMUSoundCard) card_head; + QLIST_HEAD (hw_in_listhead, HWVoiceIn) hw_head_in; + QLIST_HEAD (hw_out_listhead, HWVoiceOut) hw_head_out; + QLIST_HEAD (cap_listhead, CaptureVoiceOut) cap_head; int nb_hw_voices_out; int nb_hw_voices_in; int vm_running; @@ -222,6 +224,8 @@ int audio_pcm_hw_get_live_out2 (HWVoiceOut *hw, int *nb_live); int audio_bug (const char *funcname, int cond); void *audio_calloc (const char *funcname, int nmemb, size_t size); +void audio_run (const char *msg); + #define VOICE_ENABLE 1 #define VOICE_DISABLE 2 diff --git a/audio/audio_template.h b/audio/audio_template.h index 0ffca652f..e65d834ac 100644 --- a/audio/audio_template.h +++ b/audio/audio_template.h @@ -184,12 +184,12 @@ static void glue (audio_pcm_sw_fini_, TYPE) (SW *sw) static void glue (audio_pcm_hw_add_sw_, TYPE) (HW *hw, SW *sw) { - LIST_INSERT_HEAD (&hw->sw_head, sw, entries); + QLIST_INSERT_HEAD (&hw->sw_head, sw, entries); } static void glue (audio_pcm_hw_del_sw_, TYPE) (SW *sw) { - LIST_REMOVE (sw, entries); + QLIST_REMOVE (sw, entries); } static void glue (audio_pcm_hw_gc_, TYPE) (HW **hwp) @@ -201,7 +201,7 @@ static void glue (audio_pcm_hw_gc_, TYPE) (HW **hwp) #ifdef DAC audio_detach_capture (hw); #endif - LIST_REMOVE (hw, entries); + QLIST_REMOVE (hw, entries); glue (s->nb_hw_voices_, TYPE) += 1; glue (audio_pcm_hw_free_resources_ ,TYPE) (hw); glue (hw->pcm_ops->fini_, TYPE) (hw); @@ -267,9 +267,9 @@ static HW *glue (audio_pcm_hw_add_new_, TYPE) (struct audsettings *as) } hw->pcm_ops = drv->pcm_ops; - LIST_INIT (&hw->sw_head); + QLIST_INIT (&hw->sw_head); #ifdef DAC - LIST_INIT (&hw->cap_head); + QLIST_INIT (&hw->cap_head); #endif if (glue (hw->pcm_ops->init_, TYPE) (hw, as)) { goto err0; @@ -294,7 +294,7 @@ static HW *glue (audio_pcm_hw_add_new_, TYPE) (struct audsettings *as) goto err1; } - LIST_INSERT_HEAD (&s->glue (hw_head_, TYPE), hw, entries); + QLIST_INSERT_HEAD (&s->glue (hw_head_, TYPE), hw, entries); glue (s->nb_hw_voices_, TYPE) -= 1; #ifdef DAC audio_attach_capture (hw); diff --git a/audio/ossaudio.c b/audio/ossaudio.c index 18152b535..2cc3c6f5c 100644 --- a/audio/ossaudio.c +++ b/audio/ossaudio.c @@ -31,6 +31,8 @@ #include <sys/soundcard.h> #endif #include "qemu-common.h" +#include "host-utils.h" +#include "qemu-char.h" #include "audio.h" #define AUDIO_CAP "oss" @@ -114,9 +116,36 @@ static void oss_anal_close (int *fdp) if (err) { oss_logerr (errno, "Failed to close file(fd=%d)\n", *fdp); } + qemu_set_fd_handler (*fdp, NULL, NULL, NULL); *fdp = -1; } +static void oss_helper_poll_out (void *opaque) +{ + (void) opaque; + audio_run ("oss_poll_out"); +} + +static void oss_helper_poll_in (void *opaque) +{ + (void) opaque; + audio_run ("oss_poll_in"); +} + +static int oss_poll_out (HWVoiceOut *hw) +{ + OSSVoiceOut *oss = (OSSVoiceOut *) hw; + + return qemu_set_fd_handler (oss->fd, NULL, oss_helper_poll_out, NULL); +} + +static int oss_poll_in (HWVoiceIn *hw) +{ + OSSVoiceIn *oss = (OSSVoiceIn *) hw; + + return qemu_set_fd_handler (oss->fd, oss_helper_poll_in, NULL, NULL); +} + static int oss_write (SWVoiceOut *sw, void *buf, int len) { return audio_pcm_sw_write (sw, buf, len); @@ -205,13 +234,16 @@ static int oss_open (int in, struct oss_params *req, struct oss_params *obt, int *pfd) { int fd; + int oflags; int mmmmssss; audio_buf_info abinfo; int fmt, freq, nchannels; const char *dspname = in ? conf.devpath_in : conf.devpath_out; const char *typ = in ? "ADC" : "DAC"; - fd = open (dspname, (in ? O_RDONLY : O_WRONLY) | O_NONBLOCK); + /* Kludge needed to have working mmap on Linux */ + oflags = conf.try_mmap ? O_RDWR : (in ? O_RDONLY : O_WRONLY); + fd = open (dspname, oflags | O_NONBLOCK); if (-1 == fd) { oss_logerr2 (errno, typ, "Failed to open `%s'\n", dspname); return -1; @@ -242,7 +274,7 @@ static int oss_open (int in, struct oss_params *req, goto err; } - mmmmssss = (req->nfrags << 16) | lsbindex (req->fragsize); + mmmmssss = (req->nfrags << 16) | ctz32 (req->fragsize); if (ioctl (fd, SNDCTL_DSP_SETFRAGMENT, &mmmmssss)) { oss_logerr2 (errno, typ, "Failed to set buffer length (%d, %d)\n", req->nfrags, req->fragsize); @@ -544,15 +576,26 @@ static int oss_init_out (HWVoiceOut *hw, struct audsettings *as) static int oss_ctl_out (HWVoiceOut *hw, int cmd, ...) { int trig; + va_list ap; + int poll_mode; OSSVoiceOut *oss = (OSSVoiceOut *) hw; - if (!oss->mmapped) { - return 0; - } + va_start (ap, cmd); + poll_mode = va_arg (ap, int); + va_end (ap); switch (cmd) { case VOICE_ENABLE: ldebug ("enabling voice\n"); + if (poll_mode && oss_poll_out (hw)) { + poll_mode = 0; + } + hw->poll_mode = poll_mode; + + if (!oss->mmapped) { + return 0; + } + audio_pcm_info_clear_buf (&hw->info, oss->pcm_buf, hw->samples); trig = PCM_ENABLE_OUTPUT; if (ioctl (oss->fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) { @@ -565,6 +608,15 @@ static int oss_ctl_out (HWVoiceOut *hw, int cmd, ...) break; case VOICE_DISABLE: + if (hw->poll_mode) { + qemu_set_fd_handler (oss->fd, NULL, NULL, NULL); + hw->poll_mode = 0; + } + + if (!oss->mmapped) { + return 0; + } + ldebug ("disabling voice\n"); trig = 0; if (ioctl (oss->fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) { @@ -720,8 +772,29 @@ static int oss_read (SWVoiceIn *sw, void *buf, int size) static int oss_ctl_in (HWVoiceIn *hw, int cmd, ...) { - (void) hw; - (void) cmd; + va_list ap; + int poll_mode; + OSSVoiceIn *oss = (OSSVoiceIn *) hw; + + va_start (ap, cmd); + poll_mode = va_arg (ap, int); + va_end (ap); + + switch (cmd) { + case VOICE_ENABLE: + if (poll_mode && oss_poll_in (hw)) { + poll_mode = 0; + } + hw->poll_mode = poll_mode; + break; + + case VOICE_DISABLE: + if (hw->poll_mode) { + hw->poll_mode = 0; + qemu_set_fd_handler (oss->fd, NULL, NULL, NULL); + } + break; + } return 0; } @@ -22,11 +22,6 @@ * THE SOFTWARE. */ #include "config-host.h" -#ifdef CONFIG_BSD -/* include native header before sys-queue.h */ -#include <sys/queue.h> -#endif - #include "qemu-common.h" #include "monitor.h" #include "block_int.h" @@ -36,6 +31,7 @@ #include <sys/types.h> #include <sys/stat.h> #include <sys/ioctl.h> +#include <sys/queue.h> #ifndef __DragonFly__ #include <sys/disk.h> #endif diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c index d4631c397..54e505cbe 100644 --- a/block/qcow2-cluster.c +++ b/block/qcow2-cluster.c @@ -738,7 +738,7 @@ uint64_t qcow2_alloc_cluster_offset(BlockDriverState *bs, * the same cluster. In this case we need to wait until the previous * request has completed and updated the L2 table accordingly. */ - LIST_FOREACH(old_alloc, &s->cluster_allocs, next_in_flight) { + QLIST_FOREACH(old_alloc, &s->cluster_allocs, next_in_flight) { uint64_t end_offset = offset + nb_clusters * s->cluster_size; uint64_t old_offset = old_alloc->offset; @@ -769,7 +769,7 @@ uint64_t qcow2_alloc_cluster_offset(BlockDriverState *bs, abort(); } - LIST_INSERT_HEAD(&s->cluster_allocs, m, next_in_flight); + QLIST_INSERT_HEAD(&s->cluster_allocs, m, next_in_flight); /* allocate a new cluster */ diff --git a/block/qcow2.c b/block/qcow2.c index 8579e0150..a9e768268 100644 --- a/block/qcow2.c +++ b/block/qcow2.c @@ -219,7 +219,7 @@ static int qcow_open(BlockDriverState *bs, const char *filename, int flags) if (qcow2_refcount_init(bs) < 0) goto fail; - LIST_INIT(&s->cluster_allocs); + QLIST_INIT(&s->cluster_allocs); /* read qcow2 extensions */ if (header.backing_file_offset) @@ -340,7 +340,7 @@ typedef struct QCowAIOCB { QEMUIOVector hd_qiov; QEMUBH *bh; QCowL2Meta l2meta; - LIST_ENTRY(QCowAIOCB) next_depend; + QLIST_ENTRY(QCowAIOCB) next_depend; } QCowAIOCB; static void qcow_aio_cancel(BlockDriverAIOCB *blockacb) @@ -503,7 +503,7 @@ static QCowAIOCB *qcow_aio_setup(BlockDriverState *bs, acb->n = 0; acb->cluster_offset = 0; acb->l2meta.nb_clusters = 0; - LIST_INIT(&acb->l2meta.dependent_requests); + QLIST_INIT(&acb->l2meta.dependent_requests); return acb; } @@ -530,12 +530,12 @@ static void run_dependent_requests(QCowL2Meta *m) /* Take the request off the list of running requests */ if (m->nb_clusters != 0) { - LIST_REMOVE(m, next_in_flight); + QLIST_REMOVE(m, next_in_flight); } /* * Restart all dependent requests. - * Can't use LIST_FOREACH here - the next link might not be the same + * Can't use QLIST_FOREACH here - the next link might not be the same * any more after the callback (request could depend on a different * request now) */ @@ -545,7 +545,7 @@ static void run_dependent_requests(QCowL2Meta *m) } /* Empty the list for the next part of the request */ - LIST_INIT(&m->dependent_requests); + QLIST_INIT(&m->dependent_requests); } static void qcow_aio_write_cb(void *opaque, int ret) @@ -590,7 +590,7 @@ static void qcow_aio_write_cb(void *opaque, int ret) /* Need to wait for another request? If so, we are done for now. */ if (!acb->cluster_offset && acb->l2meta.depends_on != NULL) { - LIST_INSERT_HEAD(&acb->l2meta.depends_on->dependent_requests, + QLIST_INSERT_HEAD(&acb->l2meta.depends_on->dependent_requests, acb, next_depend); return; } @@ -690,7 +690,7 @@ static int preallocate(BlockDriverState *bs) nb_sectors = bdrv_getlength(bs) >> 9; offset = 0; - LIST_INIT(&meta.dependent_requests); + QLIST_INIT(&meta.dependent_requests); while (nb_sectors) { num = MIN(nb_sectors, INT_MAX >> 9); diff --git a/block/qcow2.h b/block/qcow2.h index 965a2f45c..ecc94cbfa 100644 --- a/block/qcow2.h +++ b/block/qcow2.h @@ -98,7 +98,7 @@ typedef struct BDRVQcowState { uint8_t *cluster_cache; uint8_t *cluster_data; uint64_t cluster_cache_offset; - LIST_HEAD(QCowClusterAlloc, QCowL2Meta) cluster_allocs; + QLIST_HEAD(QCowClusterAlloc, QCowL2Meta) cluster_allocs; uint64_t *refcount_table; uint64_t refcount_table_offset; @@ -139,9 +139,9 @@ typedef struct QCowL2Meta int nb_available; int nb_clusters; struct QCowL2Meta *depends_on; - LIST_HEAD(QCowAioDependencies, QCowAIOCB) dependent_requests; + QLIST_HEAD(QCowAioDependencies, QCowAIOCB) dependent_requests; - LIST_ENTRY(QCowL2Meta) next_in_flight; + QLIST_ENTRY(QCowL2Meta) next_in_flight; } QCowL2Meta; static inline int size_to_clusters(BDRVQcowState *s, int64_t size) diff --git a/check-qdict.c b/check-qdict.c index 19989d65a..c37d44822 100644 --- a/check-qdict.c +++ b/check-qdict.c @@ -47,7 +47,7 @@ START_TEST(qdict_put_obj_test) qdict_put_obj(qdict, "", QOBJECT(qint_from_int(num))); fail_unless(qdict_size(qdict) == 1); - ent = LIST_FIRST(&qdict->table[12345 % QDICT_HASH_SIZE]); + ent = QLIST_FIRST(&qdict->table[12345 % QDICT_HASH_SIZE]); qi = qobject_to_qint(ent->value); fail_unless(qint_get_int(qi) == num); diff --git a/cpu-defs.h b/cpu-defs.h index b7a6d8cb2..1f482678d 100644 --- a/cpu-defs.h +++ b/cpu-defs.h @@ -29,7 +29,7 @@ #include <signal.h> #include <pthread.h> #include "osdep.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "targphys.h" #ifndef TARGET_LONG_BITS @@ -125,14 +125,14 @@ struct KVMState; typedef struct CPUBreakpoint { target_ulong pc; int flags; /* BP_* */ - TAILQ_ENTRY(CPUBreakpoint) entry; + QTAILQ_ENTRY(CPUBreakpoint) entry; } CPUBreakpoint; typedef struct CPUWatchpoint { target_ulong vaddr; target_ulong len_mask; int flags; /* BP_* */ - TAILQ_ENTRY(CPUWatchpoint) entry; + QTAILQ_ENTRY(CPUWatchpoint) entry; } CPUWatchpoint; /* forward decleration */ @@ -179,10 +179,10 @@ struct KVMCPUState { \ /* from this point: preserved by CPU reset */ \ /* ice debug support */ \ - TAILQ_HEAD(breakpoints_head, CPUBreakpoint) breakpoints; \ + QTAILQ_HEAD(breakpoints_head, CPUBreakpoint) breakpoints; \ int singlestep_enabled; \ \ - TAILQ_HEAD(watchpoints_head, CPUWatchpoint) watchpoints; \ + QTAILQ_HEAD(watchpoints_head, CPUWatchpoint) watchpoints; \ CPUWatchpoint *watchpoint_hit; \ \ struct GDBRegisterState *gdb_regs; \ diff --git a/cpu-exec.c b/cpu-exec.c index 14f207491..8550617af 100644 --- a/cpu-exec.c +++ b/cpu-exec.c @@ -206,7 +206,7 @@ static void cpu_handle_debug_exception(CPUState *env) CPUWatchpoint *wp; if (!env->watchpoint_hit) - TAILQ_FOREACH(wp, &env->watchpoints, entry) + QTAILQ_FOREACH(wp, &env->watchpoints, entry) wp->flags &= ~BP_WATCHPOINT_HIT; if (debug_excp_handler) @@ -1,20 +1,19 @@ -#include <sys/queue.h> - #include <assert.h> #include <errno.h> #include <stdlib.h> #include <string.h> #include <unistd.h> +#include "qemu-queue.h" #include "envlist.h" struct envlist_entry { const char *ev_var; /* actual env value */ - LIST_ENTRY(envlist_entry) ev_link; + QLIST_ENTRY(envlist_entry) ev_link; }; struct envlist { - LIST_HEAD(, envlist_entry) el_entries; /* actual entries */ + QLIST_HEAD(, envlist_entry) el_entries; /* actual entries */ size_t el_count; /* number of entries */ }; @@ -33,7 +32,7 @@ envlist_create(void) if ((envlist = malloc(sizeof (*envlist))) == NULL) return (NULL); - LIST_INIT(&envlist->el_entries); + QLIST_INIT(&envlist->el_entries); envlist->el_count = 0; return (envlist); @@ -51,7 +50,7 @@ envlist_free(envlist_t *envlist) while (envlist->el_entries.lh_first != NULL) { entry = envlist->el_entries.lh_first; - LIST_REMOVE(entry, ev_link); + QLIST_REMOVE(entry, ev_link); free((char *)entry->ev_var); free(entry); @@ -159,7 +158,7 @@ envlist_setenv(envlist_t *envlist, const char *env) } if (entry != NULL) { - LIST_REMOVE(entry, ev_link); + QLIST_REMOVE(entry, ev_link); free((char *)entry->ev_var); free(entry); } else { @@ -172,7 +171,7 @@ envlist_setenv(envlist_t *envlist, const char *env) free(entry); return (errno); } - LIST_INSERT_HEAD(&envlist->el_entries, entry, ev_link); + QLIST_INSERT_HEAD(&envlist->el_entries, entry, ev_link); return (0); } @@ -205,7 +204,7 @@ envlist_unsetenv(envlist_t *envlist, const char *env) break; } if (entry != NULL) { - LIST_REMOVE(entry, ev_link); + QLIST_REMOVE(entry, ev_link); free((char *)entry->ev_var); free(entry); @@ -598,8 +598,8 @@ void cpu_exec_init(CPUState *env) } env->cpu_index = cpu_index; env->numa_node = 0; - TAILQ_INIT(&env->breakpoints); - TAILQ_INIT(&env->watchpoints); + QTAILQ_INIT(&env->breakpoints); + QTAILQ_INIT(&env->watchpoints); #ifdef __WIN32 env->thread_id = GetCurrentProcessId(); #else @@ -1365,9 +1365,9 @@ int cpu_watchpoint_insert(CPUState *env, target_ulong addr, target_ulong len, /* keep all GDB-injected watchpoints in front */ if (flags & BP_GDB) - TAILQ_INSERT_HEAD(&env->watchpoints, wp, entry); + QTAILQ_INSERT_HEAD(&env->watchpoints, wp, entry); else - TAILQ_INSERT_TAIL(&env->watchpoints, wp, entry); + QTAILQ_INSERT_TAIL(&env->watchpoints, wp, entry); tlb_flush_page(env, addr); @@ -1383,7 +1383,7 @@ int cpu_watchpoint_remove(CPUState *env, target_ulong addr, target_ulong len, target_ulong len_mask = ~(len - 1); CPUWatchpoint *wp; - TAILQ_FOREACH(wp, &env->watchpoints, entry) { + QTAILQ_FOREACH(wp, &env->watchpoints, entry) { if (addr == wp->vaddr && len_mask == wp->len_mask && flags == (wp->flags & ~BP_WATCHPOINT_HIT)) { cpu_watchpoint_remove_by_ref(env, wp); @@ -1396,7 +1396,7 @@ int cpu_watchpoint_remove(CPUState *env, target_ulong addr, target_ulong len, /* Remove a specific watchpoint by reference. */ void cpu_watchpoint_remove_by_ref(CPUState *env, CPUWatchpoint *watchpoint) { - TAILQ_REMOVE(&env->watchpoints, watchpoint, entry); + QTAILQ_REMOVE(&env->watchpoints, watchpoint, entry); tlb_flush_page(env, watchpoint->vaddr); @@ -1408,7 +1408,7 @@ void cpu_watchpoint_remove_all(CPUState *env, int mask) { CPUWatchpoint *wp, *next; - TAILQ_FOREACH_SAFE(wp, &env->watchpoints, entry, next) { + QTAILQ_FOREACH_SAFE(wp, &env->watchpoints, entry, next) { if (wp->flags & mask) cpu_watchpoint_remove_by_ref(env, wp); } @@ -1428,9 +1428,9 @@ int cpu_breakpoint_insert(CPUState *env, target_ulong pc, int flags, /* keep all GDB-injected breakpoints in front */ if (flags & BP_GDB) - TAILQ_INSERT_HEAD(&env->breakpoints, bp, entry); + QTAILQ_INSERT_HEAD(&env->breakpoints, bp, entry); else - TAILQ_INSERT_TAIL(&env->breakpoints, bp, entry); + QTAILQ_INSERT_TAIL(&env->breakpoints, bp, entry); breakpoint_invalidate(env, pc); @@ -1448,7 +1448,7 @@ int cpu_breakpoint_remove(CPUState *env, target_ulong pc, int flags) #if defined(TARGET_HAS_ICE) CPUBreakpoint *bp; - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == pc && bp->flags == flags) { cpu_breakpoint_remove_by_ref(env, bp); return 0; @@ -1464,7 +1464,7 @@ int cpu_breakpoint_remove(CPUState *env, target_ulong pc, int flags) void cpu_breakpoint_remove_by_ref(CPUState *env, CPUBreakpoint *breakpoint) { #if defined(TARGET_HAS_ICE) - TAILQ_REMOVE(&env->breakpoints, breakpoint, entry); + QTAILQ_REMOVE(&env->breakpoints, breakpoint, entry); breakpoint_invalidate(env, breakpoint->pc); @@ -1478,7 +1478,7 @@ void cpu_breakpoint_remove_all(CPUState *env, int mask) #if defined(TARGET_HAS_ICE) CPUBreakpoint *bp, *next; - TAILQ_FOREACH_SAFE(bp, &env->breakpoints, entry, next) { + QTAILQ_FOREACH_SAFE(bp, &env->breakpoints, entry, next) { if (bp->flags & mask) cpu_breakpoint_remove_by_ref(env, bp); } @@ -1731,13 +1731,13 @@ CPUState *cpu_copy(CPUState *env) /* Clone all break/watchpoints. Note: Once we support ptrace with hw-debug register access, make sure BP_CPU break/watchpoints are handled correctly on clone. */ - TAILQ_INIT(&env->breakpoints); - TAILQ_INIT(&env->watchpoints); + QTAILQ_INIT(&env->breakpoints); + QTAILQ_INIT(&env->watchpoints); #if defined(TARGET_HAS_ICE) - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { cpu_breakpoint_insert(new_env, bp->pc, bp->flags, NULL); } - TAILQ_FOREACH(wp, &env->watchpoints, entry) { + QTAILQ_FOREACH(wp, &env->watchpoints, entry) { cpu_watchpoint_insert(new_env, wp->vaddr, (~wp->len_mask) + 1, wp->flags, NULL); } @@ -2027,7 +2027,7 @@ int tlb_set_page_exec(CPUState *env, target_ulong vaddr, code_address = address; /* Make accesses to pages with watchpoints go via the watchpoint trap routines. */ - TAILQ_FOREACH(wp, &env->watchpoints, entry) { + QTAILQ_FOREACH(wp, &env->watchpoints, entry) { if (vaddr == (wp->vaddr & TARGET_PAGE_MASK)) { iotlb = io_mem_watch + paddr; /* TODO: The memory case can be optimized by not trapping @@ -2791,7 +2791,7 @@ static void check_watchpoint(int offset, int len_mask, int flags) return; } vaddr = (env->mem_io_vaddr & TARGET_PAGE_MASK) + offset; - TAILQ_FOREACH(wp, &env->watchpoints, entry) { + QTAILQ_FOREACH(wp, &env->watchpoints, entry) { if ((vaddr == (wp->vaddr & len_mask) || (vaddr & wp->len_mask) == wp->vaddr) && (wp->flags & flags)) { wp->flags |= BP_WATCHPOINT_HIT; @@ -3302,11 +3302,11 @@ static BounceBuffer bounce; typedef struct MapClient { void *opaque; void (*callback)(void *opaque); - LIST_ENTRY(MapClient) link; + QLIST_ENTRY(MapClient) link; } MapClient; -static LIST_HEAD(map_client_list, MapClient) map_client_list - = LIST_HEAD_INITIALIZER(map_client_list); +static QLIST_HEAD(map_client_list, MapClient) map_client_list + = QLIST_HEAD_INITIALIZER(map_client_list); void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque)) { @@ -3314,7 +3314,7 @@ void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque)) client->opaque = opaque; client->callback = callback; - LIST_INSERT_HEAD(&map_client_list, client, link); + QLIST_INSERT_HEAD(&map_client_list, client, link); return client; } @@ -3322,7 +3322,7 @@ void cpu_unregister_map_client(void *_client) { MapClient *client = (MapClient *)_client; - LIST_REMOVE(client, link); + QLIST_REMOVE(client, link); qemu_free(client); } @@ -3330,8 +3330,8 @@ static void cpu_notify_map_clients(void) { MapClient *client; - while (!LIST_EMPTY(&map_client_list)) { - client = LIST_FIRST(&map_client_list); + while (!QLIST_EMPTY(&map_client_list)) { + client = QLIST_FIRST(&map_client_list); client->callback(client->opaque); cpu_unregister_map_client(client); } diff --git a/hw/device-assignment.c b/hw/device-assignment.c index 75db54625..46e6471fa 100644 --- a/hw/device-assignment.c +++ b/hw/device-assignment.c @@ -554,7 +554,7 @@ again: return 0; } -static LIST_HEAD(, AssignedDevInfo) adev_head; +static QLIST_HEAD(, AssignedDevInfo) adev_head; #ifdef KVM_CAP_IRQ_ROUTING static void free_dev_irq_entries(AssignedDevice *dev) @@ -614,7 +614,7 @@ static void free_assigned_device(AssignedDevInfo *adev) adev->assigned_dev = dev = NULL; } - LIST_REMOVE(adev, next); + QLIST_REMOVE(adev, next); qemu_free(adev); } @@ -735,7 +735,7 @@ AssignedDevInfo *get_assigned_device(int pcibus, int slot) AssignedDevice *assigned_dev = NULL; AssignedDevInfo *adev = NULL; - LIST_FOREACH(adev, &adev_head, next) { + QLIST_FOREACH(adev, &adev_head, next) { assigned_dev = adev->assigned_dev; if (pci_bus_num(assigned_dev->dev.bus) == pcibus && PCI_SLOT(assigned_dev->dev.devfn) == slot) @@ -752,9 +752,9 @@ void assigned_dev_update_irqs() { AssignedDevInfo *adev; - adev = LIST_FIRST(&adev_head); + adev = QLIST_FIRST(&adev_head); while (adev) { - AssignedDevInfo *next = LIST_NEXT(adev, next); + AssignedDevInfo *next = QLIST_NEXT(adev, next); int r; r = assign_irq(adev); @@ -1245,7 +1245,7 @@ AssignedDevInfo *add_assigned_device(const char *arg) adev->disable_iommu = 1; #endif - LIST_INSERT_HEAD(&adev_head, adev, next); + QLIST_INSERT_HEAD(&adev_head, adev, next); return adev; bad: fprintf(stderr, "pcidevice argument parse error; " @@ -1375,7 +1375,7 @@ ram_addr_t assigned_dev_load_option_roms(ram_addr_t rom_base_offset) ram_addr_t offset = rom_base_offset; AssignedDevInfo *adev; - LIST_FOREACH(adev, &adev_head, next) { + QLIST_FOREACH(adev, &adev_head, next) { int size, len; void *buf; FILE *fp; diff --git a/hw/device-assignment.h b/hw/device-assignment.h index 0be62f450..a7b34e8cf 100644 --- a/hw/device-assignment.h +++ b/hw/device-assignment.h @@ -30,7 +30,7 @@ #include <sys/mman.h> #include "qemu-common.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "pci.h" /* From include/linux/pci.h in the kernel sources */ @@ -104,7 +104,7 @@ struct AssignedDevInfo { int dev; int func; AssignedDevice *assigned_dev; - LIST_ENTRY(AssignedDevInfo) next; + QLIST_ENTRY(AssignedDevInfo) next; int disable_iommu; }; diff --git a/hw/device-hotplug.c b/hw/device-hotplug.c index fd4cc3fb5..69779caef 100644 --- a/hw/device-hotplug.c +++ b/hw/device-hotplug.c @@ -68,7 +68,7 @@ void destroy_bdrvs(dev_match_fn *match_fn, void *arg) DriveInfo *dinfo; struct BlockDriverState *bs; - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { bs = dinfo->bdrv; if (bs) { if (bs->private && match_fn(bs->private, arg)) { @@ -268,7 +268,6 @@ static int gus_initfn (ISADevice *dev) if (!s->voice) { AUD_remove_card (&s->card); - qemu_free (s); return -1; } @@ -76,7 +76,7 @@ int i2c_start_transfer(i2c_bus *bus, int address, int recv) DeviceState *qdev; i2c_slave *slave = NULL; - LIST_FOREACH(qdev, &bus->qbus.children, sibling) { + QLIST_FOREACH(qdev, &bus->qbus.children, sibling) { slave = I2C_SLAVE_FROM_QDEV(qdev); if (slave->address == address) break; diff --git a/hw/pci-hotplug.c b/hw/pci-hotplug.c index 26f640452..b8ea9ae1f 100644 --- a/hw/pci-hotplug.c +++ b/hw/pci-hotplug.c @@ -85,7 +85,7 @@ void drive_hot_add(Monitor *mon, const QDict *qdict) switch (type) { case IF_SCSI: success = 1; - scsibus = LIST_FIRST(&dev->qdev.child_bus); + scsibus = QLIST_FIRST(&dev->qdev.child_bus); scsi_bus_legacy_add_drive(DO_UPCAST(SCSIBus, qbus, scsibus), dinfo, dinfo->unit); break; @@ -101,7 +101,7 @@ DeviceState *qdev_create(BusState *bus, const char *name) qdev_prop_set_defaults(dev, dev->info->props); qdev_prop_set_defaults(dev, dev->parent_bus->info->props); qdev_prop_set_compat(dev); - LIST_INSERT_HEAD(&bus->children, dev, sibling); + QLIST_INSERT_HEAD(&bus->children, dev, sibling); return dev; } @@ -235,7 +235,7 @@ void qdev_free(DeviceState *dev) #endif if (dev->info->reset) qemu_unregister_reset(dev->info->reset, dev); - LIST_REMOVE(dev, sibling); + QLIST_REMOVE(dev, sibling); qemu_free(dev); } @@ -321,7 +321,7 @@ BusState *qdev_get_child_bus(DeviceState *dev, const char *name) { BusState *bus; - LIST_FOREACH(bus, &dev->child_bus, sibling) { + QLIST_FOREACH(bus, &dev->child_bus, sibling) { if (strcmp(name, bus->name) == 0) { return bus; } @@ -346,8 +346,8 @@ static BusState *qbus_find_recursive(BusState *bus, const char *name, return bus; } - LIST_FOREACH(dev, &bus->children, sibling) { - LIST_FOREACH(child, &dev->child_bus, sibling) { + QLIST_FOREACH(dev, &bus->children, sibling) { + QLIST_FOREACH(child, &dev->child_bus, sibling) { ret = qbus_find_recursive(child, name, info); if (ret) { return ret; @@ -365,7 +365,7 @@ static void qbus_list_bus(DeviceState *dev, char *dest, int len) pos += snprintf(dest+pos, len-pos,"child busses at \"%s\":", dev->id ? dev->id : dev->info->name); - LIST_FOREACH(child, &dev->child_bus, sibling) { + QLIST_FOREACH(child, &dev->child_bus, sibling) { pos += snprintf(dest+pos, len-pos, "%s\"%s\"", sep, child->name); sep = ", "; } @@ -379,7 +379,7 @@ static void qbus_list_dev(BusState *bus, char *dest, int len) pos += snprintf(dest+pos, len-pos, "devices at \"%s\":", bus->name); - LIST_FOREACH(dev, &bus->children, sibling) { + QLIST_FOREACH(dev, &bus->children, sibling) { pos += snprintf(dest+pos, len-pos, "%s\"%s\"", sep, dev->info->name); if (dev->id) @@ -392,7 +392,7 @@ static BusState *qbus_find_bus(DeviceState *dev, char *elem) { BusState *child; - LIST_FOREACH(child, &dev->child_bus, sibling) { + QLIST_FOREACH(child, &dev->child_bus, sibling) { if (strcmp(child->name, elem) == 0) { return child; } @@ -410,17 +410,17 @@ static DeviceState *qbus_find_dev(BusState *bus, char *elem) * (2) driver name * (3) driver alias, if present */ - LIST_FOREACH(dev, &bus->children, sibling) { + QLIST_FOREACH(dev, &bus->children, sibling) { if (dev->id && strcmp(dev->id, elem) == 0) { return dev; } } - LIST_FOREACH(dev, &bus->children, sibling) { + QLIST_FOREACH(dev, &bus->children, sibling) { if (strcmp(dev->info->name, elem) == 0) { return dev; } } - LIST_FOREACH(dev, &bus->children, sibling) { + QLIST_FOREACH(dev, &bus->children, sibling) { if (dev->info->alias && strcmp(dev->info->alias, elem) == 0) { return dev; } @@ -478,7 +478,7 @@ static BusState *qbus_find(const char *path) qemu_error("device has no child bus (%s)\n", path); return NULL; case 1: - return LIST_FIRST(&dev->child_bus); + return QLIST_FIRST(&dev->child_bus); default: qbus_list_bus(dev, msg, sizeof(msg)); qemu_error("device has multiple child busses (%s)\n%s\n", @@ -532,9 +532,9 @@ BusState *qbus_create(BusInfo *info, DeviceState *parent, const char *name) bus->name = buf; } - LIST_INIT(&bus->children); + QLIST_INIT(&bus->children); if (parent) { - LIST_INSERT_HEAD(&parent->child_bus, bus, sibling); + QLIST_INSERT_HEAD(&parent->child_bus, bus, sibling); parent->num_child_bus++; } return bus; @@ -575,7 +575,7 @@ static void qdev_print(Monitor *mon, DeviceState *dev, int indent) qdev_print_props(mon, dev, dev->parent_bus->info->props, "bus", indent); if (dev->parent_bus->info->print_dev) dev->parent_bus->info->print_dev(mon, dev, indent); - LIST_FOREACH(child, &dev->child_bus, sibling) { + QLIST_FOREACH(child, &dev->child_bus, sibling) { qbus_print(mon, child, indent); } } @@ -587,7 +587,7 @@ static void qbus_print(Monitor *mon, BusState *bus, int indent) qdev_printf("bus: %s\n", bus->name); indent += 2; qdev_printf("type %s\n", bus->info->name); - LIST_FOREACH(dev, &bus->children, sibling) { + QLIST_FOREACH(dev, &bus->children, sibling) { qdev_print(mon, dev, indent); } } @@ -3,7 +3,7 @@ #include "hw.h" #include "sysemu.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "qemu-char.h" #include "qemu-option.h" @@ -29,10 +29,10 @@ struct DeviceState { qemu_irq *gpio_out; int num_gpio_in; qemu_irq *gpio_in; - LIST_HEAD(, BusState) child_bus; + QLIST_HEAD(, BusState) child_bus; int num_child_bus; NICInfo *nd; - LIST_ENTRY(DeviceState) sibling; + QLIST_ENTRY(DeviceState) sibling; }; typedef void (*bus_dev_printfn)(Monitor *mon, DeviceState *dev, int indent); @@ -47,8 +47,8 @@ struct BusState { DeviceState *parent; BusInfo *info; const char *name; - LIST_HEAD(, DeviceState) children; - LIST_ENTRY(BusState) sibling; + QLIST_HEAD(, DeviceState) children; + QLIST_ENTRY(BusState) sibling; }; struct Property { @@ -27,6 +27,7 @@ #include "isa.h" #include "qdev.h" #include "qemu-timer.h" +#include "host-utils.h" #define dolog(...) AUD_log ("sb16", __VA_ARGS__) @@ -1092,8 +1093,8 @@ static IO_WRITE_PROTO (mixer_write_datab) { int dma, hdma; - dma = lsbindex (val & 0xf); - hdma = lsbindex (val & 0xf0); + dma = ctz32 (val & 0xf); + hdma = ctz32 (val & 0xf0); if (dma != s->dma || hdma != s->hdma) { dolog ( "attempt to change DMA " @@ -25,8 +25,8 @@ static int ssi_slave_init(DeviceState *dev, DeviceInfo *base_info) SSIBus *bus; bus = FROM_QBUS(SSIBus, qdev_get_parent_bus(dev)); - if (LIST_FIRST(&bus->qbus.children) != dev - || LIST_NEXT(dev, sibling) != NULL) { + if (QLIST_FIRST(&bus->qbus.children) != dev + || QLIST_NEXT(dev, sibling) != NULL) { hw_error("Too many devices on SSI bus"); } @@ -61,7 +61,7 @@ uint32_t ssi_transfer(SSIBus *bus, uint32_t val) { DeviceState *dev; SSISlave *slave; - dev = LIST_FIRST(&bus->qbus.children); + dev = QLIST_FIRST(&bus->qbus.children); if (!dev) { return 0; } diff --git a/hw/usb-bus.c b/hw/usb-bus.c index 169fb2f58..03933f12f 100644 --- a/hw/usb-bus.c +++ b/hw/usb-bus.c @@ -12,7 +12,7 @@ static struct BusInfo usb_bus_info = { .print_dev = usb_bus_dev_print, }; static int next_usb_bus = 0; -static TAILQ_HEAD(, USBBus) busses = TAILQ_HEAD_INITIALIZER(busses); +static QTAILQ_HEAD(, USBBus) busses = QTAILQ_HEAD_INITIALIZER(busses); USBBus *usb_bus_new(DeviceState *host) { @@ -20,9 +20,9 @@ USBBus *usb_bus_new(DeviceState *host) bus = FROM_QBUS(USBBus, qbus_create(&usb_bus_info, host, NULL)); bus->busnr = next_usb_bus++; - TAILQ_INIT(&bus->free); - TAILQ_INIT(&bus->used); - TAILQ_INSERT_TAIL(&busses, bus, next); + QTAILQ_INIT(&bus->free); + QTAILQ_INIT(&bus->used); + QTAILQ_INSERT_TAIL(&busses, bus, next); return bus; } @@ -31,8 +31,8 @@ USBBus *usb_bus_find(int busnr) USBBus *bus; if (-1 == busnr) - return TAILQ_FIRST(&busses); - TAILQ_FOREACH(bus, &busses, next) { + return QTAILQ_FIRST(&busses); + QTAILQ_FOREACH(bus, &busses, next) { if (bus->busnr == busnr) return bus; } @@ -100,7 +100,7 @@ void usb_register_port(USBBus *bus, USBPort *port, void *opaque, int index, port->opaque = opaque; port->index = index; port->attach = attach; - TAILQ_INSERT_TAIL(&bus->free, port, next); + QTAILQ_INSERT_TAIL(&bus->free, port, next); bus->nfree++; } @@ -116,13 +116,13 @@ static void do_attach(USBDevice *dev) } dev->attached++; - port = TAILQ_FIRST(&bus->free); - TAILQ_REMOVE(&bus->free, port, next); + port = QTAILQ_FIRST(&bus->free); + QTAILQ_REMOVE(&bus->free, port, next); bus->nfree--; usb_attach(port, dev); - TAILQ_INSERT_TAIL(&bus->used, port, next); + QTAILQ_INSERT_TAIL(&bus->used, port, next); bus->nused++; } @@ -149,7 +149,7 @@ int usb_device_delete_addr(int busnr, int addr) if (!bus) return -1; - TAILQ_FOREACH(port, &bus->used, next) { + QTAILQ_FOREACH(port, &bus->used, next) { if (port->dev->addr == addr) break; } @@ -157,13 +157,13 @@ int usb_device_delete_addr(int busnr, int addr) return -1; dev = port->dev; - TAILQ_REMOVE(&bus->used, port, next); + QTAILQ_REMOVE(&bus->used, port, next); bus->nused--; usb_attach(port, NULL); dev->info->handle_destroy(dev); - TAILQ_INSERT_TAIL(&bus->free, port, next); + QTAILQ_INSERT_TAIL(&bus->free, port, next); bus->nfree++; return 0; } @@ -196,13 +196,13 @@ void usb_info(Monitor *mon) USBDevice *dev; USBPort *port; - if (TAILQ_EMPTY(&busses)) { + if (QTAILQ_EMPTY(&busses)) { monitor_printf(mon, "USB support not enabled\n"); return; } - TAILQ_FOREACH(bus, &busses, next) { - TAILQ_FOREACH(port, &bus->used, next) { + QTAILQ_FOREACH(bus, &busses, next) { + QTAILQ_FOREACH(port, &bus->used, next) { dev = port->dev; if (!dev) continue; diff --git a/hw/usb-net.c b/hw/usb-net.c index f19309ee1..b33e32927 100644 --- a/hw/usb-net.c +++ b/hw/usb-net.c @@ -26,7 +26,7 @@ #include "qemu-common.h" #include "usb.h" #include "net.h" -#include "sys-queue.h" +#include "qemu-queue.h" /*#define TRAFFIC_DEBUG*/ /* Thanks to NetChip Technologies for donating this product ID. @@ -595,7 +595,7 @@ static const uint32_t oid_supported_list[] = #define NDIS_MAC_OPTION_8021P_PRIORITY (1 << 6) struct rndis_response { - TAILQ_ENTRY(rndis_response) entries; + QTAILQ_ENTRY(rndis_response) entries; uint32_t length; uint8_t buf[0]; }; @@ -621,7 +621,7 @@ typedef struct USBNetState { char usbstring_mac[13]; VLANClientState *vc; - TAILQ_HEAD(rndis_resp_head, rndis_response) rndis_resp; + QTAILQ_HEAD(rndis_resp_head, rndis_response) rndis_resp; } USBNetState; static int ndis_query(USBNetState *s, uint32_t oid, @@ -812,7 +812,7 @@ static int rndis_get_response(USBNetState *s, uint8_t *buf) if (!r) return ret; - TAILQ_REMOVE(&s->rndis_resp, r, entries); + QTAILQ_REMOVE(&s->rndis_resp, r, entries); ret = r->length; memcpy(buf, r->buf, r->length); qemu_free(r); @@ -825,7 +825,7 @@ static void *rndis_queue_response(USBNetState *s, unsigned int length) struct rndis_response *r = qemu_mallocz(sizeof(struct rndis_response) + length); - TAILQ_INSERT_TAIL(&s->rndis_resp, r, entries); + QTAILQ_INSERT_TAIL(&s->rndis_resp, r, entries); r->length = length; return &r->buf[0]; @@ -836,7 +836,7 @@ static void rndis_clear_responsequeue(USBNetState *s) struct rndis_response *r; while ((r = s->rndis_resp.tqh_first)) { - TAILQ_REMOVE(&s->rndis_resp, r, entries); + QTAILQ_REMOVE(&s->rndis_resp, r, entries); qemu_free(r); } } @@ -1440,7 +1440,7 @@ static int usb_net_initfn(USBDevice *dev) s->rndis = 1; s->rndis_state = RNDIS_UNINITIALIZED; - TAILQ_INIT(&s->rndis_resp); + QTAILQ_INIT(&s->rndis_resp); s->medium = 0; /* NDIS_MEDIUM_802_3 */ s->speed = 1000000; /* 100MBps, in 100Bps units */ @@ -24,7 +24,7 @@ #include "block.h" #include "qdev.h" -#include "sys-queue.h" +#include "qemu-queue.h" #define USB_TOKEN_SETUP 0x2d #define USB_TOKEN_IN 0x69 /* device -> host */ @@ -193,7 +193,7 @@ struct USBPort { usb_attachfn attach; void *opaque; int index; /* internal port index, may be used with the opaque */ - TAILQ_ENTRY(USBPort) next; + QTAILQ_ENTRY(USBPort) next; }; typedef void USBCallback(USBPacket * packet, void *opaque); @@ -298,9 +298,9 @@ struct USBBus { int busnr; int nfree; int nused; - TAILQ_HEAD(, USBPort) free; - TAILQ_HEAD(, USBPort) used; - TAILQ_ENTRY(USBBus) next; + QTAILQ_HEAD(, USBPort) free; + QTAILQ_HEAD(, USBPort) used; + QTAILQ_ENTRY(USBBus) next; }; USBBus *usb_bus_new(DeviceState *host); diff --git a/hw/watchdog.c b/hw/watchdog.c index adba87253..6a3d1b432 100644 --- a/hw/watchdog.c +++ b/hw/watchdog.c @@ -22,7 +22,7 @@ #include "qemu-common.h" #include "qemu-option.h" #include "qemu-config.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "sysemu.h" #include "hw/watchdog.h" @@ -35,11 +35,11 @@ #define WDT_NONE 6 /* Do nothing. */ static int watchdog_action = WDT_RESET; -static LIST_HEAD(watchdog_list, WatchdogTimerModel) watchdog_list; +static QLIST_HEAD(watchdog_list, WatchdogTimerModel) watchdog_list; void watchdog_add_model(WatchdogTimerModel *model) { - LIST_INSERT_HEAD(&watchdog_list, model, entry); + QLIST_INSERT_HEAD(&watchdog_list, model, entry); } /* Returns: @@ -54,14 +54,14 @@ int select_watchdog(const char *p) /* -watchdog ? lists available devices and exits cleanly. */ if (strcmp(p, "?") == 0) { - LIST_FOREACH(model, &watchdog_list, entry) { + QLIST_FOREACH(model, &watchdog_list, entry) { fprintf(stderr, "\t%s\t%s\n", model->wdt_name, model->wdt_description); } return 2; } - LIST_FOREACH(model, &watchdog_list, entry) { + QLIST_FOREACH(model, &watchdog_list, entry) { if (strcasecmp(model->wdt_name, p) == 0) { /* add the device */ opts = qemu_opts_create(&qemu_device_opts, NULL, 0); @@ -71,7 +71,7 @@ int select_watchdog(const char *p) } fprintf(stderr, "Unknown -watchdog device. Supported devices are:\n"); - LIST_FOREACH(model, &watchdog_list, entry) { + QLIST_FOREACH(model, &watchdog_list, entry) { fprintf(stderr, "\t%s\t%s\n", model->wdt_name, model->wdt_description); } diff --git a/hw/watchdog.h b/hw/watchdog.h index 8c54fa41f..330062c85 100644 --- a/hw/watchdog.h +++ b/hw/watchdog.h @@ -23,7 +23,7 @@ #define QEMU_WATCHDOG_H struct WatchdogTimerModel { - LIST_ENTRY(WatchdogTimerModel) entry; + QLIST_ENTRY(WatchdogTimerModel) entry; /* Short name of the device - used to select it on the command line. */ const char *wdt_name; diff --git a/hw/xen_backend.c b/hw/xen_backend.c index efafd2fa5..658ea8d1d 100644 --- a/hw/xen_backend.c +++ b/hw/xen_backend.c @@ -48,7 +48,7 @@ struct xs_handle *xenstore = NULL; const char *xen_protocol; /* private */ -static TAILQ_HEAD(XenDeviceHead, XenDevice) xendevs = TAILQ_HEAD_INITIALIZER(xendevs); +static QTAILQ_HEAD(XenDeviceHead, XenDevice) xendevs = QTAILQ_HEAD_INITIALIZER(xendevs); static int debug = 0; /* ------------------------------------------------------------- */ @@ -165,7 +165,7 @@ struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev) { struct XenDevice *xendev; - TAILQ_FOREACH(xendev, &xendevs, next) { + QTAILQ_FOREACH(xendev, &xendevs, next) { if (xendev->dom != dom) continue; if (xendev->dev != dev) @@ -227,7 +227,7 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev, xendev->gnttabdev = -1; } - TAILQ_INSERT_TAIL(&xendevs, xendev, next); + QTAILQ_INSERT_TAIL(&xendevs, xendev, next); if (xendev->ops->alloc) xendev->ops->alloc(xendev); @@ -243,7 +243,7 @@ static struct XenDevice *xen_be_del_xendev(int dom, int dev) struct XenDevice *xendev, *xnext; /* - * This is pretty much like TAILQ_FOREACH(xendev, &xendevs, next) but + * This is pretty much like QTAILQ_FOREACH(xendev, &xendevs, next) but * we save the next pointer in xnext because we might free xendev. */ xnext = xendevs.tqh_first; @@ -271,7 +271,7 @@ static struct XenDevice *xen_be_del_xendev(int dom, int dev) if (xendev->gnttabdev >= 0) xc_gnttab_close(xendev->gnttabdev); - TAILQ_REMOVE(&xendevs, xendev, next); + QTAILQ_REMOVE(&xendevs, xendev, next); qemu_free(xendev); } return NULL; diff --git a/hw/xen_backend.h b/hw/xen_backend.h index 4dbfdb4a4..f07f7d422 100644 --- a/hw/xen_backend.h +++ b/hw/xen_backend.h @@ -50,7 +50,7 @@ struct XenDevice { int gnttabdev; struct XenDevOps *ops; - TAILQ_ENTRY(XenDevice) next; + QTAILQ_ENTRY(XenDevice) next; }; /* ------------------------------------------------------------- */ diff --git a/hw/xen_devconfig.c b/hw/xen_devconfig.c index 4121188a4..ea8f8c4c2 100644 --- a/hw/xen_devconfig.c +++ b/hw/xen_devconfig.c @@ -4,9 +4,9 @@ struct xs_dirs { char *xs_dir; - TAILQ_ENTRY(xs_dirs) list; + QTAILQ_ENTRY(xs_dirs) list; }; -static TAILQ_HEAD(xs_dirs_head, xs_dirs) xs_cleanup = TAILQ_HEAD_INITIALIZER(xs_cleanup); +static QTAILQ_HEAD(xs_dirs_head, xs_dirs) xs_cleanup = QTAILQ_HEAD_INITIALIZER(xs_cleanup); static void xen_config_cleanup_dir(char *dir) { @@ -14,14 +14,14 @@ static void xen_config_cleanup_dir(char *dir) d = qemu_malloc(sizeof(*d)); d->xs_dir = dir; - TAILQ_INSERT_TAIL(&xs_cleanup, d, list); + QTAILQ_INSERT_TAIL(&xs_cleanup, d, list); } void xen_config_cleanup(void) { struct xs_dirs *d; - TAILQ_FOREACH(d, &xs_cleanup, list) { + QTAILQ_FOREACH(d, &xs_cleanup, list) { xs_rm(xenstore, 0, d->xs_dir); } } diff --git a/hw/xen_disk.c b/hw/xen_disk.c index 100ef8e9b..74cde8069 100644 --- a/hw/xen_disk.c +++ b/hw/xen_disk.c @@ -77,7 +77,7 @@ struct ioreq { int aio_errors; struct XenBlkDev *blkdev; - LIST_ENTRY(ioreq) list; + QLIST_ENTRY(ioreq) list; }; struct XenBlkDev { @@ -99,9 +99,9 @@ struct XenBlkDev { int cnt_map; /* request lists */ - LIST_HEAD(inflight_head, ioreq) inflight; - LIST_HEAD(finished_head, ioreq) finished; - LIST_HEAD(freelist_head, ioreq) freelist; + QLIST_HEAD(inflight_head, ioreq) inflight; + QLIST_HEAD(finished_head, ioreq) finished; + QLIST_HEAD(freelist_head, ioreq) freelist; int requests_total; int requests_inflight; int requests_finished; @@ -118,7 +118,7 @@ static struct ioreq *ioreq_start(struct XenBlkDev *blkdev) { struct ioreq *ioreq = NULL; - if (LIST_EMPTY(&blkdev->freelist)) { + if (QLIST_EMPTY(&blkdev->freelist)) { if (blkdev->requests_total >= max_requests) goto out; /* allocate new struct */ @@ -128,11 +128,11 @@ static struct ioreq *ioreq_start(struct XenBlkDev *blkdev) qemu_iovec_init(&ioreq->v, BLKIF_MAX_SEGMENTS_PER_REQUEST); } else { /* get one from freelist */ - ioreq = LIST_FIRST(&blkdev->freelist); - LIST_REMOVE(ioreq, list); + ioreq = QLIST_FIRST(&blkdev->freelist); + QLIST_REMOVE(ioreq, list); qemu_iovec_reset(&ioreq->v); } - LIST_INSERT_HEAD(&blkdev->inflight, ioreq, list); + QLIST_INSERT_HEAD(&blkdev->inflight, ioreq, list); blkdev->requests_inflight++; out: @@ -143,8 +143,8 @@ static void ioreq_finish(struct ioreq *ioreq) { struct XenBlkDev *blkdev = ioreq->blkdev; - LIST_REMOVE(ioreq, list); - LIST_INSERT_HEAD(&blkdev->finished, ioreq, list); + QLIST_REMOVE(ioreq, list); + QLIST_INSERT_HEAD(&blkdev->finished, ioreq, list); blkdev->requests_inflight--; blkdev->requests_finished++; } @@ -153,10 +153,10 @@ static void ioreq_release(struct ioreq *ioreq) { struct XenBlkDev *blkdev = ioreq->blkdev; - LIST_REMOVE(ioreq, list); + QLIST_REMOVE(ioreq, list); memset(ioreq, 0, sizeof(*ioreq)); ioreq->blkdev = blkdev; - LIST_INSERT_HEAD(&blkdev->freelist, ioreq, list); + QLIST_INSERT_HEAD(&blkdev->freelist, ioreq, list); blkdev->requests_finished--; } @@ -476,8 +476,8 @@ static void blk_send_response_all(struct XenBlkDev *blkdev) struct ioreq *ioreq; int send_notify = 0; - while (!LIST_EMPTY(&blkdev->finished)) { - ioreq = LIST_FIRST(&blkdev->finished); + while (!QLIST_EMPTY(&blkdev->finished)) { + ioreq = QLIST_FIRST(&blkdev->finished); send_notify += blk_send_response_one(ioreq); ioreq_release(ioreq); } @@ -564,9 +564,9 @@ static void blk_alloc(struct XenDevice *xendev) { struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); - LIST_INIT(&blkdev->inflight); - LIST_INIT(&blkdev->finished); - LIST_INIT(&blkdev->freelist); + QLIST_INIT(&blkdev->inflight); + QLIST_INIT(&blkdev->finished); + QLIST_INIT(&blkdev->freelist); blkdev->bh = qemu_bh_new(blk_bh, blkdev); if (xen_mode != XEN_EMULATE) batch_maps = 1; @@ -750,9 +750,9 @@ static int blk_free(struct XenDevice *xendev) struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); struct ioreq *ioreq; - while (!LIST_EMPTY(&blkdev->freelist)) { - ioreq = LIST_FIRST(&blkdev->freelist); - LIST_REMOVE(ioreq, list); + while (!QLIST_EMPTY(&blkdev->freelist)) { + ioreq = QLIST_FIRST(&blkdev->freelist); + QLIST_REMOVE(ioreq, list); qemu_iovec_destroy(&ioreq->v); qemu_free(ioreq); } @@ -430,7 +430,7 @@ int kvm_init(int smp_cpus) s = qemu_mallocz(sizeof(KVMState)); #ifdef KVM_CAP_SET_GUEST_DEBUG - TAILQ_INIT(&s->kvm_sw_breakpoints); + QTAILQ_INIT(&s->kvm_sw_breakpoints); #endif for (i = 0; i < ARRAY_SIZE(s->slots); i++) s->slots[i].slot = i; @@ -929,7 +929,7 @@ struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *env, { struct kvm_sw_breakpoint *bp; - TAILQ_FOREACH(bp, &env->kvm_state->kvm_sw_breakpoints, entry) { + QTAILQ_FOREACH(bp, &env->kvm_state->kvm_sw_breakpoints, entry) { if (bp->pc == pc) return bp; } @@ -938,7 +938,7 @@ struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *env, int kvm_sw_breakpoints_active(CPUState *env) { - return !TAILQ_EMPTY(&env->kvm_state->kvm_sw_breakpoints); + return !QTAILQ_EMPTY(&env->kvm_state->kvm_sw_breakpoints); } #ifdef KVM_UPSTREAM @@ -998,7 +998,7 @@ int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr, return err; } - TAILQ_INSERT_HEAD(¤t_env->kvm_state->kvm_sw_breakpoints, + QTAILQ_INSERT_HEAD(¤t_env->kvm_state->kvm_sw_breakpoints, bp, entry); } else { err = kvm_arch_insert_hw_breakpoint(addr, len, type); @@ -1035,7 +1035,7 @@ int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr, if (err) return err; - TAILQ_REMOVE(¤t_env->kvm_state->kvm_sw_breakpoints, bp, entry); + QTAILQ_REMOVE(¤t_env->kvm_state->kvm_sw_breakpoints, bp, entry); qemu_free(bp); } else { err = kvm_arch_remove_hw_breakpoint(addr, len, type); @@ -1057,7 +1057,7 @@ void kvm_remove_all_breakpoints(CPUState *current_env) KVMState *s = current_env->kvm_state; CPUState *env; - TAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) { + QTAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) { if (kvm_arch_remove_sw_breakpoint(current_env, bp) != 0) { /* Try harder to find a CPU that currently sees the breakpoint. */ for (env = first_cpu; env != NULL; env = env->next_cpu) { @@ -15,7 +15,7 @@ #define QEMU_KVM_H #include "config.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "qemu-kvm.h" #ifdef KVM_UPSTREAM @@ -103,10 +103,10 @@ struct kvm_sw_breakpoint { target_ulong pc; target_ulong saved_insn; int use_count; - TAILQ_ENTRY(kvm_sw_breakpoint) entry; + QTAILQ_ENTRY(kvm_sw_breakpoint) entry; }; -TAILQ_HEAD(kvm_sw_breakpoint_head, kvm_sw_breakpoint); +QTAILQ_HEAD(kvm_sw_breakpoint_head, kvm_sw_breakpoint); int kvm_arch_debug(struct kvm_debug_exit_arch *arch_info); diff --git a/linux-user/elfload.c b/linux-user/elfload.c index 4f04b9828..10d4781da 100644 --- a/linux-user/elfload.c +++ b/linux-user/elfload.c @@ -1844,7 +1844,7 @@ struct target_elf_prpsinfo { /* Here is the structure in which status of each thread is captured. */ struct elf_thread_status { - TAILQ_ENTRY(elf_thread_status) ets_link; + QTAILQ_ENTRY(elf_thread_status) ets_link; struct target_elf_prstatus prstatus; /* NT_PRSTATUS */ #if 0 elf_fpregset_t fpu; /* NT_PRFPREG */ @@ -1860,7 +1860,7 @@ struct elf_note_info { struct target_elf_prstatus *prstatus; /* NT_PRSTATUS */ struct target_elf_prpsinfo *psinfo; /* NT_PRPSINFO */ - TAILQ_HEAD(thread_list_head, elf_thread_status) thread_list; + QTAILQ_HEAD(thread_list_head, elf_thread_status) thread_list; #if 0 /* * Current version of ELF coredump doesn't support @@ -1878,11 +1878,11 @@ struct vm_area_struct { abi_ulong vma_start; /* start vaddr of memory region */ abi_ulong vma_end; /* end vaddr of memory region */ abi_ulong vma_flags; /* protection etc. flags for the region */ - TAILQ_ENTRY(vm_area_struct) vma_link; + QTAILQ_ENTRY(vm_area_struct) vma_link; }; struct mm_struct { - TAILQ_HEAD(, vm_area_struct) mm_mmap; + QTAILQ_HEAD(, vm_area_struct) mm_mmap; int mm_count; /* number of mappings */ }; @@ -1962,7 +1962,7 @@ static struct mm_struct *vma_init(void) return (NULL); mm->mm_count = 0; - TAILQ_INIT(&mm->mm_mmap); + QTAILQ_INIT(&mm->mm_mmap); return (mm); } @@ -1972,7 +1972,7 @@ static void vma_delete(struct mm_struct *mm) struct vm_area_struct *vma; while ((vma = vma_first(mm)) != NULL) { - TAILQ_REMOVE(&mm->mm_mmap, vma, vma_link); + QTAILQ_REMOVE(&mm->mm_mmap, vma, vma_link); qemu_free(vma); } qemu_free(mm); @@ -1990,7 +1990,7 @@ static int vma_add_mapping(struct mm_struct *mm, abi_ulong start, vma->vma_end = end; vma->vma_flags = flags; - TAILQ_INSERT_TAIL(&mm->mm_mmap, vma, vma_link); + QTAILQ_INSERT_TAIL(&mm->mm_mmap, vma, vma_link); mm->mm_count++; return (0); @@ -1998,12 +1998,12 @@ static int vma_add_mapping(struct mm_struct *mm, abi_ulong start, static struct vm_area_struct *vma_first(const struct mm_struct *mm) { - return (TAILQ_FIRST(&mm->mm_mmap)); + return (QTAILQ_FIRST(&mm->mm_mmap)); } static struct vm_area_struct *vma_next(struct vm_area_struct *vma) { - return (TAILQ_NEXT(vma, vma_link)); + return (QTAILQ_NEXT(vma, vma_link)); } static int vma_get_mapping_count(const struct mm_struct *mm) @@ -2328,7 +2328,7 @@ static void fill_thread_info(struct elf_note_info *info, const CPUState *env) fill_note(&ets->notes[0], "CORE", NT_PRSTATUS, sizeof (ets->prstatus), &ets->prstatus); - TAILQ_INSERT_TAIL(&info->thread_list, ets, ets_link); + QTAILQ_INSERT_TAIL(&info->thread_list, ets, ets_link); info->notes_size += note_size(&ets->notes[0]); } @@ -2343,7 +2343,7 @@ static int fill_note_info(struct elf_note_info *info, (void) memset(info, 0, sizeof (*info)); - TAILQ_INIT(&info->thread_list); + QTAILQ_INIT(&info->thread_list); info->notes = qemu_mallocz(NUMNOTES * sizeof (struct memelfnote)); if (info->notes == NULL) @@ -2389,9 +2389,9 @@ static void free_note_info(struct elf_note_info *info) { struct elf_thread_status *ets; - while (!TAILQ_EMPTY(&info->thread_list)) { - ets = TAILQ_FIRST(&info->thread_list); - TAILQ_REMOVE(&info->thread_list, ets, ets_link); + while (!QTAILQ_EMPTY(&info->thread_list)) { + ets = QTAILQ_FIRST(&info->thread_list); + QTAILQ_REMOVE(&info->thread_list, ets, ets_link); qemu_free(ets); } diff --git a/linux-user/qemu.h b/linux-user/qemu.h index def620f0e..d129debb1 100644 --- a/linux-user/qemu.h +++ b/linux-user/qemu.h @@ -18,7 +18,7 @@ #include "syscall.h" #include "target_signal.h" #include "gdbstub.h" -#include "sys-queue.h" +#include "qemu-queue.h" #if defined(CONFIG_USE_NPTL) #define THREAD __thread @@ -12,17 +12,17 @@ */ #include "qemu-common.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "module.h" typedef struct ModuleEntry { module_init_type type; void (*init)(void); - TAILQ_ENTRY(ModuleEntry) node; + QTAILQ_ENTRY(ModuleEntry) node; } ModuleEntry; -typedef TAILQ_HEAD(, ModuleEntry) ModuleTypeList; +typedef QTAILQ_HEAD(, ModuleEntry) ModuleTypeList; static ModuleTypeList init_type_list[MODULE_INIT_MAX]; @@ -36,7 +36,7 @@ static void init_types(void) } for (i = 0; i < MODULE_INIT_MAX; i++) { - TAILQ_INIT(&init_type_list[i]); + QTAILQ_INIT(&init_type_list[i]); } inited = 1; @@ -64,7 +64,7 @@ void register_module_init(void (*fn)(void), module_init_type type) l = find_type(type); - TAILQ_INSERT_TAIL(l, e, node); + QTAILQ_INSERT_TAIL(l, e, node); } void module_call_init(module_init_type type) @@ -74,7 +74,7 @@ void module_call_init(module_init_type type) l = find_type(type); - TAILQ_FOREACH(e, l, node) { + QTAILQ_FOREACH(e, l, node) { e->init(); } } @@ -83,7 +83,7 @@ typedef struct mon_fd_t mon_fd_t; struct mon_fd_t { char *name; int fd; - LIST_ENTRY(mon_fd_t) next; + QLIST_ENTRY(mon_fd_t) next; }; struct Monitor { @@ -98,11 +98,11 @@ struct Monitor { CPUState *mon_cpu; BlockDriverCompletionFunc *password_completion_cb; void *password_opaque; - LIST_HEAD(,mon_fd_t) fds; - LIST_ENTRY(Monitor) entry; + QLIST_HEAD(,mon_fd_t) fds; + QLIST_ENTRY(Monitor) entry; }; -static LIST_HEAD(mon_list, Monitor) mon_list; +static QLIST_HEAD(mon_list, Monitor) mon_list; static const mon_cmd_t mon_cmds[]; static const mon_cmd_t info_cmds[]; @@ -273,7 +273,7 @@ static void do_commit(Monitor *mon, const QDict *qdict) const char *device = qdict_get_str(qdict, "device"); all_devices = !strcmp(device, "all"); - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { if (!all_devices) if (strcmp(bdrv_get_device_name(dinfo->bdrv), device)) continue; @@ -1498,7 +1498,7 @@ static void do_info_profile(Monitor *mon) #endif /* Capture support */ -static LIST_HEAD (capture_list_head, CaptureState) capture_head; +static QLIST_HEAD (capture_list_head, CaptureState) capture_head; static void do_info_capture(Monitor *mon) { @@ -1521,7 +1521,7 @@ static void do_stop_capture(Monitor *mon, const QDict *qdict) for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) { if (i == n) { s->ops.destroy (s->opaque); - LIST_REMOVE (s, entries); + QLIST_REMOVE (s, entries); qemu_free (s); return; } @@ -1549,7 +1549,7 @@ static void do_wav_capture(Monitor *mon, const QDict *qdict) monitor_printf(mon, "Faied to add wave capture\n"); qemu_free (s); } - LIST_INSERT_HEAD (&capture_head, s, entries); + QLIST_INSERT_HEAD (&capture_head, s, entries); } #endif @@ -1624,7 +1624,7 @@ static void do_acl_show(Monitor *mon, const QDict *qdict) if (acl) { monitor_printf(mon, "policy: %s\n", acl->defaultDeny ? "deny" : "allow"); - TAILQ_FOREACH(entry, &acl->entries, next) { + QTAILQ_FOREACH(entry, &acl->entries, next) { i++; monitor_printf(mon, "%d: %s %s\n", i, entry->deny ? "deny" : "allow", entry->match); @@ -1753,7 +1753,7 @@ static void do_getfd(Monitor *mon, const QDict *qdict) return; } - LIST_FOREACH(monfd, &mon->fds, next) { + QLIST_FOREACH(monfd, &mon->fds, next) { if (strcmp(monfd->name, fdname) != 0) { continue; } @@ -1767,7 +1767,7 @@ static void do_getfd(Monitor *mon, const QDict *qdict) monfd->name = qemu_strdup(fdname); monfd->fd = fd; - LIST_INSERT_HEAD(&mon->fds, monfd, next); + QLIST_INSERT_HEAD(&mon->fds, monfd, next); } static void do_closefd(Monitor *mon, const QDict *qdict) @@ -1775,12 +1775,12 @@ static void do_closefd(Monitor *mon, const QDict *qdict) const char *fdname = qdict_get_str(qdict, "fdname"); mon_fd_t *monfd; - LIST_FOREACH(monfd, &mon->fds, next) { + QLIST_FOREACH(monfd, &mon->fds, next) { if (strcmp(monfd->name, fdname) != 0) { continue; } - LIST_REMOVE(monfd, next); + QLIST_REMOVE(monfd, next); close(monfd->fd); qemu_free(monfd->name); qemu_free(monfd); @@ -1806,7 +1806,7 @@ int monitor_get_fd(Monitor *mon, const char *fdname) { mon_fd_t *monfd; - LIST_FOREACH(monfd, &mon->fds, next) { + QLIST_FOREACH(monfd, &mon->fds, next) { int fd; if (strcmp(monfd->name, fdname) != 0) { @@ -1816,7 +1816,7 @@ int monitor_get_fd(Monitor *mon, const char *fdname) fd = monfd->fd; /* caller takes ownership of fd */ - LIST_REMOVE(monfd, next); + QLIST_REMOVE(monfd, next); qemu_free(monfd->name); qemu_free(monfd); @@ -3202,7 +3202,7 @@ void monitor_init(CharDriverState *chr, int flags) qemu_chr_add_handlers(chr, monitor_can_read, monitor_read, monitor_event, mon); - LIST_INSERT_HEAD(&mon_list, mon, entry); + QLIST_INSERT_HEAD(&mon_list, mon, entry); if (!cur_mon || (flags & MONITOR_IS_DEFAULT)) cur_mon = mon; } @@ -31,8 +31,6 @@ /* Needed early for CONFIG_BSD etc. */ #include "config-host.h" -/* Needed early to override system queue definitions on BSD */ -#include "sys-queue.h" #ifndef _WIN32 #include <sys/times.h> @@ -115,6 +113,7 @@ #include "qemu-log.h" #include "slirp/libslirp.h" +#include "qemu-queue.h" static VLANState *first_vlan; @@ -445,9 +444,9 @@ void qemu_purge_queued_packets(VLANClientState *vc) { VLANPacket *packet, *next; - TAILQ_FOREACH_SAFE(packet, &vc->vlan->send_queue, entry, next) { + QTAILQ_FOREACH_SAFE(packet, &vc->vlan->send_queue, entry, next) { if (packet->sender == vc) { - TAILQ_REMOVE(&vc->vlan->send_queue, packet, entry); + QTAILQ_REMOVE(&vc->vlan->send_queue, packet, entry); qemu_free(packet); } } @@ -455,17 +454,17 @@ void qemu_purge_queued_packets(VLANClientState *vc) void qemu_flush_queued_packets(VLANClientState *vc) { - while (!TAILQ_EMPTY(&vc->vlan->send_queue)) { + while (!QTAILQ_EMPTY(&vc->vlan->send_queue)) { VLANPacket *packet; int ret; - packet = TAILQ_FIRST(&vc->vlan->send_queue); - TAILQ_REMOVE(&vc->vlan->send_queue, packet, entry); + packet = QTAILQ_FIRST(&vc->vlan->send_queue); + QTAILQ_REMOVE(&vc->vlan->send_queue, packet, entry); ret = qemu_deliver_packet(packet->sender, packet->data, packet->size, packet->raw); 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; } @@ -489,7 +488,7 @@ static void qemu_enqueue_packet(VLANClientState *sender, packet->sent_cb = sent_cb; memcpy(packet->data, buf, size); - TAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry); + QTAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry); } static ssize_t qemu_send_packet_async2(VLANClientState *sender, @@ -625,7 +624,7 @@ static ssize_t qemu_enqueue_packet_iov(VLANClientState *sender, packet->size += len; } - TAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry); + QTAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry); return packet->size; } @@ -691,7 +690,7 @@ struct slirp_config_str { }; typedef struct SlirpState { - TAILQ_ENTRY(SlirpState) entry; + QTAILQ_ENTRY(SlirpState) entry; VLANClientState *vc; Slirp *slirp; #ifndef _WIN32 @@ -702,8 +701,8 @@ typedef struct SlirpState { static struct slirp_config_str *slirp_configs; const char *legacy_tftp_prefix; const char *legacy_bootp_filename; -static TAILQ_HEAD(slirp_stacks, SlirpState) slirp_stacks = - TAILQ_HEAD_INITIALIZER(slirp_stacks); +static QTAILQ_HEAD(slirp_stacks, SlirpState) slirp_stacks = + QTAILQ_HEAD_INITIALIZER(slirp_stacks); static void slirp_hostfwd(SlirpState *s, Monitor *mon, const char *redir_str, int legacy_format); @@ -756,7 +755,7 @@ static void net_slirp_cleanup(VLANClientState *vc) slirp_cleanup(s->slirp); slirp_smb_cleanup(s); - TAILQ_REMOVE(&slirp_stacks, s, entry); + QTAILQ_REMOVE(&slirp_stacks, s, entry); qemu_free(s); } @@ -864,7 +863,7 @@ static int net_slirp_init(Monitor *mon, VLANState *vlan, const char *model, s = qemu_mallocz(sizeof(SlirpState)); s->slirp = slirp_init(restricted, net, mask, host, vhostname, tftp_export, bootfile, dhcp, dns, s); - TAILQ_INSERT_TAIL(&slirp_stacks, s, entry); + QTAILQ_INSERT_TAIL(&slirp_stacks, s, entry); while (slirp_configs) { struct slirp_config_str *config = slirp_configs; @@ -911,11 +910,11 @@ static SlirpState *slirp_lookup(Monitor *mon, const char *vlan, } return vc->opaque; } else { - if (TAILQ_EMPTY(&slirp_stacks)) { + if (QTAILQ_EMPTY(&slirp_stacks)) { monitor_printf(mon, "user mode network stack not in use\n"); return NULL; } - return TAILQ_FIRST(&slirp_stacks); + return QTAILQ_FIRST(&slirp_stacks); } } @@ -966,7 +965,7 @@ void net_slirp_hostfwd_remove(Monitor *mon, const QDict *qdict) host_port = atoi(p); - err = slirp_remove_hostfwd(TAILQ_FIRST(&slirp_stacks)->slirp, is_udp, + err = slirp_remove_hostfwd(QTAILQ_FIRST(&slirp_stacks)->slirp, is_udp, host_addr, host_port); monitor_printf(mon, "host forwarding rule for %s %s\n", src_str, @@ -1065,7 +1064,7 @@ void net_slirp_redir(const char *redir_str) { struct slirp_config_str *config; - if (TAILQ_EMPTY(&slirp_stacks)) { + if (QTAILQ_EMPTY(&slirp_stacks)) { config = qemu_malloc(sizeof(*config)); pstrcpy(config->str, sizeof(config->str), redir_str); config->flags = SLIRP_CFG_HOSTFWD | SLIRP_CFG_LEGACY; @@ -1074,7 +1073,7 @@ void net_slirp_redir(const char *redir_str) return; } - slirp_hostfwd(TAILQ_FIRST(&slirp_stacks), NULL, redir_str, 1); + slirp_hostfwd(QTAILQ_FIRST(&slirp_stacks), NULL, redir_str, 1); } #ifndef _WIN32 @@ -1157,8 +1156,8 @@ void net_slirp_smb(const char *exported_dir) exit(1); } legacy_smb_export = exported_dir; - if (!TAILQ_EMPTY(&slirp_stacks)) { - slirp_smb(TAILQ_FIRST(&slirp_stacks), NULL, exported_dir, + if (!QTAILQ_EMPTY(&slirp_stacks)) { + slirp_smb(QTAILQ_FIRST(&slirp_stacks), NULL, exported_dir, vserver_addr); } } @@ -1253,7 +1252,7 @@ void do_info_usernet(Monitor *mon) { SlirpState *s; - TAILQ_FOREACH(s, &slirp_stacks, entry) { + QTAILQ_FOREACH(s, &slirp_stacks, entry) { monitor_printf(mon, "VLAN %d (%s):\n", s->vc->vlan->id, s->vc->name); slirp_connection_info(s->slirp, mon); } @@ -2501,7 +2500,7 @@ VLANState *qemu_find_vlan(int id, int allocate) } vlan = qemu_mallocz(sizeof(VLANState)); vlan->id = id; - TAILQ_INIT(&vlan->send_queue); + QTAILQ_INIT(&vlan->send_queue); vlan->next = NULL; pvlan = &first_vlan; while (*pvlan != NULL) @@ -2765,7 +2764,7 @@ int net_client_init(Monitor *mon, const char *device, const char *p) qemu_free(smb_export); qemu_free(vsmbsrv); } else if (!strcmp(device, "channel")) { - if (TAILQ_EMPTY(&slirp_stacks)) { + if (QTAILQ_EMPTY(&slirp_stacks)) { struct slirp_config_str *config; config = qemu_malloc(sizeof(*config)); @@ -2774,7 +2773,7 @@ int net_client_init(Monitor *mon, const char *device, const char *p) config->next = slirp_configs; slirp_configs = config; } else { - slirp_guestfwd(TAILQ_FIRST(&slirp_stacks), mon, p, 1); + slirp_guestfwd(QTAILQ_FIRST(&slirp_stacks), mon, p, 1); } ret = 0; } else @@ -1,7 +1,7 @@ #ifndef QEMU_NET_H #define QEMU_NET_H -#include "sys-queue.h" +#include "qemu-queue.h" #include "qemu-common.h" #include "qdict.h" @@ -40,7 +40,7 @@ typedef struct VLANPacket VLANPacket; typedef void (NetPacketSent) (VLANClientState *, ssize_t); struct VLANPacket { - TAILQ_ENTRY(VLANPacket) entry; + QTAILQ_ENTRY(VLANPacket) entry; VLANClientState *sender; int size; int raw; @@ -53,7 +53,7 @@ struct VLANState { VLANClientState *first_client; struct VLANState *next; unsigned int nb_guest_devs, nb_host_devs; - TAILQ_HEAD(send_queue, VLANPacket) send_queue; + QTAILQ_HEAD(send_queue, VLANPacket) send_queue; int delivering; }; diff --git a/posix-aio-compat.c b/posix-aio-compat.c index 9320b3d79..ca528766a 100644 --- a/posix-aio-compat.c +++ b/posix-aio-compat.c @@ -22,7 +22,7 @@ #include <stdlib.h> #include <stdio.h> -#include "sys-queue.h" +#include "qemu-queue.h" #include "osdep.h" #include "qemu-common.h" #include "block_int.h" @@ -44,7 +44,7 @@ struct qemu_paiocb { int ev_signo; off_t aio_offset; - TAILQ_ENTRY(qemu_paiocb) node; + QTAILQ_ENTRY(qemu_paiocb) node; int aio_type; ssize_t ret; int active; @@ -64,7 +64,7 @@ static pthread_attr_t attr; static int max_threads = 64; static int cur_threads = 0; static int idle_threads = 0; -static TAILQ_HEAD(, qemu_paiocb) request_list; +static QTAILQ_HEAD(, qemu_paiocb) request_list; #ifdef CONFIG_PREADV static int preadv_present = 1; @@ -139,7 +139,7 @@ static size_t handle_aiocb_flush(struct qemu_paiocb *aiocb) { int ret; - ret = fdatasync(aiocb->aio_fildes); + ret = qemu_fdatasync(aiocb->aio_fildes); if (ret == -1) return -errno; return 0; @@ -322,16 +322,16 @@ static void *aio_thread(void *unused) mutex_lock(&lock); - while (TAILQ_EMPTY(&request_list) && + while (QTAILQ_EMPTY(&request_list) && !(ret == ETIMEDOUT)) { ret = cond_timedwait(&cond, &lock, &ts); } - if (TAILQ_EMPTY(&request_list)) + if (QTAILQ_EMPTY(&request_list)) break; - aiocb = TAILQ_FIRST(&request_list); - TAILQ_REMOVE(&request_list, aiocb, node); + aiocb = QTAILQ_FIRST(&request_list); + QTAILQ_REMOVE(&request_list, aiocb, node); aiocb->active = 1; idle_threads--; mutex_unlock(&lock); @@ -382,7 +382,7 @@ static void qemu_paio_submit(struct qemu_paiocb *aiocb) mutex_lock(&lock); if (idle_threads == 0 && cur_threads < max_threads) spawn_thread(); - TAILQ_INSERT_TAIL(&request_list, aiocb, node); + QTAILQ_INSERT_TAIL(&request_list, aiocb, node); mutex_unlock(&lock); cond_signal(&cond); } @@ -510,7 +510,7 @@ static void paio_cancel(BlockDriverAIOCB *blockacb) mutex_lock(&lock); if (!acb->active) { - TAILQ_REMOVE(&request_list, acb, node); + QTAILQ_REMOVE(&request_list, acb, node); acb->ret = -ECANCELED; } else if (acb->ret == -EINPROGRESS) { active = 1; @@ -616,7 +616,7 @@ void *paio_init(void) if (ret) die2(ret, "pthread_attr_setdetachstate"); - TAILQ_INIT(&request_list); + QTAILQ_INIT(&request_list); posix_aio_state = s; @@ -14,7 +14,7 @@ #include "qdict.h" #include "qstring.h" #include "qobject.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "qemu-common.h" static void qdict_destroy_obj(QObject *obj); @@ -88,7 +88,7 @@ static QDictEntry *qdict_find(const QDict *qdict, { QDictEntry *entry; - LIST_FOREACH(entry, &qdict->table[hash], next) + QLIST_FOREACH(entry, &qdict->table[hash], next) if (!strcmp(entry->key, key)) return entry; @@ -120,7 +120,7 @@ void qdict_put_obj(QDict *qdict, const char *key, QObject *value) } else { /* allocate a new entry */ entry = alloc_entry(key, value); - LIST_INSERT_HEAD(&qdict->table[hash], entry, next); + QLIST_INSERT_HEAD(&qdict->table[hash], entry, next); } qdict->size++; @@ -266,7 +266,7 @@ void qdict_del(QDict *qdict, const char *key) entry = qdict_find(qdict, key, tdb_hash(key) % QDICT_HASH_SIZE); if (entry) { - LIST_REMOVE(entry, next); + QLIST_REMOVE(entry, next); qentry_destroy(entry); qdict->size--; } @@ -284,10 +284,10 @@ static void qdict_destroy_obj(QObject *obj) qdict = qobject_to_qdict(obj); for (i = 0; i < QDICT_HASH_SIZE; i++) { - QDictEntry *entry = LIST_FIRST(&qdict->table[i]); + QDictEntry *entry = QLIST_FIRST(&qdict->table[i]); while (entry) { - QDictEntry *tmp = LIST_NEXT(entry, next); - LIST_REMOVE(entry, next); + QDictEntry *tmp = QLIST_NEXT(entry, next); + QLIST_REMOVE(entry, next); qentry_destroy(entry); entry = tmp; } @@ -2,7 +2,7 @@ #define QDICT_H #include "qobject.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include <stdint.h> #define QDICT_HASH_SIZE 512 @@ -10,13 +10,13 @@ typedef struct QDictEntry { char *key; QObject *value; - LIST_ENTRY(QDictEntry) next; + QLIST_ENTRY(QDictEntry) next; } QDictEntry; typedef struct QDict { QObject_HEAD; size_t size; - LIST_HEAD(,QDictEntry) table[QDICT_HASH_SIZE]; + QLIST_HEAD(,QDictEntry) table[QDICT_HASH_SIZE]; } QDict; /* Object API */ diff --git a/qemu-char.c b/qemu-char.c index 4f2961802..8084a6785 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -106,8 +106,8 @@ /***********************************************************/ /* character device */ -static TAILQ_HEAD(CharDriverStateHead, CharDriverState) chardevs = - TAILQ_HEAD_INITIALIZER(chardevs); +static QTAILQ_HEAD(CharDriverStateHead, CharDriverState) chardevs = + QTAILQ_HEAD_INITIALIZER(chardevs); static int initial_reset_issued; static void qemu_chr_event(CharDriverState *s, int event) @@ -139,7 +139,7 @@ void qemu_chr_initial_reset(void) initial_reset_issued = 1; - TAILQ_FOREACH(chr, &chardevs, next) { + QTAILQ_FOREACH(chr, &chardevs, next) { qemu_chr_reset(chr); } } @@ -352,7 +352,7 @@ static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch) case 's': { DriveInfo *dinfo; - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { bdrv_commit(dinfo->bdrv); } } @@ -2400,7 +2400,7 @@ CharDriverState *qemu_chr_open_opts(QemuOpts *opts, if (!chr->filename) chr->filename = qemu_strdup(qemu_opt_get(opts, "backend")); chr->init = init; - TAILQ_INSERT_TAIL(&chardevs, chr, next); + QTAILQ_INSERT_TAIL(&chardevs, chr, next); if (qemu_opt_get_bool(opts, "mux", 0)) { CharDriverState *base = chr; @@ -2409,7 +2409,7 @@ CharDriverState *qemu_chr_open_opts(QemuOpts *opts, snprintf(base->label, len, "%s-base", qemu_opts_id(opts)); chr = qemu_chr_open_mux(base); chr->filename = base->filename; - TAILQ_INSERT_TAIL(&chardevs, chr, next); + QTAILQ_INSERT_TAIL(&chardevs, chr, next); } chr->label = qemu_strdup(qemu_opts_id(opts)); return chr; @@ -2438,7 +2438,7 @@ CharDriverState *qemu_chr_open(const char *label, const char *filename, void (*i void qemu_chr_close(CharDriverState *chr) { - TAILQ_REMOVE(&chardevs, chr, next); + QTAILQ_REMOVE(&chardevs, chr, next); if (chr->chr_close) chr->chr_close(chr); qemu_free(chr->filename); @@ -2450,7 +2450,7 @@ void qemu_chr_info(Monitor *mon) { CharDriverState *chr; - TAILQ_FOREACH(chr, &chardevs, next) { + QTAILQ_FOREACH(chr, &chardevs, next) { monitor_printf(mon, "%s: filename=%s\n", chr->label, chr->filename); } } @@ -2459,7 +2459,7 @@ CharDriverState *qemu_chr_find(const char *name) { CharDriverState *chr; - TAILQ_FOREACH(chr, &chardevs, next) { + QTAILQ_FOREACH(chr, &chardevs, next) { if (strcmp(chr->label, name) != 0) continue; return chr; diff --git a/qemu-char.h b/qemu-char.h index d12ab11a8..c0654bca2 100644 --- a/qemu-char.h +++ b/qemu-char.h @@ -2,7 +2,7 @@ #define QEMU_CHAR_H #include "qemu-common.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "qemu-option.h" #include "qemu-config.h" @@ -66,7 +66,7 @@ struct CharDriverState { QEMUBH *bh; char *label; char *filename; - TAILQ_ENTRY(CharDriverState) next; + QTAILQ_ENTRY(CharDriverState) next; }; CharDriverState *qemu_chr_open_opts(QemuOpts *opts, diff --git a/qemu-config.c b/qemu-config.c index c7d6da936..636fa64b4 100644 --- a/qemu-config.c +++ b/qemu-config.c @@ -4,7 +4,7 @@ QemuOptsList qemu_drive_opts = { .name = "drive", - .head = TAILQ_HEAD_INITIALIZER(qemu_drive_opts.head), + .head = QTAILQ_HEAD_INITIALIZER(qemu_drive_opts.head), .desc = { { .name = "bus", @@ -81,7 +81,7 @@ QemuOptsList qemu_drive_opts = { QemuOptsList qemu_chardev_opts = { .name = "chardev", - .head = TAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head), + .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head), .desc = { { .name = "backend", @@ -144,7 +144,7 @@ QemuOptsList qemu_chardev_opts = { QemuOptsList qemu_device_opts = { .name = "device", - .head = TAILQ_HEAD_INITIALIZER(qemu_device_opts.head), + .head = QTAILQ_HEAD_INITIALIZER(qemu_device_opts.head), .desc = { /* * no elements => accept any diff --git a/qemu-kvm.c b/qemu-kvm.c index 78eeb6ff7..bff11e8fd 100644 --- a/qemu-kvm.c +++ b/qemu-kvm.c @@ -68,7 +68,7 @@ static uint64_t phys_ram_size; #ifdef USE_KVM_DEVICE_ASSIGNMENT /* The list of ioperm_data */ -static LIST_HEAD(, ioperm_data) ioperm_head; +static QLIST_HEAD(, ioperm_data) ioperm_head; #endif //#define DEBUG_MEMREG @@ -390,7 +390,7 @@ int kvm_init(int smp_cpus) kvm_context->no_pit_creation = 0; #ifdef KVM_CAP_SET_GUEST_DEBUG - TAILQ_INIT(&kvm_state->kvm_sw_breakpoints); + QTAILQ_INIT(&kvm_state->kvm_sw_breakpoints); #endif gsi_count = kvm_get_gsi_count(kvm_context); @@ -1843,7 +1843,7 @@ static void *ap_main_loop(void *_env) #ifdef USE_KVM_DEVICE_ASSIGNMENT /* do ioperm for io ports of assigned devices */ - LIST_FOREACH(data, &ioperm_head, entries) + QLIST_FOREACH(data, &ioperm_head, entries) on_vcpu(env, kvm_arch_do_ioperm, data); #endif @@ -2427,19 +2427,19 @@ void kvm_mutex_lock(void) #ifdef USE_KVM_DEVICE_ASSIGNMENT void kvm_add_ioperm_data(struct ioperm_data *data) { - LIST_INSERT_HEAD(&ioperm_head, data, entries); + QLIST_INSERT_HEAD(&ioperm_head, data, entries); } void kvm_remove_ioperm_data(unsigned long start_port, unsigned long num) { struct ioperm_data *data; - data = LIST_FIRST(&ioperm_head); + data = QLIST_FIRST(&ioperm_head); while (data) { - struct ioperm_data *next = LIST_NEXT(data, entries); + struct ioperm_data *next = QLIST_NEXT(data, entries); if (data->start_port == start_port && data->num == num) { - LIST_REMOVE(data, entries); + QLIST_REMOVE(data, entries); qemu_free(data); } diff --git a/qemu-kvm.h b/qemu-kvm.h index 11350f731..0091a16ab 100644 --- a/qemu-kvm.h +++ b/qemu-kvm.h @@ -1021,10 +1021,10 @@ struct kvm_sw_breakpoint { target_ulong pc; target_ulong saved_insn; int use_count; - TAILQ_ENTRY(kvm_sw_breakpoint) entry; + QTAILQ_ENTRY(kvm_sw_breakpoint) entry; }; -TAILQ_HEAD(kvm_sw_breakpoint_head, kvm_sw_breakpoint); +QTAILQ_HEAD(kvm_sw_breakpoint_head, kvm_sw_breakpoint); int kvm_arch_debug(struct kvm_debug_exit_arch *arch_info); int kvm_sw_breakpoints_active(CPUState *env); @@ -1073,7 +1073,7 @@ void kvm_arch_do_ioperm(void *_data); #define BITMAP_SIZE(m) (ALIGN(((m)>>TARGET_PAGE_BITS), HOST_LONG_BITS) / 8) #ifdef CONFIG_KVM -#include "sys-queue.h" +#include "qemu-queue.h" extern int kvm_allowed; extern int kvm_irqchip; @@ -1086,7 +1086,7 @@ struct ioperm_data { unsigned long start_port; unsigned long num; int turn_on; - LIST_ENTRY(ioperm_data) entries; + QLIST_ENTRY(ioperm_data) entries; }; void qemu_kvm_cpu_stop(CPUState *env); diff --git a/qemu-option.c b/qemu-option.c index 0c2101e3e..88298e4b5 100644 --- a/qemu-option.c +++ b/qemu-option.c @@ -477,21 +477,21 @@ struct QemuOpt { } value; QemuOpts *opts; - TAILQ_ENTRY(QemuOpt) next; + QTAILQ_ENTRY(QemuOpt) next; }; struct QemuOpts { const char *id; QemuOptsList *list; - TAILQ_HEAD(, QemuOpt) head; - TAILQ_ENTRY(QemuOpts) next; + QTAILQ_HEAD(, QemuOpt) head; + QTAILQ_ENTRY(QemuOpts) next; }; static QemuOpt *qemu_opt_find(QemuOpts *opts, const char *name) { QemuOpt *opt; - TAILQ_FOREACH(opt, &opts->head, next) { + QTAILQ_FOREACH(opt, &opts->head, next) { if (strcmp(opt->name, name) != 0) continue; return opt; @@ -556,7 +556,7 @@ static int qemu_opt_parse(QemuOpt *opt) static void qemu_opt_del(QemuOpt *opt) { - TAILQ_REMOVE(&opt->opts->head, opt, next); + QTAILQ_REMOVE(&opt->opts->head, opt, next); qemu_free((/* !const */ char*)opt->name); qemu_free((/* !const */ char*)opt->str); qemu_free(opt); @@ -588,7 +588,7 @@ int qemu_opt_set(QemuOpts *opts, const char *name, const char *value) opt = qemu_mallocz(sizeof(*opt)); opt->name = qemu_strdup(name); opt->opts = opts; - TAILQ_INSERT_TAIL(&opts->head, opt, next); + QTAILQ_INSERT_TAIL(&opts->head, opt, next); if (desc[i].name != NULL) { opt->desc = desc+i; } @@ -613,7 +613,7 @@ int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque, QemuOpt *opt; int rc = 0; - TAILQ_FOREACH(opt, &opts->head, next) { + QTAILQ_FOREACH(opt, &opts->head, next) { rc = func(opt->name, opt->str, opaque); if (abort_on_failure && rc != 0) break; @@ -625,7 +625,7 @@ QemuOpts *qemu_opts_find(QemuOptsList *list, const char *id) { QemuOpts *opts; - TAILQ_FOREACH(opts, &list->head, next) { + QTAILQ_FOREACH(opts, &list->head, next) { if (!opts->id) { continue; } @@ -658,8 +658,8 @@ QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id, int fail_if_exist opts->id = qemu_strdup(id); } opts->list = list; - TAILQ_INIT(&opts->head); - TAILQ_INSERT_TAIL(&list->head, opts, next); + QTAILQ_INIT(&opts->head); + QTAILQ_INSERT_TAIL(&list->head, opts, next); return opts; } @@ -687,12 +687,12 @@ void qemu_opts_del(QemuOpts *opts) QemuOpt *opt; for (;;) { - opt = TAILQ_FIRST(&opts->head); + opt = QTAILQ_FIRST(&opts->head); if (opt == NULL) break; qemu_opt_del(opt); } - TAILQ_REMOVE(&opts->list->head, opts, next); + QTAILQ_REMOVE(&opts->list->head, opts, next); qemu_free(opts); } @@ -702,7 +702,7 @@ int qemu_opts_print(QemuOpts *opts, void *dummy) fprintf(stderr, "%s: %s:", opts->list->name, opts->id ? opts->id : "<noid>"); - TAILQ_FOREACH(opt, &opts->head, next) { + QTAILQ_FOREACH(opt, &opts->head, next) { fprintf(stderr, " %s=\"%s\"", opt->name, opt->str); } fprintf(stderr, "\n"); @@ -788,7 +788,7 @@ int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func, void *opaque, QemuOpts *opts; int rc = 0; - TAILQ_FOREACH(opts, &list->head, next) { + QTAILQ_FOREACH(opts, &list->head, next) { rc = func(opts, opaque); if (abort_on_failure && rc != 0) break; diff --git a/qemu-option.h b/qemu-option.h index 9e52625cc..6b968a572 100644 --- a/qemu-option.h +++ b/qemu-option.h @@ -26,7 +26,7 @@ #ifndef QEMU_OPTIONS_H #define QEMU_OPTIONS_H -#include "sys-queue.h" +#include "qemu-queue.h" enum QEMUOptionParType { OPT_FLAG, @@ -95,7 +95,7 @@ typedef struct QemuOptDesc { struct QemuOptsList { const char *name; - TAILQ_HEAD(, QemuOpts) head; + QTAILQ_HEAD(, QemuOpts) head; QemuOptDesc desc[]; }; diff --git a/sys-queue.h b/qemu-queue.h index eb89a4d21..8877efd7b 100644 --- a/sys-queue.h +++ b/qemu-queue.h @@ -36,8 +36,8 @@ * @(#)queue.h 8.5 (Berkeley) 8/20/94 */ -#ifndef _SYS_QUEUE_H_ -#define _SYS_QUEUE_H_ +#ifndef QEMU_SYS_QUEUE_H_ +#define QEMU_SYS_QUEUE_H_ /* * This file defines three types of data structures: @@ -71,15 +71,15 @@ /* * List definitions. */ -#define LIST_HEAD(name, type) \ +#define QLIST_HEAD(name, type) \ struct name { \ struct type *lh_first; /* first element */ \ } -#define LIST_HEAD_INITIALIZER(head) \ +#define QLIST_HEAD_INITIALIZER(head) \ { NULL } -#define LIST_ENTRY(type) \ +#define QLIST_ENTRY(type) \ struct { \ struct type *le_next; /* next element */ \ struct type **le_prev; /* address of previous next element */ \ @@ -88,11 +88,11 @@ struct { \ /* * List functions. */ -#define LIST_INIT(head) do { \ +#define QLIST_INIT(head) do { \ (head)->lh_first = NULL; \ } while (/*CONSTCOND*/0) -#define LIST_INSERT_AFTER(listelm, elm, field) do { \ +#define QLIST_INSERT_AFTER(listelm, elm, field) do { \ if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \ (listelm)->field.le_next->field.le_prev = \ &(elm)->field.le_next; \ @@ -100,33 +100,33 @@ struct { \ (elm)->field.le_prev = &(listelm)->field.le_next; \ } while (/*CONSTCOND*/0) -#define LIST_INSERT_BEFORE(listelm, elm, field) do { \ +#define QLIST_INSERT_BEFORE(listelm, elm, field) do { \ (elm)->field.le_prev = (listelm)->field.le_prev; \ (elm)->field.le_next = (listelm); \ *(listelm)->field.le_prev = (elm); \ (listelm)->field.le_prev = &(elm)->field.le_next; \ } while (/*CONSTCOND*/0) -#define LIST_INSERT_HEAD(head, elm, field) do { \ +#define QLIST_INSERT_HEAD(head, elm, field) do { \ if (((elm)->field.le_next = (head)->lh_first) != NULL) \ (head)->lh_first->field.le_prev = &(elm)->field.le_next;\ (head)->lh_first = (elm); \ (elm)->field.le_prev = &(head)->lh_first; \ } while (/*CONSTCOND*/0) -#define LIST_REMOVE(elm, field) do { \ +#define QLIST_REMOVE(elm, field) do { \ if ((elm)->field.le_next != NULL) \ (elm)->field.le_next->field.le_prev = \ (elm)->field.le_prev; \ *(elm)->field.le_prev = (elm)->field.le_next; \ } while (/*CONSTCOND*/0) -#define LIST_FOREACH(var, head, field) \ +#define QLIST_FOREACH(var, head, field) \ for ((var) = ((head)->lh_first); \ (var); \ (var) = ((var)->field.le_next)) -#define LIST_FOREACH_SAFE(var, head, field, next_var) \ +#define QLIST_FOREACH_SAFE(var, head, field, next_var) \ for ((var) = ((head)->lh_first); \ (var) && ((next_var) = ((var)->field.le_next), 1); \ (var) = (next_var)) @@ -134,40 +134,40 @@ struct { \ /* * List access methods. */ -#define LIST_EMPTY(head) ((head)->lh_first == NULL) -#define LIST_FIRST(head) ((head)->lh_first) -#define LIST_NEXT(elm, field) ((elm)->field.le_next) +#define QLIST_EMPTY(head) ((head)->lh_first == NULL) +#define QLIST_FIRST(head) ((head)->lh_first) +#define QLIST_NEXT(elm, field) ((elm)->field.le_next) /* * Tail queue definitions. */ -#define _TAILQ_HEAD(name, type, qual) \ +#define Q_TAILQ_HEAD(name, type, qual) \ struct name { \ qual type *tqh_first; /* first element */ \ qual type *qual *tqh_last; /* addr of last next element */ \ } -#define TAILQ_HEAD(name, type) _TAILQ_HEAD(name, struct type,) +#define QTAILQ_HEAD(name, type) Q_TAILQ_HEAD(name, struct type,) -#define TAILQ_HEAD_INITIALIZER(head) \ +#define QTAILQ_HEAD_INITIALIZER(head) \ { NULL, &(head).tqh_first } -#define _TAILQ_ENTRY(type, qual) \ +#define Q_TAILQ_ENTRY(type, qual) \ struct { \ qual type *tqe_next; /* next element */ \ qual type *qual *tqe_prev; /* address of previous next element */\ } -#define TAILQ_ENTRY(type) _TAILQ_ENTRY(struct type,) +#define QTAILQ_ENTRY(type) Q_TAILQ_ENTRY(struct type,) /* * Tail queue functions. */ -#define TAILQ_INIT(head) do { \ +#define QTAILQ_INIT(head) do { \ (head)->tqh_first = NULL; \ (head)->tqh_last = &(head)->tqh_first; \ } while (/*CONSTCOND*/0) -#define TAILQ_INSERT_HEAD(head, elm, field) do { \ +#define QTAILQ_INSERT_HEAD(head, elm, field) do { \ if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \ (head)->tqh_first->field.tqe_prev = \ &(elm)->field.tqe_next; \ @@ -177,14 +177,14 @@ struct { \ (elm)->field.tqe_prev = &(head)->tqh_first; \ } while (/*CONSTCOND*/0) -#define TAILQ_INSERT_TAIL(head, elm, field) do { \ +#define QTAILQ_INSERT_TAIL(head, elm, field) do { \ (elm)->field.tqe_next = NULL; \ (elm)->field.tqe_prev = (head)->tqh_last; \ *(head)->tqh_last = (elm); \ (head)->tqh_last = &(elm)->field.tqe_next; \ } while (/*CONSTCOND*/0) -#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ +#define QTAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\ (elm)->field.tqe_next->field.tqe_prev = \ &(elm)->field.tqe_next; \ @@ -194,14 +194,14 @@ struct { \ (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \ } while (/*CONSTCOND*/0) -#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ +#define QTAILQ_INSERT_BEFORE(listelm, elm, field) do { \ (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ (elm)->field.tqe_next = (listelm); \ *(listelm)->field.tqe_prev = (elm); \ (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \ } while (/*CONSTCOND*/0) -#define TAILQ_REMOVE(head, elm, field) do { \ +#define QTAILQ_REMOVE(head, elm, field) do { \ if (((elm)->field.tqe_next) != NULL) \ (elm)->field.tqe_next->field.tqe_prev = \ (elm)->field.tqe_prev; \ @@ -210,17 +210,17 @@ struct { \ *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ } while (/*CONSTCOND*/0) -#define TAILQ_FOREACH(var, head, field) \ +#define QTAILQ_FOREACH(var, head, field) \ for ((var) = ((head)->tqh_first); \ (var); \ (var) = ((var)->field.tqe_next)) -#define TAILQ_FOREACH_SAFE(var, head, field, next_var) \ +#define QTAILQ_FOREACH_SAFE(var, head, field, next_var) \ for ((var) = ((head)->tqh_first); \ (var) && ((next_var) = ((var)->field.tqe_next), 1); \ (var) = (next_var)) -#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ +#define QTAILQ_FOREACH_REVERSE(var, head, headname, field) \ for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last)); \ (var); \ (var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last))) @@ -228,29 +228,29 @@ struct { \ /* * Tail queue access methods. */ -#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL) -#define TAILQ_FIRST(head) ((head)->tqh_first) -#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) +#define QTAILQ_EMPTY(head) ((head)->tqh_first == NULL) +#define QTAILQ_FIRST(head) ((head)->tqh_first) +#define QTAILQ_NEXT(elm, field) ((elm)->field.tqe_next) -#define TAILQ_LAST(head, headname) \ +#define QTAILQ_LAST(head, headname) \ (*(((struct headname *)((head)->tqh_last))->tqh_last)) -#define TAILQ_PREV(elm, headname, field) \ +#define QTAILQ_PREV(elm, headname, field) \ (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) /* * Circular queue definitions. */ -#define CIRCLEQ_HEAD(name, type) \ +#define QCIRCLEQ_HEAD(name, type) \ struct name { \ struct type *cqh_first; /* first element */ \ struct type *cqh_last; /* last element */ \ } -#define CIRCLEQ_HEAD_INITIALIZER(head) \ +#define QCIRCLEQ_HEAD_INITIALIZER(head) \ { (void *)&head, (void *)&head } -#define CIRCLEQ_ENTRY(type) \ +#define QCIRCLEQ_ENTRY(type) \ struct { \ struct type *cqe_next; /* next element */ \ struct type *cqe_prev; /* previous element */ \ @@ -259,12 +259,12 @@ struct { \ /* * Circular queue functions. */ -#define CIRCLEQ_INIT(head) do { \ +#define QCIRCLEQ_INIT(head) do { \ (head)->cqh_first = (void *)(head); \ (head)->cqh_last = (void *)(head); \ } while (/*CONSTCOND*/0) -#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ +#define QCIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ (elm)->field.cqe_next = (listelm)->field.cqe_next; \ (elm)->field.cqe_prev = (listelm); \ if ((listelm)->field.cqe_next == (void *)(head)) \ @@ -274,7 +274,7 @@ struct { \ (listelm)->field.cqe_next = (elm); \ } while (/*CONSTCOND*/0) -#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \ +#define QCIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \ (elm)->field.cqe_next = (listelm); \ (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \ if ((listelm)->field.cqe_prev == (void *)(head)) \ @@ -284,7 +284,7 @@ struct { \ (listelm)->field.cqe_prev = (elm); \ } while (/*CONSTCOND*/0) -#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \ +#define QCIRCLEQ_INSERT_HEAD(head, elm, field) do { \ (elm)->field.cqe_next = (head)->cqh_first; \ (elm)->field.cqe_prev = (void *)(head); \ if ((head)->cqh_last == (void *)(head)) \ @@ -294,7 +294,7 @@ struct { \ (head)->cqh_first = (elm); \ } while (/*CONSTCOND*/0) -#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \ +#define QCIRCLEQ_INSERT_TAIL(head, elm, field) do { \ (elm)->field.cqe_next = (void *)(head); \ (elm)->field.cqe_prev = (head)->cqh_last; \ if ((head)->cqh_first == (void *)(head)) \ @@ -304,7 +304,7 @@ struct { \ (head)->cqh_last = (elm); \ } while (/*CONSTCOND*/0) -#define CIRCLEQ_REMOVE(head, elm, field) do { \ +#define QCIRCLEQ_REMOVE(head, elm, field) do { \ if ((elm)->field.cqe_next == (void *)(head)) \ (head)->cqh_last = (elm)->field.cqe_prev; \ else \ @@ -317,12 +317,12 @@ struct { \ (elm)->field.cqe_next; \ } while (/*CONSTCOND*/0) -#define CIRCLEQ_FOREACH(var, head, field) \ +#define QCIRCLEQ_FOREACH(var, head, field) \ for ((var) = ((head)->cqh_first); \ (var) != (const void *)(head); \ (var) = ((var)->field.cqe_next)) -#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \ +#define QCIRCLEQ_FOREACH_REVERSE(var, head, field) \ for ((var) = ((head)->cqh_last); \ (var) != (const void *)(head); \ (var) = ((var)->field.cqe_prev)) @@ -330,19 +330,19 @@ struct { \ /* * Circular queue access methods. */ -#define CIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head)) -#define CIRCLEQ_FIRST(head) ((head)->cqh_first) -#define CIRCLEQ_LAST(head) ((head)->cqh_last) -#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next) -#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev) +#define QCIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head)) +#define QCIRCLEQ_FIRST(head) ((head)->cqh_first) +#define QCIRCLEQ_LAST(head) ((head)->cqh_last) +#define QCIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next) +#define QCIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev) -#define CIRCLEQ_LOOP_NEXT(head, elm, field) \ +#define QCIRCLEQ_LOOP_NEXT(head, elm, field) \ (((elm)->field.cqe_next == (void *)(head)) \ ? ((head)->cqh_first) \ : (elm->field.cqe_next)) -#define CIRCLEQ_LOOP_PREV(head, elm, field) \ +#define QCIRCLEQ_LOOP_PREV(head, elm, field) \ (((elm)->field.cqe_prev == (void *)(head)) \ ? ((head)->cqh_last) \ : (elm->field.cqe_prev)) -#endif /* !_SYS_QUEUE_H_ */ +#endif /* !QEMU_SYS_QUEUE_H_ */ diff --git a/qemu-sockets.c b/qemu-sockets.c index b80279c86..3cdff4c20 100644 --- a/qemu-sockets.c +++ b/qemu-sockets.c @@ -32,7 +32,7 @@ static const int on=1, off=0; /* used temporarely until all users are converted to QemuOpts */ QemuOptsList dummy_opts = { .name = "dummy", - .head = TAILQ_HEAD_INITIALIZER(dummy_opts.head), + .head = QTAILQ_HEAD_INITIALIZER(dummy_opts.head), .desc = { { .name = "path", @@ -90,6 +90,7 @@ #include "audio/audio.h" #include "migration.h" #include "qemu_socket.h" +#include "qemu-queue.h" /* point to the block driver where the snapshots are managed */ static BlockDriverState *bs_snapshots; @@ -910,7 +911,7 @@ const VMStateInfo vmstate_info_buffer = { }; typedef struct SaveStateEntry { - TAILQ_ENTRY(SaveStateEntry) entry; + QTAILQ_ENTRY(SaveStateEntry) entry; char idstr[256]; int instance_id; int version_id; @@ -922,8 +923,8 @@ typedef struct SaveStateEntry { void *opaque; } SaveStateEntry; -static TAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers = - TAILQ_HEAD_INITIALIZER(savevm_handlers); +static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers = + QTAILQ_HEAD_INITIALIZER(savevm_handlers); static int global_section_id; static int calculate_new_instance_id(const char *idstr) @@ -931,7 +932,7 @@ static int calculate_new_instance_id(const char *idstr) SaveStateEntry *se; int instance_id = 0; - TAILQ_FOREACH(se, &savevm_handlers, entry) { + QTAILQ_FOREACH(se, &savevm_handlers, entry) { if (strcmp(idstr, se->idstr) == 0 && instance_id <= se->instance_id) { instance_id = se->instance_id + 1; @@ -970,7 +971,7 @@ int register_savevm_live(const char *idstr, se->instance_id = instance_id; } /* add at the end of list */ - TAILQ_INSERT_TAIL(&savevm_handlers, se, entry); + QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry); return 0; } @@ -989,9 +990,9 @@ void unregister_savevm(const char *idstr, void *opaque) { SaveStateEntry *se, *new_se; - TAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) { + QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) { if (strcmp(se->idstr, idstr) == 0 && se->opaque == opaque) { - TAILQ_REMOVE(&savevm_handlers, se, entry); + QTAILQ_REMOVE(&savevm_handlers, se, entry); qemu_free(se); } } @@ -1018,7 +1019,7 @@ int vmstate_register(int instance_id, const VMStateDescription *vmsd, se->instance_id = instance_id; } /* add at the end of list */ - TAILQ_INSERT_TAIL(&savevm_handlers, se, entry); + QTAILQ_INSERT_TAIL(&savevm_handlers, se, entry); return 0; } @@ -1026,9 +1027,9 @@ void vmstate_unregister(const VMStateDescription *vmsd, void *opaque) { SaveStateEntry *se, *new_se; - TAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) { + QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) { if (se->vmsd == vmsd && se->opaque == opaque) { - TAILQ_REMOVE(&savevm_handlers, se, entry); + QTAILQ_REMOVE(&savevm_handlers, se, entry); qemu_free(se); } } @@ -1158,7 +1159,7 @@ int qemu_savevm_state_begin(QEMUFile *f) qemu_put_be32(f, QEMU_VM_FILE_MAGIC); qemu_put_be32(f, QEMU_VM_FILE_VERSION); - TAILQ_FOREACH(se, &savevm_handlers, entry) { + QTAILQ_FOREACH(se, &savevm_handlers, entry) { int len; if (se->save_live_state == NULL) @@ -1190,7 +1191,7 @@ int qemu_savevm_state_iterate(QEMUFile *f) SaveStateEntry *se; int ret = 1; - TAILQ_FOREACH(se, &savevm_handlers, entry) { + QTAILQ_FOREACH(se, &savevm_handlers, entry) { if (se->save_live_state == NULL) continue; @@ -1214,7 +1215,7 @@ int qemu_savevm_state_complete(QEMUFile *f) { SaveStateEntry *se; - TAILQ_FOREACH(se, &savevm_handlers, entry) { + QTAILQ_FOREACH(se, &savevm_handlers, entry) { if (se->save_live_state == NULL) continue; @@ -1225,7 +1226,7 @@ int qemu_savevm_state_complete(QEMUFile *f) se->save_live_state(f, QEMU_VM_SECTION_END, se->opaque); } - TAILQ_FOREACH(se, &savevm_handlers, entry) { + QTAILQ_FOREACH(se, &savevm_handlers, entry) { int len; if (se->save_state == NULL && se->vmsd == NULL) @@ -1290,7 +1291,7 @@ static SaveStateEntry *find_se(const char *idstr, int instance_id) { SaveStateEntry *se; - TAILQ_FOREACH(se, &savevm_handlers, entry) { + QTAILQ_FOREACH(se, &savevm_handlers, entry) { if (!strcmp(se->idstr, idstr) && instance_id == se->instance_id) return se; @@ -1299,7 +1300,7 @@ static SaveStateEntry *find_se(const char *idstr, int instance_id) } typedef struct LoadStateEntry { - LIST_ENTRY(LoadStateEntry) entry; + QLIST_ENTRY(LoadStateEntry) entry; SaveStateEntry *se; int section_id; int version_id; @@ -1307,8 +1308,8 @@ typedef struct LoadStateEntry { int qemu_loadvm_state(QEMUFile *f) { - LIST_HEAD(, LoadStateEntry) loadvm_handlers = - LIST_HEAD_INITIALIZER(loadvm_handlers); + QLIST_HEAD(, LoadStateEntry) loadvm_handlers = + QLIST_HEAD_INITIALIZER(loadvm_handlers); LoadStateEntry *le, *new_le; uint8_t section_type; unsigned int v; @@ -1365,7 +1366,7 @@ int qemu_loadvm_state(QEMUFile *f) le->se = se; le->section_id = section_id; le->version_id = version_id; - LIST_INSERT_HEAD(&loadvm_handlers, le, entry); + QLIST_INSERT_HEAD(&loadvm_handlers, le, entry); ret = vmstate_load(f, le->se, le->version_id); if (ret < 0) { @@ -1378,7 +1379,7 @@ int qemu_loadvm_state(QEMUFile *f) case QEMU_VM_SECTION_END: section_id = qemu_get_be32(f); - LIST_FOREACH(le, &loadvm_handlers, entry) { + QLIST_FOREACH(le, &loadvm_handlers, entry) { if (le->section_id == section_id) { break; } @@ -1406,8 +1407,8 @@ int qemu_loadvm_state(QEMUFile *f) ret = 0; out: - LIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) { - LIST_REMOVE(le, entry); + QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) { + QLIST_REMOVE(le, entry); qemu_free(le); } @@ -1440,7 +1441,7 @@ static BlockDriverState *get_bs_snapshots(void) if (bs_snapshots) return bs_snapshots; - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { bs = dinfo->bdrv; if (bdrv_can_snapshot(bs)) goto ok; @@ -1545,7 +1546,7 @@ void do_savevm(Monitor *mon, const QDict *qdict) /* create the snapshots */ - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { bs1 = dinfo->bdrv; if (bdrv_has_snapshot(bs1)) { if (must_delete) { @@ -1588,7 +1589,7 @@ int load_vmstate(Monitor *mon, const char *name) /* Flush all IO requests so they don't interfere with the new state. */ qemu_aio_flush(); - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { bs1 = dinfo->bdrv; if (bdrv_has_snapshot(bs1)) { ret = bdrv_snapshot_goto(bs1, name); @@ -1651,7 +1652,7 @@ void do_delvm(Monitor *mon, const QDict *qdict) return; } - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { bs1 = dinfo->bdrv; if (bdrv_has_snapshot(bs1)) { ret = bdrv_snapshot_delete(bs1, name); @@ -1682,7 +1683,7 @@ void do_info_snapshots(Monitor *mon) return; } monitor_printf(mon, "Snapshot devices:"); - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { bs1 = dinfo->bdrv; if (bdrv_has_snapshot(bs1)) { if (bs == bs1) diff --git a/slirp/slirp.c b/slirp/slirp.c index d4a9bacf1..6731f529f 100644 --- a/slirp/slirp.c +++ b/slirp/slirp.c @@ -44,8 +44,8 @@ u_int curtime; static u_int time_fasttimo, last_slowtimo; static int do_slowtimo; -static TAILQ_HEAD(slirp_instances, Slirp) slirp_instances = - TAILQ_HEAD_INITIALIZER(slirp_instances); +static QTAILQ_HEAD(slirp_instances, Slirp) slirp_instances = + QTAILQ_HEAD_INITIALIZER(slirp_instances); static struct in_addr dns_addr; static u_int dns_addr_time; @@ -234,14 +234,14 @@ Slirp *slirp_init(int restricted, struct in_addr vnetwork, register_savevm("slirp", 0, 3, slirp_state_save, slirp_state_load, slirp); - TAILQ_INSERT_TAIL(&slirp_instances, slirp, entry); + QTAILQ_INSERT_TAIL(&slirp_instances, slirp, entry); return slirp; } void slirp_cleanup(Slirp *slirp) { - TAILQ_REMOVE(&slirp_instances, slirp, entry); + QTAILQ_REMOVE(&slirp_instances, slirp, entry); unregister_savevm("slirp", slirp); @@ -261,7 +261,7 @@ void slirp_select_fill(int *pnfds, struct socket *so, *so_next; int nfds; - if (TAILQ_EMPTY(&slirp_instances)) { + if (QTAILQ_EMPTY(&slirp_instances)) { return; } @@ -276,7 +276,7 @@ void slirp_select_fill(int *pnfds, */ do_slowtimo = 0; - TAILQ_FOREACH(slirp, &slirp_instances, entry) { + QTAILQ_FOREACH(slirp, &slirp_instances, entry) { /* * *_slowtimo needs calling if there are IP fragments * in the fragment queue, or there are TCP connections active @@ -384,7 +384,7 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds, struct socket *so, *so_next; int ret; - if (TAILQ_EMPTY(&slirp_instances)) { + if (QTAILQ_EMPTY(&slirp_instances)) { return; } @@ -394,7 +394,7 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds, curtime = qemu_get_clock(rt_clock); - TAILQ_FOREACH(slirp, &slirp_instances, entry) { + QTAILQ_FOREACH(slirp, &slirp_instances, entry) { /* * See if anything has timed out */ diff --git a/slirp/slirp.h b/slirp/slirp.h index 020412caf..9ef57ea39 100644 --- a/slirp/slirp.h +++ b/slirp/slirp.h @@ -174,7 +174,7 @@ int inet_aton(const char *cp, struct in_addr *ia); #include "debug.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "libslirp.h" #include "ip.h" @@ -198,7 +198,7 @@ int inet_aton(const char *cp, struct in_addr *ia); #include "tftp.h" struct Slirp { - TAILQ_ENTRY(Slirp) entry; + QTAILQ_ENTRY(Slirp) entry; /* virtual network configuration */ struct in_addr vnetwork_addr; @@ -4,7 +4,7 @@ #include "qemu-common.h" #include "qemu-option.h" -#include "sys-queue.h" +#include "qemu-queue.h" #include "qdict.h" #ifdef _WIN32 @@ -176,15 +176,15 @@ typedef struct DriveInfo { QemuOpts *opts; BlockInterfaceErrorAction onerror; char serial[BLOCK_SERIAL_STRLEN + 1]; - TAILQ_ENTRY(DriveInfo) next; + QTAILQ_ENTRY(DriveInfo) next; } DriveInfo; #define MAX_IDE_DEVS 2 #define MAX_SCSI_DEVS 7 #define MAX_DRIVES 32 -extern TAILQ_HEAD(drivelist, DriveInfo) drives; -extern TAILQ_HEAD(driveoptlist, DriveOpt) driveopts; +extern QTAILQ_HEAD(drivelist, DriveInfo) drives; +extern QTAILQ_HEAD(driveoptlist, DriveOpt) driveopts; extern DriveInfo *extboot_drive; extern DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit); diff --git a/target-alpha/translate.c b/target-alpha/translate.c index 1dd85629b..9d2bc45d8 100644 --- a/target-alpha/translate.c +++ b/target-alpha/translate.c @@ -2367,8 +2367,8 @@ static inline void gen_intermediate_code_internal(CPUState *env, gen_icount_start(); for (ret = 0; ret == 0;) { - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == ctx.pc) { gen_excp(&ctx, EXCP_DEBUG, 0); break; diff --git a/target-arm/translate.c b/target-arm/translate.c index 4db8d0e26..c1d0dcf16 100644 --- a/target-arm/translate.c +++ b/target-arm/translate.c @@ -8770,8 +8770,8 @@ static inline void gen_intermediate_code_internal(CPUState *env, } #endif - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == dc->pc) { gen_set_condexec(dc); gen_set_pc_im(dc->pc); diff --git a/target-cris/translate.c b/target-cris/translate.c index bd3ae3d76..c6068f78f 100644 --- a/target-cris/translate.c +++ b/target-cris/translate.c @@ -3082,8 +3082,8 @@ static void check_breakpoint(CPUState *env, DisasContext *dc) { CPUBreakpoint *bp; - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == dc->pc) { cris_evaluate_flags (dc); tcg_gen_movi_tl(env_pc, dc->pc); diff --git a/target-i386/helper.c b/target-i386/helper.c index aafcc7afe..8fd87b588 100644 --- a/target-i386/helper.c +++ b/target-i386/helper.c @@ -1523,7 +1523,7 @@ static void breakpoint_handler(CPUState *env) cpu_resume_from_signal(env, NULL); } } else { - TAILQ_FOREACH(bp, &env->breakpoints, entry) + QTAILQ_FOREACH(bp, &env->breakpoints, entry) if (bp->pc == env->eip) { if (bp->flags & BP_CPU) { check_hw_breakpoints(env, 1); diff --git a/target-i386/translate.c b/target-i386/translate.c index ff9398575..335fc0842 100644 --- a/target-i386/translate.c +++ b/target-i386/translate.c @@ -7687,8 +7687,8 @@ static inline void gen_intermediate_code_internal(CPUState *env, gen_icount_start(); for(;;) { - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == pc_ptr && !((bp->flags & BP_CPU) && (tb->flags & HF_RF_MASK))) { gen_debug(dc, pc_ptr - dc->cs_base); diff --git a/target-m68k/translate.c b/target-m68k/translate.c index b37578baf..99cf6ddef 100644 --- a/target-m68k/translate.c +++ b/target-m68k/translate.c @@ -2999,8 +2999,8 @@ gen_intermediate_code_internal(CPUState *env, TranslationBlock *tb, do { pc_offset = dc->pc - pc_start; gen_throws_exception = NULL; - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == dc->pc) { gen_exception(dc, dc->pc, EXCP_DEBUG); dc->is_jmp = DISAS_JUMP; diff --git a/target-microblaze/translate.c b/target-microblaze/translate.c index fe53b2e14..dfeb8ae84 100644 --- a/target-microblaze/translate.c +++ b/target-microblaze/translate.c @@ -1230,8 +1230,8 @@ static void check_breakpoint(CPUState *env, DisasContext *dc) { CPUBreakpoint *bp; - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == dc->pc) { t_gen_raise_exception(dc, EXCP_DEBUG); dc->is_jmp = DISAS_UPDATE; diff --git a/target-mips/translate.c b/target-mips/translate.c index a2b2edbbd..fb3c980c1 100644 --- a/target-mips/translate.c +++ b/target-mips/translate.c @@ -8314,8 +8314,8 @@ gen_intermediate_code_internal (CPUState *env, TranslationBlock *tb, LOG_DISAS("\ntb %p idx %d hflags %04x\n", tb, ctx.mem_idx, ctx.hflags); gen_icount_start(); while (ctx.bstate == BS_NONE) { - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == ctx.pc) { save_cpu_state(&ctx, 1); ctx.bstate = BS_BRANCH; diff --git a/target-ppc/translate.c b/target-ppc/translate.c index 1c54fa7d8..648bf9e18 100644 --- a/target-ppc/translate.c +++ b/target-ppc/translate.c @@ -9000,8 +9000,8 @@ static inline void gen_intermediate_code_internal(CPUState *env, gen_icount_start(); /* Set env in case of segfault during code fetch */ while (ctx.exception == POWERPC_EXCP_NONE && gen_opc_ptr < gen_opc_end) { - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == ctx.nip) { gen_debug_exception(ctxp); break; diff --git a/target-sh4/translate.c b/target-sh4/translate.c index b272f4c06..895b978d3 100644 --- a/target-sh4/translate.c +++ b/target-sh4/translate.c @@ -1927,8 +1927,8 @@ gen_intermediate_code_internal(CPUState * env, TranslationBlock * tb, max_insns = CF_COUNT_MASK; gen_icount_start(); while (ctx.bstate == BS_NONE && gen_opc_ptr < gen_opc_end) { - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (ctx.pc == bp->pc) { /* We have hit a breakpoint - make sure PC is up-to-date */ tcg_gen_movi_i32(cpu_pc, ctx.pc); diff --git a/target-sparc/translate.c b/target-sparc/translate.c index 61578ecc3..928aa61ad 100644 --- a/target-sparc/translate.c +++ b/target-sparc/translate.c @@ -4706,8 +4706,8 @@ static inline void gen_intermediate_code_internal(TranslationBlock * tb, max_insns = CF_COUNT_MASK; gen_icount_start(); do { - if (unlikely(!TAILQ_EMPTY(&env->breakpoints))) { - TAILQ_FOREACH(bp, &env->breakpoints, entry) { + if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) { + QTAILQ_FOREACH(bp, &env->breakpoints, entry) { if (bp->pc == dc->pc) { if (dc->pc != pc_start) save_state(dc, cpu_cond); @@ -63,6 +63,7 @@ typedef struct USBHostDevice { } USBHostDevice; +#if 0 static int ensure_ep_open(USBHostDevice *dev, int ep, int mode) { char buf[32]; @@ -110,6 +111,7 @@ static void ensure_eps_closed(USBHostDevice *dev) epnum++; } } +#endif static void usb_host_handle_reset(USBDevice *dev) { @@ -118,6 +120,7 @@ static void usb_host_handle_reset(USBDevice *dev) #endif } +#if 0 /* XXX: * -check device states against transfer requests * and return appropriate response @@ -275,6 +278,7 @@ static int usb_host_handle_data(USBDevice *dev, USBPacket *p) return ret; } } +#endif static void usb_host_handle_destroy(USBDevice *opaque) { @@ -293,9 +297,15 @@ static void usb_host_handle_destroy(USBDevice *opaque) qemu_free(s); } +static int usb_host_initfn(USBDevice *dev) +{ + return 0; +} + USBDevice *usb_host_device_open(const char *devname) { struct usb_device_info bus_info, dev_info; + USBDevice *d = NULL; USBHostDevice *dev; char ctlpath[PATH_MAX + 1]; char buspath[PATH_MAX + 1]; @@ -343,9 +353,6 @@ USBDevice *usb_host_device_open(const char *devname) } if (dfd >= 0) { - dev = qemu_mallocz(sizeof(USBHostDevice)); - dev->devfd = dfd; - if (ioctl(dfd, USB_GET_DEVICEINFO, &dev_info) < 0) { #ifdef DEBUG printf("usb_host_device_open: failed to grab device info - %s\n", @@ -354,18 +361,14 @@ USBDevice *usb_host_device_open(const char *devname) goto fail; } + d = usb_create(NULL /* FIXME */, "USB Host Device"); + dev = DO_UPCAST(USBHostDevice, dev, d); + if (dev_info.udi_speed == 1) dev->dev.speed = USB_SPEED_LOW - 1; else dev->dev.speed = USB_SPEED_FULL - 1; - dev->dev.handle_packet = usb_generic_handle_packet; - - dev->dev.handle_reset = usb_host_handle_reset; - dev->dev.handle_control = usb_host_handle_control; - dev->dev.handle_data = usb_host_handle_data; - dev->dev.handle_destroy = usb_host_handle_destroy; - if (strncmp(dev_info.udi_product, "product", 7) != 0) pstrcpy(dev->dev.devname, sizeof(dev->dev.devname), dev_info.udi_product); @@ -389,6 +392,25 @@ fail: return NULL; } +static struct USBDeviceInfo usb_host_dev_info = { + .qdev.name = "USB Host Device", + .qdev.size = sizeof(USBHostDevice), + .init = usb_host_initfn, + .handle_packet = usb_generic_handle_packet, + .handle_reset = usb_host_handle_reset, +#if 0 + .handle_control = usb_host_handle_control, + .handle_data = usb_host_handle_data, +#endif + .handle_destroy = usb_host_handle_destroy, +}; + +static void usb_host_register_devices(void) +{ + usb_qdev_register(&usb_host_dev_info); +} +device_init(usb_host_register_devices) + static int usb_host_scan(void *opaque, USBScanFunc *func) { struct usb_device_info bus_info; diff --git a/usb-linux.c b/usb-linux.c index c80499af9..c434e4f8a 100644 --- a/usb-linux.c +++ b/usb-linux.c @@ -583,9 +583,9 @@ static int usb_host_handle_control(USBHostDevice *s, USBPacket *p) buffer_len = 8 + s->ctrl.len; if (buffer_len > sizeof(s->ctrl.buffer)) { - fprintf(stderr, "husb: ctrl buffer too small (%u > %lu)\n", - buffer_len, sizeof(s->ctrl.buffer)); - return USB_RET_STALL; + fprintf(stderr, "husb: ctrl buffer too small (%u > %zu)\n", + buffer_len, sizeof(s->ctrl.buffer)); + return USB_RET_STALL; } aurb = async_alloc(); @@ -31,8 +31,6 @@ /* Needed early for CONFIG_BSD etc. */ #include "config-host.h" -/* Needed early to override system queue definitions on BSD */ -#include "sys-queue.h" #ifndef _WIN32 #include <libgen.h> @@ -170,6 +168,8 @@ int main(int argc, char **argv) #include "slirp/libslirp.h" +#include "qemu-queue.h" + //#define DEBUG_NET //#define DEBUG_SLIRP @@ -182,8 +182,8 @@ static const char *data_dir; const char *bios_name = NULL; /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available to store the VM snapshots */ -struct drivelist drives = TAILQ_HEAD_INITIALIZER(drives); -struct driveoptlist driveopts = TAILQ_HEAD_INITIALIZER(driveopts); +struct drivelist drives = QTAILQ_HEAD_INITIALIZER(drives); +struct driveoptlist driveopts = QTAILQ_HEAD_INITIALIZER(driveopts); DriveInfo *extboot_drive = NULL; enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB; static DisplayState *display_state; @@ -1824,7 +1824,7 @@ DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit) /* seek interface, bus and unit */ - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { if (dinfo->type == type && dinfo->bus == bus && dinfo->unit == unit) @@ -1838,7 +1838,7 @@ DriveInfo *drive_get_by_id(const char *id) { DriveInfo *dinfo; - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { if (strcmp(id, dinfo->id)) continue; return dinfo; @@ -1852,7 +1852,7 @@ int drive_get_max_bus(BlockInterfaceType type) DriveInfo *dinfo; max_bus = -1; - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { if(dinfo->type == type && dinfo->bus > max_bus) max_bus = dinfo->bus; @@ -1864,7 +1864,7 @@ const char *drive_get_serial(BlockDriverState *bdrv) { DriveInfo *dinfo; - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { if (dinfo->bdrv == bdrv) return dinfo->serial; } @@ -1876,7 +1876,7 @@ BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv) { DriveInfo *dinfo; - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { if (dinfo->bdrv == bdrv) return dinfo->onerror; } @@ -1893,11 +1893,11 @@ void drive_uninit(BlockDriverState *bdrv) { DriveInfo *dinfo; - TAILQ_FOREACH(dinfo, &drives, next) { + QTAILQ_FOREACH(dinfo, &drives, next) { if (dinfo->bdrv != bdrv) continue; qemu_opts_del(dinfo->opts); - TAILQ_REMOVE(&drives, dinfo, next); + QTAILQ_REMOVE(&drives, dinfo, next); qemu_free(dinfo); break; } @@ -2191,7 +2191,7 @@ DriveInfo *drive_init(QemuOpts *opts, void *opaque, dinfo->opts = opts; if (serial) strncpy(dinfo->serial, serial, sizeof(serial)); - TAILQ_INSERT_TAIL(&drives, dinfo, next); + QTAILQ_INSERT_TAIL(&drives, dinfo, next); if (is_extboot) { extboot_drive = dinfo; } @@ -3179,10 +3179,10 @@ static void nographic_update(void *opaque) struct vm_change_state_entry { VMChangeStateHandler *cb; void *opaque; - LIST_ENTRY (vm_change_state_entry) entries; + QLIST_ENTRY (vm_change_state_entry) entries; }; -static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head; +static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head; VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb, void *opaque) @@ -3193,13 +3193,13 @@ VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb, e->cb = cb; e->opaque = opaque; - LIST_INSERT_HEAD(&vm_change_state_head, e, entries); + QLIST_INSERT_HEAD(&vm_change_state_head, e, entries); return e; } void qemu_del_vm_change_state_handler(VMChangeStateEntry *e) { - LIST_REMOVE (e, entries); + QLIST_REMOVE (e, entries); qemu_free (e); } @@ -3229,13 +3229,13 @@ void vm_start(void) /* reset/shutdown handler */ typedef struct QEMUResetEntry { - TAILQ_ENTRY(QEMUResetEntry) entry; + QTAILQ_ENTRY(QEMUResetEntry) entry; QEMUResetHandler *func; void *opaque; } QEMUResetEntry; -static TAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers = - TAILQ_HEAD_INITIALIZER(reset_handlers); +static QTAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers = + QTAILQ_HEAD_INITIALIZER(reset_handlers); static int reset_requested; static int shutdown_requested; static int powerdown_requested; @@ -3300,16 +3300,16 @@ void qemu_register_reset(QEMUResetHandler *func, void *opaque) re->func = func; re->opaque = opaque; - TAILQ_INSERT_TAIL(&reset_handlers, re, entry); + QTAILQ_INSERT_TAIL(&reset_handlers, re, entry); } void qemu_unregister_reset(QEMUResetHandler *func, void *opaque) { QEMUResetEntry *re; - TAILQ_FOREACH(re, &reset_handlers, entry) { + QTAILQ_FOREACH(re, &reset_handlers, entry) { if (re->func == func && re->opaque == opaque) { - TAILQ_REMOVE(&reset_handlers, re, entry); + QTAILQ_REMOVE(&reset_handlers, re, entry); qemu_free(re); return; } @@ -3321,7 +3321,7 @@ void qemu_system_reset(void) QEMUResetEntry *re, *nre; /* reset all devices */ - TAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) { + QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) { re->func(re->opaque); } } @@ -4637,9 +4637,9 @@ struct device_config { DEV_BT, /* -bt */ } type; const char *cmdline; - TAILQ_ENTRY(device_config) next; + QTAILQ_ENTRY(device_config) next; }; -TAILQ_HEAD(, device_config) device_configs = TAILQ_HEAD_INITIALIZER(device_configs); +QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs); static void add_device_config(int type, const char *cmdline) { @@ -4648,7 +4648,7 @@ static void add_device_config(int type, const char *cmdline) conf = qemu_mallocz(sizeof(*conf)); conf->type = type; conf->cmdline = cmdline; - TAILQ_INSERT_TAIL(&device_configs, conf, next); + QTAILQ_INSERT_TAIL(&device_configs, conf, next); } static int foreach_device_config(int type, int (*func)(const char *cmdline)) @@ -4656,7 +4656,7 @@ static int foreach_device_config(int type, int (*func)(const char *cmdline)) struct device_config *conf; int rc; - TAILQ_FOREACH(conf, &device_configs, next) { + QTAILQ_FOREACH(conf, &device_configs, next) { if (conf->type != type) continue; rc = func(conf->cmdline); @@ -4713,7 +4713,7 @@ int main(int argc, char **argv, char **envp) qemu_errors_to_file(stderr); qemu_cache_utils_init(envp); - LIST_INIT (&vm_change_state_head); + QLIST_INIT (&vm_change_state_head); #ifndef _WIN32 { struct sigaction act; |