Revision 72cf2d4f vl.c
| b/vl.c | ||
|---|---|---|
| 31 | 31 |
|
| 32 | 32 |
/* Needed early for CONFIG_BSD etc. */ |
| 33 | 33 |
#include "config-host.h" |
| 34 |
/* Needed early to override system queue definitions on BSD */ |
|
| 35 |
#include "sys-queue.h" |
|
| 36 | 34 |
|
| 37 | 35 |
#ifndef _WIN32 |
| 38 | 36 |
#include <libgen.h> |
| ... | ... | |
| 168 | 166 |
|
| 169 | 167 |
#include "slirp/libslirp.h" |
| 170 | 168 |
|
| 169 |
#include "qemu-queue.h" |
|
| 170 |
|
|
| 171 | 171 |
//#define DEBUG_NET |
| 172 | 172 |
//#define DEBUG_SLIRP |
| 173 | 173 |
|
| ... | ... | |
| 180 | 180 |
const char *bios_name = NULL; |
| 181 | 181 |
/* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available |
| 182 | 182 |
to store the VM snapshots */ |
| 183 |
struct drivelist drives = TAILQ_HEAD_INITIALIZER(drives); |
|
| 184 |
struct driveoptlist driveopts = TAILQ_HEAD_INITIALIZER(driveopts); |
|
| 183 |
struct drivelist drives = QTAILQ_HEAD_INITIALIZER(drives);
|
|
| 184 |
struct driveoptlist driveopts = QTAILQ_HEAD_INITIALIZER(driveopts);
|
|
| 185 | 185 |
enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB; |
| 186 | 186 |
static DisplayState *display_state; |
| 187 | 187 |
DisplayType display_type = DT_DEFAULT; |
| ... | ... | |
| 1810 | 1810 |
|
| 1811 | 1811 |
/* seek interface, bus and unit */ |
| 1812 | 1812 |
|
| 1813 |
TAILQ_FOREACH(dinfo, &drives, next) {
|
|
| 1813 |
QTAILQ_FOREACH(dinfo, &drives, next) {
|
|
| 1814 | 1814 |
if (dinfo->type == type && |
| 1815 | 1815 |
dinfo->bus == bus && |
| 1816 | 1816 |
dinfo->unit == unit) |
| ... | ... | |
| 1824 | 1824 |
{
|
| 1825 | 1825 |
DriveInfo *dinfo; |
| 1826 | 1826 |
|
| 1827 |
TAILQ_FOREACH(dinfo, &drives, next) {
|
|
| 1827 |
QTAILQ_FOREACH(dinfo, &drives, next) {
|
|
| 1828 | 1828 |
if (strcmp(id, dinfo->id)) |
| 1829 | 1829 |
continue; |
| 1830 | 1830 |
return dinfo; |
| ... | ... | |
| 1838 | 1838 |
DriveInfo *dinfo; |
| 1839 | 1839 |
|
| 1840 | 1840 |
max_bus = -1; |
| 1841 |
TAILQ_FOREACH(dinfo, &drives, next) {
|
|
| 1841 |
QTAILQ_FOREACH(dinfo, &drives, next) {
|
|
| 1842 | 1842 |
if(dinfo->type == type && |
| 1843 | 1843 |
dinfo->bus > max_bus) |
| 1844 | 1844 |
max_bus = dinfo->bus; |
| ... | ... | |
| 1850 | 1850 |
{
|
| 1851 | 1851 |
DriveInfo *dinfo; |
| 1852 | 1852 |
|
| 1853 |
TAILQ_FOREACH(dinfo, &drives, next) {
|
|
| 1853 |
QTAILQ_FOREACH(dinfo, &drives, next) {
|
|
| 1854 | 1854 |
if (dinfo->bdrv == bdrv) |
| 1855 | 1855 |
return dinfo->serial; |
| 1856 | 1856 |
} |
| ... | ... | |
| 1862 | 1862 |
{
|
| 1863 | 1863 |
DriveInfo *dinfo; |
| 1864 | 1864 |
|
| 1865 |
TAILQ_FOREACH(dinfo, &drives, next) {
|
|
| 1865 |
QTAILQ_FOREACH(dinfo, &drives, next) {
|
|
| 1866 | 1866 |
if (dinfo->bdrv == bdrv) |
| 1867 | 1867 |
return dinfo->onerror; |
| 1868 | 1868 |
} |
| ... | ... | |
| 1879 | 1879 |
{
|
| 1880 | 1880 |
DriveInfo *dinfo; |
| 1881 | 1881 |
|
| 1882 |
TAILQ_FOREACH(dinfo, &drives, next) {
|
|
| 1882 |
QTAILQ_FOREACH(dinfo, &drives, next) {
|
|
| 1883 | 1883 |
if (dinfo->bdrv != bdrv) |
| 1884 | 1884 |
continue; |
| 1885 | 1885 |
qemu_opts_del(dinfo->opts); |
| 1886 |
TAILQ_REMOVE(&drives, dinfo, next); |
|
| 1886 |
QTAILQ_REMOVE(&drives, dinfo, next);
|
|
| 1887 | 1887 |
qemu_free(dinfo); |
| 1888 | 1888 |
break; |
| 1889 | 1889 |
} |
| ... | ... | |
| 2170 | 2170 |
dinfo->opts = opts; |
| 2171 | 2171 |
if (serial) |
| 2172 | 2172 |
strncpy(dinfo->serial, serial, sizeof(serial)); |
| 2173 |
TAILQ_INSERT_TAIL(&drives, dinfo, next); |
|
| 2173 |
QTAILQ_INSERT_TAIL(&drives, dinfo, next);
|
|
| 2174 | 2174 |
|
| 2175 | 2175 |
switch(type) {
|
| 2176 | 2176 |
case IF_IDE: |
| ... | ... | |
| 3145 | 3145 |
struct vm_change_state_entry {
|
| 3146 | 3146 |
VMChangeStateHandler *cb; |
| 3147 | 3147 |
void *opaque; |
| 3148 |
LIST_ENTRY (vm_change_state_entry) entries; |
|
| 3148 |
QLIST_ENTRY (vm_change_state_entry) entries;
|
|
| 3149 | 3149 |
}; |
| 3150 | 3150 |
|
| 3151 |
static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head; |
|
| 3151 |
static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
|
|
| 3152 | 3152 |
|
| 3153 | 3153 |
VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb, |
| 3154 | 3154 |
void *opaque) |
| ... | ... | |
| 3159 | 3159 |
|
| 3160 | 3160 |
e->cb = cb; |
| 3161 | 3161 |
e->opaque = opaque; |
| 3162 |
LIST_INSERT_HEAD(&vm_change_state_head, e, entries); |
|
| 3162 |
QLIST_INSERT_HEAD(&vm_change_state_head, e, entries);
|
|
| 3163 | 3163 |
return e; |
| 3164 | 3164 |
} |
| 3165 | 3165 |
|
| 3166 | 3166 |
void qemu_del_vm_change_state_handler(VMChangeStateEntry *e) |
| 3167 | 3167 |
{
|
| 3168 |
LIST_REMOVE (e, entries); |
|
| 3168 |
QLIST_REMOVE (e, entries);
|
|
| 3169 | 3169 |
qemu_free (e); |
| 3170 | 3170 |
} |
| 3171 | 3171 |
|
| ... | ... | |
| 3195 | 3195 |
/* reset/shutdown handler */ |
| 3196 | 3196 |
|
| 3197 | 3197 |
typedef struct QEMUResetEntry {
|
| 3198 |
TAILQ_ENTRY(QEMUResetEntry) entry; |
|
| 3198 |
QTAILQ_ENTRY(QEMUResetEntry) entry;
|
|
| 3199 | 3199 |
QEMUResetHandler *func; |
| 3200 | 3200 |
void *opaque; |
| 3201 | 3201 |
} QEMUResetEntry; |
| 3202 | 3202 |
|
| 3203 |
static TAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers = |
|
| 3204 |
TAILQ_HEAD_INITIALIZER(reset_handlers); |
|
| 3203 |
static QTAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers =
|
|
| 3204 |
QTAILQ_HEAD_INITIALIZER(reset_handlers);
|
|
| 3205 | 3205 |
static int reset_requested; |
| 3206 | 3206 |
static int shutdown_requested; |
| 3207 | 3207 |
static int powerdown_requested; |
| ... | ... | |
| 3259 | 3259 |
|
| 3260 | 3260 |
re->func = func; |
| 3261 | 3261 |
re->opaque = opaque; |
| 3262 |
TAILQ_INSERT_TAIL(&reset_handlers, re, entry); |
|
| 3262 |
QTAILQ_INSERT_TAIL(&reset_handlers, re, entry);
|
|
| 3263 | 3263 |
} |
| 3264 | 3264 |
|
| 3265 | 3265 |
void qemu_unregister_reset(QEMUResetHandler *func, void *opaque) |
| 3266 | 3266 |
{
|
| 3267 | 3267 |
QEMUResetEntry *re; |
| 3268 | 3268 |
|
| 3269 |
TAILQ_FOREACH(re, &reset_handlers, entry) {
|
|
| 3269 |
QTAILQ_FOREACH(re, &reset_handlers, entry) {
|
|
| 3270 | 3270 |
if (re->func == func && re->opaque == opaque) {
|
| 3271 |
TAILQ_REMOVE(&reset_handlers, re, entry); |
|
| 3271 |
QTAILQ_REMOVE(&reset_handlers, re, entry);
|
|
| 3272 | 3272 |
qemu_free(re); |
| 3273 | 3273 |
return; |
| 3274 | 3274 |
} |
| ... | ... | |
| 3280 | 3280 |
QEMUResetEntry *re, *nre; |
| 3281 | 3281 |
|
| 3282 | 3282 |
/* reset all devices */ |
| 3283 |
TAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) {
|
|
| 3283 |
QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) {
|
|
| 3284 | 3284 |
re->func(re->opaque); |
| 3285 | 3285 |
} |
| 3286 | 3286 |
} |
| ... | ... | |
| 4579 | 4579 |
DEV_BT, /* -bt */ |
| 4580 | 4580 |
} type; |
| 4581 | 4581 |
const char *cmdline; |
| 4582 |
TAILQ_ENTRY(device_config) next; |
|
| 4582 |
QTAILQ_ENTRY(device_config) next;
|
|
| 4583 | 4583 |
}; |
| 4584 |
TAILQ_HEAD(, device_config) device_configs = TAILQ_HEAD_INITIALIZER(device_configs);
|
|
| 4584 |
QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs);
|
|
| 4585 | 4585 |
|
| 4586 | 4586 |
static void add_device_config(int type, const char *cmdline) |
| 4587 | 4587 |
{
|
| ... | ... | |
| 4590 | 4590 |
conf = qemu_mallocz(sizeof(*conf)); |
| 4591 | 4591 |
conf->type = type; |
| 4592 | 4592 |
conf->cmdline = cmdline; |
| 4593 |
TAILQ_INSERT_TAIL(&device_configs, conf, next); |
|
| 4593 |
QTAILQ_INSERT_TAIL(&device_configs, conf, next);
|
|
| 4594 | 4594 |
} |
| 4595 | 4595 |
|
| 4596 | 4596 |
static int foreach_device_config(int type, int (*func)(const char *cmdline)) |
| ... | ... | |
| 4598 | 4598 |
struct device_config *conf; |
| 4599 | 4599 |
int rc; |
| 4600 | 4600 |
|
| 4601 |
TAILQ_FOREACH(conf, &device_configs, next) {
|
|
| 4601 |
QTAILQ_FOREACH(conf, &device_configs, next) {
|
|
| 4602 | 4602 |
if (conf->type != type) |
| 4603 | 4603 |
continue; |
| 4604 | 4604 |
rc = func(conf->cmdline); |
| ... | ... | |
| 4655 | 4655 |
qemu_errors_to_file(stderr); |
| 4656 | 4656 |
qemu_cache_utils_init(envp); |
| 4657 | 4657 |
|
| 4658 |
LIST_INIT (&vm_change_state_head); |
|
| 4658 |
QLIST_INIT (&vm_change_state_head);
|
|
| 4659 | 4659 |
#ifndef _WIN32 |
| 4660 | 4660 |
{
|
| 4661 | 4661 |
struct sigaction act; |
Also available in: Unified diff