live migration: Propagate output monitor to callback handler

[qemu.git] / vl.c

diff --git a/vl.c b/vl.c
index 19e11b2f704f3837ef678989a734e431e06dbebe..e9b75c9b8651b5aff1f2c818ec0003ad804fa672 100644 (file)
--- a/vl.c
+++ b/vl.c
@@ -44,25 +44,17 @@
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <net/if.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <net/if.h>

-#if defined(__NetBSD__)
-#include <net/if_tap.h>
-#endif
-#ifdef __linux__
-#include <linux/if_tun.h>
-#endif

 #include <arpa/inet.h>
 #include <dirent.h>
 #include <netdb.h>
 #include <sys/select.h>
 #ifdef CONFIG_BSD
 #include <sys/stat.h>
 #include <arpa/inet.h>
 #include <dirent.h>
 #include <netdb.h>
 #include <sys/select.h>
 #ifdef CONFIG_BSD
 #include <sys/stat.h>

-#if defined(__FreeBSD__) || defined(__DragonFly__)
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)

 #include <libutil.h>
 #else
 #include <util.h>
 #endif
 #include <libutil.h>
 #else
 #include <util.h>
 #endif

-#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
-#include <freebsd/stdlib.h>

 #else
 #ifdef __linux__
 #include <pty.h>
 #else
 #ifdef __linux__
 #include <pty.h>


@@ -143,8 +135,10 @@ int main(int argc, char **argv)
 #include "hw/smbios.h"
 #include "hw/xen.h"
 #include "hw/qdev.h"
 #include "hw/smbios.h"
 #include "hw/xen.h"
 #include "hw/qdev.h"

+#include "hw/loader.h"

 #include "bt-host.h"
 #include "net.h"
 #include "bt-host.h"
 #include "net.h"

+#include "net/slirp.h"

 #include "monitor.h"
 #include "console.h"
 #include "sysemu.h"
 #include "monitor.h"
 #include "console.h"
 #include "sysemu.h"


@@ -153,6 +147,8 @@ int main(int argc, char **argv)
 #include "qemu-char.h"
 #include "cache-utils.h"
 #include "block.h"
 #include "qemu-char.h"
 #include "cache-utils.h"
 #include "block.h"

+#include "block_int.h"
+#include "block-migration.h"

 #include "dma.h"
 #include "audio/audio.h"
 #include "migration.h"
 #include "dma.h"
 #include "audio/audio.h"
 #include "migration.h"


@@ -196,6 +192,7 @@ int vm_running;
 int autostart;
 static int rtc_utc = 1;
 static int rtc_date_offset = -1; /* -1 means no change */
 int autostart;
 static int rtc_utc = 1;
 static int rtc_date_offset = -1; /* -1 means no change */

+QEMUClock *rtc_clock;

 int vga_interface_type = VGA_CIRRUS;
 #ifdef TARGET_SPARC
 int graphic_width = 1024;
 int vga_interface_type = VGA_CIRRUS;
 #ifdef TARGET_SPARC
 int graphic_width = 1024;


@@ -245,6 +242,7 @@ int old_param = 0;
 #endif
 const char *qemu_name;
 int alt_grab = 0;
 #endif
 const char *qemu_name;
 int alt_grab = 0;

+int ctrl_grab = 0;

 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
 unsigned int nb_prom_envs = 0;
 const char *prom_envs[MAX_PROM_ENVS];
 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
 unsigned int nb_prom_envs = 0;
 const char *prom_envs[MAX_PROM_ENVS];


@@ -531,6 +529,14 @@ uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
 /***********************************************************/
 /* real time host monotonic timer */
 
 /***********************************************************/
 /* real time host monotonic timer */
 

+static int64_t get_clock_realtime(void)
+{
+    struct timeval tv;
+
+    gettimeofday(&tv, NULL);
+    return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
+}
+

 #ifdef WIN32
 
 static int64_t clock_freq;
 #ifdef WIN32
 
 static int64_t clock_freq;


@@ -562,7 +568,7 @@ static void init_get_clock(void)
 {
     use_rt_clock = 0;
 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
 {
     use_rt_clock = 0;
 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \

-    || defined(__DragonFly__)
+    || defined(__DragonFly__) || defined(__FreeBSD_kernel__)

     {
         struct timespec ts;
         if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
     {
         struct timespec ts;
         if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {


@@ -575,7 +581,7 @@ static void init_get_clock(void)
 static int64_t get_clock(void)
 {
 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
 static int64_t get_clock(void)
 {
 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \

-       || defined(__DragonFly__)
+       || defined(__DragonFly__) || defined(__FreeBSD_kernel__)

     if (use_rt_clock) {
         struct timespec ts;
         clock_gettime(CLOCK_MONOTONIC, &ts);
     if (use_rt_clock) {
         struct timespec ts;
         clock_gettime(CLOCK_MONOTONIC, &ts);


@@ -585,9 +591,7 @@ static int64_t get_clock(void)
     {
         /* XXX: using gettimeofday leads to problems if the date
            changes, so it should be avoided. */
     {
         /* XXX: using gettimeofday leads to problems if the date
            changes, so it should be avoided. */

-        struct timeval tv;
-        gettimeofday(&tv, NULL);
-        return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
+        return get_clock_realtime();

     }
 }
 #endif
     }
 }
 #endif


@@ -676,8 +680,9 @@ void cpu_disable_ticks(void)
 /***********************************************************/
 /* timers */
 
 /***********************************************************/
 /* timers */
 

-#define QEMU_TIMER_REALTIME 0
-#define QEMU_TIMER_VIRTUAL  1
+#define QEMU_CLOCK_REALTIME 0
+#define QEMU_CLOCK_VIRTUAL  1
+#define QEMU_CLOCK_HOST     2

 
 struct QEMUClock {
     int type;
 
 struct QEMUClock {
     int type;


@@ -904,10 +909,13 @@ next:
     }
 }
 
     }
 }
 

+#define QEMU_NUM_CLOCKS 3
+

 QEMUClock *rt_clock;
 QEMUClock *vm_clock;
 QEMUClock *rt_clock;
 QEMUClock *vm_clock;

+QEMUClock *host_clock;

 
 

-static QEMUTimer *active_timers[2];
+static QEMUTimer *active_timers[QEMU_NUM_CLOCKS];

 
 static QEMUClock *qemu_new_clock(int type)
 {
 
 static QEMUClock *qemu_new_clock(int type)
 {


@@ -1025,23 +1033,28 @@ static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
 int64_t qemu_get_clock(QEMUClock *clock)
 {
     switch(clock->type) {
 int64_t qemu_get_clock(QEMUClock *clock)
 {
     switch(clock->type) {

-    case QEMU_TIMER_REALTIME:
+    case QEMU_CLOCK_REALTIME:

         return get_clock() / 1000000;
     default:
         return get_clock() / 1000000;
     default:

-    case QEMU_TIMER_VIRTUAL:
+    case QEMU_CLOCK_VIRTUAL:

         if (use_icount) {
             return cpu_get_icount();
         } else {
             return cpu_get_clock();
         }
         if (use_icount) {
             return cpu_get_icount();
         } else {
             return cpu_get_clock();
         }

+    case QEMU_CLOCK_HOST:
+        return get_clock_realtime();

     }
 }
 
     }
 }
 

-static void init_timers(void)
+static void init_clocks(void)

 {
     init_get_clock();
 {
     init_get_clock();

-    rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
-    vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
+    rt_clock = qemu_new_clock(QEMU_CLOCK_REALTIME);
+    vm_clock = qemu_new_clock(QEMU_CLOCK_VIRTUAL);
+    host_clock = qemu_new_clock(QEMU_CLOCK_HOST);
+
+    rtc_clock = host_clock;

 }
 
 /* save a timer */
 }
 
 /* save a timer */


@@ -1123,10 +1136,12 @@ static void host_alarm_handler(int host_signum)
 #endif
     if (alarm_has_dynticks(alarm_timer) ||
         (!use_icount &&
 #endif
     if (alarm_has_dynticks(alarm_timer) ||
         (!use_icount &&

-            qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
+            qemu_timer_expired(active_timers[QEMU_CLOCK_VIRTUAL],

                                qemu_get_clock(vm_clock))) ||
                                qemu_get_clock(vm_clock))) ||

-        qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
-                           qemu_get_clock(rt_clock))) {
+        qemu_timer_expired(active_timers[QEMU_CLOCK_REALTIME],
+                           qemu_get_clock(rt_clock)) ||
+        qemu_timer_expired(active_timers[QEMU_CLOCK_HOST],
+                           qemu_get_clock(host_clock))) {

         qemu_event_increment();
         if (alarm_timer) alarm_timer->flags |= ALARM_FLAG_EXPIRED;
 
         qemu_event_increment();
         if (alarm_timer) alarm_timer->flags |= ALARM_FLAG_EXPIRED;
 


@@ -1143,14 +1158,18 @@ static void host_alarm_handler(int host_signum)
 
 static int64_t qemu_next_deadline(void)
 {
 
 static int64_t qemu_next_deadline(void)
 {

-    int64_t delta;
+    /* To avoid problems with overflow limit this to 2^32.  */
+    int64_t delta = INT32_MAX;

 
 

-    if (active_timers[QEMU_TIMER_VIRTUAL]) {
-        delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
+    if (active_timers[QEMU_CLOCK_VIRTUAL]) {
+        delta = active_timers[QEMU_CLOCK_VIRTUAL]->expire_time -

                      qemu_get_clock(vm_clock);
                      qemu_get_clock(vm_clock);

-    } else {
-        /* To avoid problems with overflow limit this to 2^32.  */
-        delta = INT32_MAX;
+    }
+    if (active_timers[QEMU_CLOCK_HOST]) {
+        int64_t hdelta = active_timers[QEMU_CLOCK_HOST]->expire_time -
+                 qemu_get_clock(host_clock);
+        if (hdelta < delta)
+            delta = hdelta;

     }
 
     if (delta < 0)
     }
 
     if (delta < 0)


@@ -1159,7 +1178,7 @@ static int64_t qemu_next_deadline(void)
     return delta;
 }
 
     return delta;
 }
 

-#if defined(__linux__) || defined(_WIN32)
+#if defined(__linux__)

 static uint64_t qemu_next_deadline_dyntick(void)
 {
     int64_t delta;
 static uint64_t qemu_next_deadline_dyntick(void)
 {
     int64_t delta;


@@ -1170,8 +1189,8 @@ static uint64_t qemu_next_deadline_dyntick(void)
     else
         delta = (qemu_next_deadline() + 999) / 1000;
 
     else
         delta = (qemu_next_deadline() + 999) / 1000;
 

-    if (active_timers[QEMU_TIMER_REALTIME]) {
-        rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
+    if (active_timers[QEMU_CLOCK_REALTIME]) {
+        rtdelta = (active_timers[QEMU_CLOCK_REALTIME]->expire_time -

                  qemu_get_clock(rt_clock))*1000;
         if (rtdelta < delta)
             delta = rtdelta;
                  qemu_get_clock(rt_clock))*1000;
         if (rtdelta < delta)
             delta = rtdelta;


@@ -1353,8 +1372,9 @@ static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
     int64_t nearest_delta_us = INT64_MAX;
     int64_t current_us;
 
     int64_t nearest_delta_us = INT64_MAX;
     int64_t current_us;
 

-    if (!active_timers[QEMU_TIMER_REALTIME] &&
-                !active_timers[QEMU_TIMER_VIRTUAL])
+    if (!active_timers[QEMU_CLOCK_REALTIME] &&
+        !active_timers[QEMU_CLOCK_VIRTUAL] &&
+        !active_timers[QEMU_CLOCK_HOST])

         return;
 
     nearest_delta_us = qemu_next_deadline_dyntick();
         return;
 
     nearest_delta_us = qemu_next_deadline_dyntick();


@@ -1468,15 +1488,12 @@ static void win32_stop_timer(struct qemu_alarm_timer *t)
 static void win32_rearm_timer(struct qemu_alarm_timer *t)
 {
     struct qemu_alarm_win32 *data = t->priv;
 static void win32_rearm_timer(struct qemu_alarm_timer *t)
 {
     struct qemu_alarm_win32 *data = t->priv;

-    uint64_t nearest_delta_us;

 
 

-    if (!active_timers[QEMU_TIMER_REALTIME] &&
-                !active_timers[QEMU_TIMER_VIRTUAL])
+    if (!active_timers[QEMU_CLOCK_REALTIME] &&
+        !active_timers[QEMU_CLOCK_VIRTUAL] &&
+        !active_timers[QEMU_CLOCK_HOST])

         return;
 
         return;
 

-    nearest_delta_us = qemu_next_deadline_dyntick();
-    nearest_delta_us /= 1000;
-

     timeKillEvent(data->timerId);
 
     data->timerId = timeSetEvent(1,
     timeKillEvent(data->timerId);
 
     data->timerId = timeSetEvent(1,


@@ -1565,6 +1582,85 @@ int qemu_timedate_diff(struct tm *tm)
     return seconds - time(NULL);
 }
 
     return seconds - time(NULL);
 }
 

+static void configure_rtc_date_offset(const char *startdate, int legacy)
+{
+    time_t rtc_start_date;
+    struct tm tm;
+
+    if (!strcmp(startdate, "now") && legacy) {
+        rtc_date_offset = -1;
+    } else {
+        if (sscanf(startdate, "%d-%d-%dT%d:%d:%d",
+                   &tm.tm_year,
+                   &tm.tm_mon,
+                   &tm.tm_mday,
+                   &tm.tm_hour,
+                   &tm.tm_min,
+                   &tm.tm_sec) == 6) {
+            /* OK */
+        } else if (sscanf(startdate, "%d-%d-%d",
+                          &tm.tm_year,
+                          &tm.tm_mon,
+                          &tm.tm_mday) == 3) {
+            tm.tm_hour = 0;
+            tm.tm_min = 0;
+            tm.tm_sec = 0;
+        } else {
+            goto date_fail;
+        }
+        tm.tm_year -= 1900;
+        tm.tm_mon--;
+        rtc_start_date = mktimegm(&tm);
+        if (rtc_start_date == -1) {
+        date_fail:
+            fprintf(stderr, "Invalid date format. Valid formats are:\n"
+                            "'2006-06-17T16:01:21' or '2006-06-17'\n");
+            exit(1);
+        }
+        rtc_date_offset = time(NULL) - rtc_start_date;
+    }
+}
+
+static void configure_rtc(QemuOpts *opts)
+{
+    const char *value;
+
+    value = qemu_opt_get(opts, "base");
+    if (value) {
+        if (!strcmp(value, "utc")) {
+            rtc_utc = 1;
+        } else if (!strcmp(value, "localtime")) {
+            rtc_utc = 0;
+        } else {
+            configure_rtc_date_offset(value, 0);
+        }
+    }
+    value = qemu_opt_get(opts, "clock");
+    if (value) {
+        if (!strcmp(value, "host")) {
+            rtc_clock = host_clock;
+        } else if (!strcmp(value, "vm")) {
+            rtc_clock = vm_clock;
+        } else {
+            fprintf(stderr, "qemu: invalid option value '%s'\n", value);
+            exit(1);
+        }
+    }
+#ifdef CONFIG_TARGET_I386
+    value = qemu_opt_get(opts, "driftfix");
+    if (value) {
+        if (!strcmp(buf, "slew")) {
+            rtc_td_hack = 1;
+        } else if (!strcmp(buf, "none")) {
+            rtc_td_hack = 0;
+        } else {
+            fprintf(stderr, "qemu: invalid option value '%s'\n", value);
+            exit(1);
+        }
+    }
+#endif
+}
+

 #ifdef _WIN32
 static void socket_cleanup(void)
 {
 #ifdef _WIN32
 static void socket_cleanup(void)
 {


@@ -1880,18 +1976,12 @@ static void bdrv_format_print(void *opaque, const char *name)
     fprintf(stderr, " %s", name);
 }
 
     fprintf(stderr, " %s", name);
 }
 

-void drive_uninit(BlockDriverState *bdrv)
+void drive_uninit(DriveInfo *dinfo)

 {
 {

-    DriveInfo *dinfo;
-
-    QTAILQ_FOREACH(dinfo, &drives, next) {
-        if (dinfo->bdrv != bdrv)
-            continue;
-        qemu_opts_del(dinfo->opts);
-        QTAILQ_REMOVE(&drives, dinfo, next);
-        qemu_free(dinfo);
-        break;
-    }
+    qemu_opts_del(dinfo->opts);
+    bdrv_delete(dinfo->bdrv);
+    QTAILQ_REMOVE(&drives, dinfo, next);
+    qemu_free(dinfo);

 }
 
 DriveInfo *drive_init(QemuOpts *opts, void *opaque,
 }
 
 DriveInfo *drive_init(QemuOpts *opts, void *opaque,


@@ -1912,6 +2002,7 @@ DriveInfo *drive_init(QemuOpts *opts, void *opaque,
     int index;
     int cache;
     int aio = 0;
     int index;
     int cache;
     int aio = 0;

+    int ro = 0;

     int bdrv_flags, onerror;
     const char *devaddr;
     DriveInfo *dinfo;
     int bdrv_flags, onerror;
     const char *devaddr;
     DriveInfo *dinfo;


@@ -1943,6 +2034,7 @@ DriveInfo *drive_init(QemuOpts *opts, void *opaque,
     secs  = qemu_opt_get_number(opts, "secs", 0);
 
     snapshot = qemu_opt_get_bool(opts, "snapshot", 0);
     secs  = qemu_opt_get_number(opts, "secs", 0);
 
     snapshot = qemu_opt_get_bool(opts, "snapshot", 0);

+    ro = qemu_opt_get_bool(opts, "readonly", 0);

 
     file = qemu_opt_get(opts, "file");
     serial = qemu_opt_get(opts, "serial");
 
     file = qemu_opt_get(opts, "file");
     serial = qemu_opt_get(opts, "serial");


@@ -1983,15 +2075,15 @@ DriveInfo *drive_init(QemuOpts *opts, void *opaque,
     }
 
     if (cyls || heads || secs) {
     }
 
     if (cyls || heads || secs) {

-        if (cyls < 1 || cyls > 16383) {
+        if (cyls < 1 || (type == IF_IDE && cyls > 16383)) {

             fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", buf);
            return NULL;
        }
             fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", buf);
            return NULL;
        }

-        if (heads < 1 || heads > 16) {
+        if (heads < 1 || (type == IF_IDE && heads > 16)) {

             fprintf(stderr, "qemu: '%s' invalid physical heads number\n", buf);
            return NULL;
        }
             fprintf(stderr, "qemu: '%s' invalid physical heads number\n", buf);
            return NULL;
        }

-        if (secs < 1 || secs > 63) {
+        if (secs < 1 || (type == IF_IDE && secs > 63)) {

             fprintf(stderr, "qemu: '%s' invalid physical secs number\n", buf);
            return NULL;
        }
             fprintf(stderr, "qemu: '%s' invalid physical secs number\n", buf);
            return NULL;
        }


@@ -2065,7 +2157,7 @@ DriveInfo *drive_init(QemuOpts *opts, void *opaque,
             fprintf(stderr, "\n");
            return NULL;
         }
             fprintf(stderr, "\n");
            return NULL;
         }

-        drv = bdrv_find_format(buf);
+        drv = bdrv_find_whitelisted_format(buf);

         if (!drv) {
             fprintf(stderr, "qemu: '%s' invalid format\n", buf);
             return NULL;
         if (!drv) {
             fprintf(stderr, "qemu: '%s' invalid format\n", buf);
             return NULL;


@@ -2234,9 +2326,17 @@ DriveInfo *drive_init(QemuOpts *opts, void *opaque,
         bdrv_flags &= ~BDRV_O_NATIVE_AIO;
     }
 
         bdrv_flags &= ~BDRV_O_NATIVE_AIO;
     }
 

+    if (ro == 1) {
+        if (type == IF_IDE) {
+            fprintf(stderr, "qemu: readonly flag not supported for drive with ide interface\n");
+            return NULL;
+        }
+        (void)bdrv_set_read_only(dinfo->bdrv, 1);
+    }
+

     if (bdrv_open2(dinfo->bdrv, file, bdrv_flags, drv) < 0) {
     if (bdrv_open2(dinfo->bdrv, file, bdrv_flags, drv) < 0) {

-        fprintf(stderr, "qemu: could not open disk image %s\n",
-                        file);
+        fprintf(stderr, "qemu: could not open disk image %s: %s\n",
+                        file, strerror(errno));

         return NULL;
     }
 
         return NULL;
     }
 


@@ -2428,84 +2528,40 @@ static void smp_parse(const char *optarg)
 /***********************************************************/
 /* USB devices */
 
 /***********************************************************/
 /* USB devices */
 

-static void usb_msd_password_cb(void *opaque, int err)
-{
-    USBDevice *dev = opaque;
-
-    if (!err)
-        usb_device_attach(dev);
-    else
-        dev->info->handle_destroy(dev);
-}
-
-static struct {
-    const char *name;
-    const char *qdev;
-} usbdevs[] = {
-    {
-        .name = "mouse",
-        .qdev = "QEMU USB Mouse",
-    },{
-        .name = "tablet",
-        .qdev = "QEMU USB Tablet",
-    },{
-        .name = "keyboard",
-        .qdev = "QEMU USB Keyboard",
-    },{
-        .name = "wacom-tablet",
-        .qdev = "QEMU PenPartner Tablet",
-    }
-};
-

 static int usb_device_add(const char *devname, int is_hotplug)
 {
     const char *p;
 static int usb_device_add(const char *devname, int is_hotplug)
 {
     const char *p;

-    USBBus *bus = usb_bus_find(-1 /* any */);

     USBDevice *dev = NULL;
     USBDevice *dev = NULL;

-    int i;

 
     if (!usb_enabled)
         return -1;
 
 
     if (!usb_enabled)
         return -1;
 

-    /* simple devices which don't need extra care */
-    for (i = 0; i < ARRAY_SIZE(usbdevs); i++) {
-        if (strcmp(devname, usbdevs[i].name) != 0)
-            continue;
-        dev = usb_create_simple(bus, usbdevs[i].qdev);
+    /* drivers with .usbdevice_name entry in USBDeviceInfo */
+    dev = usbdevice_create(devname);
+    if (dev)

         goto done;
         goto done;

-    }

 
     /* the other ones */
     if (strstart(devname, "host:", &p)) {
         dev = usb_host_device_open(p);
 
     /* the other ones */
     if (strstart(devname, "host:", &p)) {
         dev = usb_host_device_open(p);

-    } else if (strstart(devname, "disk:", &p)) {
-        BlockDriverState *bs;
+    } else if (strstart(devname, "net:", &p)) {
+        QemuOpts *opts;
+        int idx;

 
 

-        dev = usb_msd_init(p);
-        if (!dev)
+        opts = qemu_opts_parse(&qemu_net_opts, p, NULL);
+        if (!opts) {

             return -1;
             return -1;

-        bs = usb_msd_get_bdrv(dev);
-        if (bdrv_key_required(bs)) {
-            autostart = 0;
-            if (is_hotplug) {
-                monitor_read_bdrv_key_start(cur_mon, bs, usb_msd_password_cb,
-                                            dev);
-                return 0;
-            }

         }
         }

-    } else if (strstart(devname, "serial:", &p)) {
-        dev = usb_serial_init(p);
-#ifdef CONFIG_BRLAPI
-    } else if (!strcmp(devname, "braille")) {
-        dev = usb_baum_init();
-#endif
-    } else if (strstart(devname, "net:", &p)) {
-        int nic = nb_nics;

 
 

-        if (net_client_init(NULL, "nic", p) < 0)
+        qemu_opt_set(opts, "type", "nic");
+        qemu_opt_set(opts, "model", "usb");
+
+        idx = net_client_init(NULL, opts, 0);
+        if (idx == -1) {

             return -1;
             return -1;

-        nd_table[nic].model = "usb";
-        dev = usb_net_init(&nd_table[nic]);
+        }
+
+        dev = usb_net_init(&nd_table[idx]);

     } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
         dev = usb_bt_init(devname[2] ? hci_init(p) :
                         bt_new_hci(qemu_find_bt_vlan(0)));
     } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
         dev = usb_bt_init(devname[2] ? hci_init(p) :
                         bt_new_hci(qemu_find_bt_vlan(0)));


@@ -2871,13 +2927,18 @@ uint64_t ram_bytes_total(void)
     return last_ram_offset;
 }
 
     return last_ram_offset;
 }
 

-static int ram_save_live(QEMUFile *f, int stage, void *opaque)
+static int ram_save_live(Monitor *mon, QEMUFile *f, int stage, void *opaque)

 {
     ram_addr_t addr;
     uint64_t bytes_transferred_last;
     double bwidth = 0;
     uint64_t expected_time = 0;
 
 {
     ram_addr_t addr;
     uint64_t bytes_transferred_last;
     double bwidth = 0;
     uint64_t expected_time = 0;
 

+    if (stage < 0) {
+        cpu_physical_memory_set_dirty_tracking(0);
+        return 0;
+    }
+

     if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) {
         qemu_file_set_error(f);
         return 0;
     if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) {
         qemu_file_set_error(f);
         return 0;


@@ -2917,9 +2978,7 @@ static int ram_save_live(QEMUFile *f, int stage, void *opaque)
         bwidth = 0.000001;
 
     /* try transferring iterative blocks of memory */
         bwidth = 0.000001;
 
     /* try transferring iterative blocks of memory */

-

     if (stage == 3) {
     if (stage == 3) {

-

         /* flush all remaining blocks regardless of rate limiting */
         while (ram_save_block(f) != 0) {
             bytes_transferred += TARGET_PAGE_SIZE;
         /* flush all remaining blocks regardless of rate limiting */
         while (ram_save_block(f) != 0) {
             bytes_transferred += TARGET_PAGE_SIZE;


@@ -2962,8 +3021,12 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id)
                 madvise(qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE, MADV_DONTNEED);
             }
 #endif
                 madvise(qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE, MADV_DONTNEED);
             }
 #endif

-        } else if (flags & RAM_SAVE_FLAG_PAGE)
+        } else if (flags & RAM_SAVE_FLAG_PAGE) {

             qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);
             qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);

+        }
+        if (qemu_file_has_error(f)) {
+            return -EIO;
+        }

     } while (!(flags & RAM_SAVE_FLAG_EOS));
 
     return 0;
     } while (!(flags & RAM_SAVE_FLAG_EOS));
 
     return 0;


@@ -2974,110 +3037,6 @@ void qemu_service_io(void)
     qemu_notify_event();
 }
 
     qemu_notify_event();
 }
 

-/***********************************************************/
-/* bottom halves (can be seen as timers which expire ASAP) */
-
-struct QEMUBH {
-    QEMUBHFunc *cb;
-    void *opaque;
-    int scheduled;
-    int idle;
-    int deleted;
-    QEMUBH *next;
-};
-
-static QEMUBH *first_bh = NULL;
-
-QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
-{
-    QEMUBH *bh;
-    bh = qemu_mallocz(sizeof(QEMUBH));
-    bh->cb = cb;
-    bh->opaque = opaque;
-    bh->next = first_bh;
-    first_bh = bh;
-    return bh;
-}
-
-int qemu_bh_poll(void)
-{
-    QEMUBH *bh, **bhp;
-    int ret;
-
-    ret = 0;
-    for (bh = first_bh; bh; bh = bh->next) {
-        if (!bh->deleted && bh->scheduled) {
-            bh->scheduled = 0;
-            if (!bh->idle)
-                ret = 1;
-            bh->idle = 0;
-            bh->cb(bh->opaque);
-        }
-    }
-
-    /* remove deleted bhs */
-    bhp = &first_bh;
-    while (*bhp) {
-        bh = *bhp;
-        if (bh->deleted) {
-            *bhp = bh->next;
-            qemu_free(bh);
-        } else
-            bhp = &bh->next;
-    }
-
-    return ret;
-}
-
-void qemu_bh_schedule_idle(QEMUBH *bh)
-{
-    if (bh->scheduled)
-        return;
-    bh->scheduled = 1;
-    bh->idle = 1;
-}
-
-void qemu_bh_schedule(QEMUBH *bh)
-{
-    if (bh->scheduled)
-        return;
-    bh->scheduled = 1;
-    bh->idle = 0;
-    /* stop the currently executing CPU to execute the BH ASAP */
-    qemu_notify_event();
-}
-
-void qemu_bh_cancel(QEMUBH *bh)
-{
-    bh->scheduled = 0;
-}
-
-void qemu_bh_delete(QEMUBH *bh)
-{
-    bh->scheduled = 0;
-    bh->deleted = 1;
-}
-
-static void qemu_bh_update_timeout(int *timeout)
-{
-    QEMUBH *bh;
-
-    for (bh = first_bh; bh; bh = bh->next) {
-        if (!bh->deleted && bh->scheduled) {
-            if (bh->idle) {
-                /* idle bottom halves will be polled at least
-                 * every 10ms */
-                *timeout = MIN(10, *timeout);
-            } else {
-                /* non-idle bottom halves will be executed
-                 * immediately */
-                *timeout = 0;
-                break;
-            }
-        }
-    }
-}
-

 /***********************************************************/
 /* machine registration */
 
 /***********************************************************/
 /* machine registration */
 


@@ -3454,8 +3413,8 @@ void qemu_notify_event(void)
     }
 }
 
     }
 }
 

-#define qemu_mutex_lock_iothread() do { } while (0)
-#define qemu_mutex_unlock_iothread() do { } while (0)
+void qemu_mutex_lock_iothread(void) {}
+void qemu_mutex_unlock_iothread(void) {}

 
 void vm_stop(int reason)
 {
 
 void vm_stop(int reason)
 {


@@ -3654,7 +3613,7 @@ static void qemu_signal_lock(unsigned int msecs)
     qemu_mutex_unlock(&qemu_fair_mutex);
 }
 
     qemu_mutex_unlock(&qemu_fair_mutex);
 }
 

-static void qemu_mutex_lock_iothread(void)
+void qemu_mutex_lock_iothread(void)

 {
     if (kvm_enabled()) {
         qemu_mutex_lock(&qemu_fair_mutex);
 {
     if (kvm_enabled()) {
         qemu_mutex_lock(&qemu_fair_mutex);


@@ -3664,7 +3623,7 @@ static void qemu_mutex_lock_iothread(void)
         qemu_signal_lock(100);
 }
 
         qemu_signal_lock(100);
 }
 

-static void qemu_mutex_unlock_iothread(void)
+void qemu_mutex_unlock_iothread(void)

 {
     qemu_mutex_unlock(&qemu_global_mutex);
 }
 {
     qemu_mutex_unlock(&qemu_global_mutex);
 }


@@ -3912,14 +3871,17 @@ void main_loop_wait(int timeout)
     /* vm time timers */
     if (vm_running) {
         if (!cur_cpu || likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
     /* vm time timers */
     if (vm_running) {
         if (!cur_cpu || likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))

-            qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
-                qemu_get_clock(vm_clock));
+            qemu_run_timers(&active_timers[QEMU_CLOCK_VIRTUAL],
+                            qemu_get_clock(vm_clock));

     }
 
     /* real time timers */
     }
 
     /* real time timers */

-    qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
+    qemu_run_timers(&active_timers[QEMU_CLOCK_REALTIME],

                     qemu_get_clock(rt_clock));
 
                     qemu_get_clock(rt_clock));
 

+    qemu_run_timers(&active_timers[QEMU_CLOCK_HOST],
+                    qemu_get_clock(host_clock));
+

     /* Check bottom-halves last in case any of the earlier events triggered
        them.  */
     qemu_bh_poll();
     /* Check bottom-halves last in case any of the earlier events triggered
        them.  */
     qemu_bh_poll();


@@ -4108,9 +4070,12 @@ static void main_loop(void)
 #endif
         } while (vm_can_run());
 
 #endif
         } while (vm_can_run());
 

-        if (qemu_debug_requested())
+        if (qemu_debug_requested()) {
+            monitor_protocol_event(EVENT_DEBUG, NULL);

             vm_stop(EXCP_DEBUG);
             vm_stop(EXCP_DEBUG);

+        }

         if (qemu_shutdown_requested()) {
         if (qemu_shutdown_requested()) {

+            monitor_protocol_event(EVENT_SHUTDOWN, NULL);

             if (no_shutdown) {
                 vm_stop(0);
                 no_shutdown = 0;
             if (no_shutdown) {
                 vm_stop(0);
                 no_shutdown = 0;


@@ -4118,15 +4083,19 @@ static void main_loop(void)
                 break;
         }
         if (qemu_reset_requested()) {
                 break;
         }
         if (qemu_reset_requested()) {

+            monitor_protocol_event(EVENT_RESET, NULL);

             pause_all_vcpus();
             qemu_system_reset();
             resume_all_vcpus();
         }
         if (qemu_powerdown_requested()) {
             pause_all_vcpus();
             qemu_system_reset();
             resume_all_vcpus();
         }
         if (qemu_powerdown_requested()) {

+            monitor_protocol_event(EVENT_POWERDOWN, NULL);

             qemu_irq_raise(qemu_system_powerdown);
         }
             qemu_irq_raise(qemu_system_powerdown);
         }

-        if ((r = qemu_vmstop_requested()))
+        if ((r = qemu_vmstop_requested())) {
+            monitor_protocol_event(EVENT_STOP, NULL);

             vm_stop(r);
             vm_stop(r);

+        }

     }
     pause_all_vcpus();
 }
     }
     pause_all_vcpus();
 }


@@ -4429,8 +4398,6 @@ int qemu_uuid_parse(const char *str, uint8_t *uuid)
     return 0;
 }
 
     return 0;
 }
 

-#define MAX_NET_CLIENTS 32
-

 #ifndef _WIN32
 
 static void termsig_handler(int signal)
 #ifndef _WIN32
 
 static void termsig_handler(int signal)


@@ -4634,13 +4601,12 @@ int main(int argc, char **argv, char **envp)
     DisplayState *ds;
     DisplayChangeListener *dcl;
     int cyls, heads, secs, translation;
     DisplayState *ds;
     DisplayChangeListener *dcl;
     int cyls, heads, secs, translation;

-    const char *net_clients[MAX_NET_CLIENTS];
-    int nb_net_clients;

     QemuOpts *hda_opts = NULL, *opts;
     int optind;
     const char *r, *optarg;
     CharDriverState *monitor_hds[MAX_MONITOR_DEVICES];
     const char *monitor_devices[MAX_MONITOR_DEVICES];
     QemuOpts *hda_opts = NULL, *opts;
     int optind;
     const char *r, *optarg;
     CharDriverState *monitor_hds[MAX_MONITOR_DEVICES];
     const char *monitor_devices[MAX_MONITOR_DEVICES];

+    int monitor_flags[MAX_MONITOR_DEVICES];

     int monitor_device_index;
     const char *serial_devices[MAX_SERIAL_PORTS];
     int serial_device_index;
     int monitor_device_index;
     const char *serial_devices[MAX_SERIAL_PORTS];
     int serial_device_index;


@@ -4666,6 +4632,8 @@ int main(int argc, char **argv, char **envp)
     CPUState *env;
     int show_vnc_port = 0;
 
     CPUState *env;
     int show_vnc_port = 0;
 

+    init_clocks();
+

     qemu_errors_to_file(stderr);
     qemu_cache_utils_init(envp);
 
     qemu_errors_to_file(stderr);
     qemu_cache_utils_init(envp);
 


@@ -4726,8 +4694,10 @@ int main(int argc, char **argv, char **envp)
     virtio_console_index = 0;
 
     monitor_devices[0] = "vc:80Cx24C";
     virtio_console_index = 0;
 
     monitor_devices[0] = "vc:80Cx24C";

+    monitor_flags[0] = MONITOR_IS_DEFAULT | MONITOR_USE_READLINE;

     for (i = 1; i < MAX_MONITOR_DEVICES; i++) {
         monitor_devices[i] = NULL;
     for (i = 1; i < MAX_MONITOR_DEVICES; i++) {
         monitor_devices[i] = NULL;

+        monitor_flags[i] = MONITOR_USE_READLINE;

     }
     monitor_device_index = 0;
 
     }
     monitor_device_index = 0;
 


@@ -4736,7 +4706,6 @@ int main(int argc, char **argv, char **envp)
         node_cpumask[i] = 0;
     }
 
         node_cpumask[i] = 0;
     }
 

-    nb_net_clients = 0;

     nb_numa_nodes = 0;
     nb_nics = 0;
 
     nb_numa_nodes = 0;
     nb_nics = 0;
 


@@ -4981,13 +4950,15 @@ int main(int argc, char **argv, char **envp)
                 fd_bootchk = 0;
                 break;
 #endif
                 fd_bootchk = 0;
                 break;
 #endif

+            case QEMU_OPTION_netdev:
+                if (net_client_parse(&qemu_netdev_opts, optarg) == -1) {
+                    exit(1);
+                }
+                break;

             case QEMU_OPTION_net:
             case QEMU_OPTION_net:

-                if (nb_net_clients >= MAX_NET_CLIENTS) {
-                    fprintf(stderr, "qemu: too many network clients\n");
+                if (net_client_parse(&qemu_net_opts, optarg) == -1) {

                     exit(1);
                 }
                     exit(1);
                 }

-                net_clients[nb_net_clients] = optarg;
-                nb_net_clients++;

                 break;
 #ifdef CONFIG_SLIRP
             case QEMU_OPTION_tftp:
                 break;
 #ifdef CONFIG_SLIRP
             case QEMU_OPTION_tftp:


@@ -4998,11 +4969,13 @@ int main(int argc, char **argv, char **envp)
                 break;
 #ifndef _WIN32
             case QEMU_OPTION_smb:
                 break;
 #ifndef _WIN32
             case QEMU_OPTION_smb:

-                net_slirp_smb(optarg);
+                if (net_slirp_smb(optarg) < 0)
+                    exit(1);

                 break;
 #endif
             case QEMU_OPTION_redir:
                 break;
 #endif
             case QEMU_OPTION_redir:

-                net_slirp_redir(optarg);
+                if (net_slirp_redir(optarg) < 0)
+                    exit(1);

                 break;
 #endif
             case QEMU_OPTION_bt:
                 break;
 #endif
             case QEMU_OPTION_bt:


@@ -5087,11 +5060,9 @@ int main(int argc, char **argv, char **envp)
             case QEMU_OPTION_S:
                 autostart = 0;
                 break;
             case QEMU_OPTION_S:
                 autostart = 0;
                 break;

-#ifndef _WIN32

            case QEMU_OPTION_k:
                keyboard_layout = optarg;
                break;
            case QEMU_OPTION_k:
                keyboard_layout = optarg;
                break;

-#endif

             case QEMU_OPTION_localtime:
                 rtc_utc = 0;
                 break;
             case QEMU_OPTION_localtime:
                 rtc_utc = 0;
                 break;


@@ -5147,7 +5118,9 @@ int main(int argc, char **argv, char **envp)
                     fprintf(stderr, "qemu: too many monitor devices\n");
                     exit(1);
                 }
                     fprintf(stderr, "qemu: too many monitor devices\n");
                     exit(1);
                 }

-                monitor_devices[monitor_device_index] = optarg;
+                monitor_devices[monitor_device_index] =
+                                monitor_cmdline_parse(optarg,
+                                        &monitor_flags[monitor_device_index]);

                 monitor_device_index++;
                 break;
             case QEMU_OPTION_chardev:
                 monitor_device_index++;
                 break;
             case QEMU_OPTION_chardev:


@@ -5211,6 +5184,9 @@ int main(int argc, char **argv, char **envp)
             case QEMU_OPTION_alt_grab:
                 alt_grab = 1;
                 break;
             case QEMU_OPTION_alt_grab:
                 alt_grab = 1;
                 break;

+            case QEMU_OPTION_ctrl_grab:
+                ctrl_grab = 1;
+                break;

             case QEMU_OPTION_no_quit:
                 no_quit = 1;
                 break;
             case QEMU_OPTION_no_quit:
                 no_quit = 1;
                 break;


@@ -5254,9 +5230,7 @@ int main(int argc, char **argv, char **envp)
                 add_device_config(DEV_USB, optarg);
                 break;
             case QEMU_OPTION_device:
                 add_device_config(DEV_USB, optarg);
                 break;
             case QEMU_OPTION_device:

-                opts = qemu_opts_parse(&qemu_device_opts, optarg, "driver");
-                if (!opts) {
-                    fprintf(stderr, "parse error: %s\n", optarg);
+                if (!qemu_opts_parse(&qemu_device_opts, optarg, "driver")) {

                     exit(1);
                 }
                 break;
                     exit(1);
                 }
                 break;


@@ -5362,42 +5336,15 @@ int main(int argc, char **argv, char **envp)
                 configure_alarms(optarg);
                 break;
             case QEMU_OPTION_startdate:
                 configure_alarms(optarg);
                 break;
             case QEMU_OPTION_startdate:

-                {
-                    struct tm tm;
-                    time_t rtc_start_date;
-                    if (!strcmp(optarg, "now")) {
-                        rtc_date_offset = -1;
-                    } else {
-                        if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
-                               &tm.tm_year,
-                               &tm.tm_mon,
-                               &tm.tm_mday,
-                               &tm.tm_hour,
-                               &tm.tm_min,
-                               &tm.tm_sec) == 6) {
-                            /* OK */
-                        } else if (sscanf(optarg, "%d-%d-%d",
-                                          &tm.tm_year,
-                                          &tm.tm_mon,
-                                          &tm.tm_mday) == 3) {
-                            tm.tm_hour = 0;
-                            tm.tm_min = 0;
-                            tm.tm_sec = 0;
-                        } else {
-                            goto date_fail;
-                        }
-                        tm.tm_year -= 1900;
-                        tm.tm_mon--;
-                        rtc_start_date = mktimegm(&tm);
-                        if (rtc_start_date == -1) {
-                        date_fail:
-                            fprintf(stderr, "Invalid date format. Valid format are:\n"
-                                    "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
-                            exit(1);
-                        }
-                        rtc_date_offset = time(NULL) - rtc_start_date;
-                    }
+                configure_rtc_date_offset(optarg, 1);
+                break;
+            case QEMU_OPTION_rtc:
+                opts = qemu_opts_parse(&qemu_rtc_opts, optarg, NULL);
+                if (!opts) {
+                    fprintf(stderr, "parse error: %s\n", optarg);
+                    exit(1);

                 }
                 }

+                configure_rtc(opts);

                 break;
             case QEMU_OPTION_tb_size:
                 tb_size = strtol(optarg, NULL, 0);
                 break;
             case QEMU_OPTION_tb_size:
                 tb_size = strtol(optarg, NULL, 0);


@@ -5434,6 +5381,36 @@ int main(int argc, char **argv, char **envp)
                 xen_mode = XEN_ATTACH;
                 break;
 #endif
                 xen_mode = XEN_ATTACH;
                 break;
 #endif

+            case QEMU_OPTION_readconfig:
+                {
+                    FILE *fp;
+                    fp = fopen(optarg, "r");
+                    if (fp == NULL) {
+                        fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
+                        exit(1);
+                    }
+                    if (qemu_config_parse(fp) != 0) {
+                        exit(1);
+                    }
+                    fclose(fp);
+                    break;
+                }
+            case QEMU_OPTION_writeconfig:
+                {
+                    FILE *fp;
+                    if (strcmp(optarg, "-") == 0) {
+                        fp = stdout;
+                    } else {
+                        fp = fopen(optarg, "w");
+                        if (fp == NULL) {
+                            fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
+                            exit(1);
+                        }
+                    }
+                    qemu_config_write(fp);
+                    fclose(fp);
+                    break;
+                }

             }
         }
     }
             }
         }
     }


@@ -5495,7 +5472,7 @@ int main(int argc, char **argv, char **envp)
             if (len != 1)
                 exit(1);
             else if (status == 1) {
             if (len != 1)
                 exit(1);
             else if (status == 1) {

-                fprintf(stderr, "Could not acquire pidfile\n");
+                fprintf(stderr, "Could not acquire pidfile: %s\n", strerror(errno));

                 exit(1);
             } else
                 exit(0);
                 exit(1);
             } else
                 exit(0);


@@ -5522,7 +5499,7 @@ int main(int argc, char **argv, char **envp)
             uint8_t status = 1;
             write(fds[1], &status, 1);
         } else
             uint8_t status = 1;
             write(fds[1], &status, 1);
         } else

-            fprintf(stderr, "Could not acquire pid file\n");
+            fprintf(stderr, "Could not acquire pid file: %s\n", strerror(errno));

         exit(1);
     }
 #endif
         exit(1);
     }
 #endif


@@ -5558,7 +5535,6 @@ int main(int argc, char **argv, char **envp)
     setvbuf(stdout, NULL, _IOLBF, 0);
 #endif
 
     setvbuf(stdout, NULL, _IOLBF, 0);
 #endif
 

-    init_timers();

     if (init_timer_alarm() < 0) {
         fprintf(stderr, "could not initialize alarm timer\n");
         exit(1);
     if (init_timer_alarm() < 0) {
         fprintf(stderr, "could not initialize alarm timer\n");
         exit(1);


@@ -5575,25 +5551,13 @@ int main(int argc, char **argv, char **envp)
     socket_init();
 #endif
 
     socket_init();
 #endif
 

-    /* init network clients */
-    if (nb_net_clients == 0) {
-        /* if no clients, we use a default config */
-        net_clients[nb_net_clients++] = "nic";
-#ifdef CONFIG_SLIRP
-        net_clients[nb_net_clients++] = "user";
-#endif
-    }
-
-    for(i = 0;i < nb_net_clients; i++) {
-        if (net_client_parse(net_clients[i]) < 0)
-            exit(1);
+    if (net_init_clients() < 0) {
+        exit(1);

     }
 
     net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
     net_set_boot_mask(net_boot);
 
     }
 
     net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
     net_set_boot_mask(net_boot);
 

-    net_client_check();
-

     /* init the bluetooth world */
     if (foreach_device_config(DEV_BT, bt_parse))
         exit(1);
     /* init the bluetooth world */
     if (foreach_device_config(DEV_BT, bt_parse))
         exit(1);


@@ -5605,7 +5569,9 @@ int main(int argc, char **argv, char **envp)
     /* init the dynamic translator */
     cpu_exec_init_all(tb_size * 1024 * 1024);
 
     /* init the dynamic translator */
     cpu_exec_init_all(tb_size * 1024 * 1024);
 

-    bdrv_init();
+    bdrv_init_with_whitelist();
+
+    blk_mig_init();

 
     /* we always create the cdrom drive, even if no disk is there */
     drive_add(NULL, CDROM_ALIAS);
 
     /* we always create the cdrom drive, even if no disk is there */
     drive_add(NULL, CDROM_ALIAS);


@@ -5623,7 +5589,8 @@ int main(int argc, char **argv, char **envp)
         exit(1);
 
     vmstate_register(0, &vmstate_timers ,&timers_state);
         exit(1);
 
     vmstate_register(0, &vmstate_timers ,&timers_state);

-    register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
+    register_savevm_live("ram", 0, 3, NULL, ram_save_live, NULL, 
+                         ram_load, NULL);

 
     /* Maintain compatibility with multiple stdio monitors */
     if (!strcmp(monitor_devices[0],"stdio")) {
 
     /* Maintain compatibility with multiple stdio monitors */
     if (!strcmp(monitor_devices[0],"stdio")) {


@@ -5707,8 +5674,8 @@ int main(int argc, char **argv, char **envp)
             snprintf(label, sizeof(label), "serial%d", i);
             serial_hds[i] = qemu_chr_open(label, devname, NULL);
             if (!serial_hds[i]) {
             snprintf(label, sizeof(label), "serial%d", i);
             serial_hds[i] = qemu_chr_open(label, devname, NULL);
             if (!serial_hds[i]) {

-                fprintf(stderr, "qemu: could not open serial device '%s'\n",
-                        devname);
+                fprintf(stderr, "qemu: could not open serial device '%s': %s\n",
+                        devname, strerror(errno));

                 exit(1);
             }
         }
                 exit(1);
             }
         }


@@ -5721,8 +5688,8 @@ int main(int argc, char **argv, char **envp)
             snprintf(label, sizeof(label), "parallel%d", i);
             parallel_hds[i] = qemu_chr_open(label, devname, NULL);
             if (!parallel_hds[i]) {
             snprintf(label, sizeof(label), "parallel%d", i);
             parallel_hds[i] = qemu_chr_open(label, devname, NULL);
             if (!parallel_hds[i]) {

-                fprintf(stderr, "qemu: could not open parallel device '%s'\n",
-                        devname);
+                fprintf(stderr, "qemu: could not open parallel device '%s': %s\n",
+                        devname, strerror(errno));

                 exit(1);
             }
         }
                 exit(1);
             }
         }


@@ -5735,8 +5702,8 @@ int main(int argc, char **argv, char **envp)
             snprintf(label, sizeof(label), "virtcon%d", i);
             virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
             if (!virtcon_hds[i]) {
             snprintf(label, sizeof(label), "virtcon%d", i);
             virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
             if (!virtcon_hds[i]) {

-                fprintf(stderr, "qemu: could not open virtio console '%s'\n",
-                        devname);
+                fprintf(stderr, "qemu: could not open virtio console '%s': %s\n",
+                        devname, strerror(errno));

                 exit(1);
             }
         }
                 exit(1);
             }
         }


@@ -5774,7 +5741,8 @@ int main(int argc, char **argv, char **envp)
 
     /* init USB devices */
     if (usb_enabled) {
 
     /* init USB devices */
     if (usb_enabled) {

-        foreach_device_config(DEV_USB, usb_parse);
+        if (foreach_device_config(DEV_USB, usb_parse) < 0)
+            exit(1);

     }
 
     /* init generic devices */
     }
 
     /* init generic devices */


@@ -5843,13 +5811,10 @@ int main(int argc, char **argv, char **envp)
     }
 
     text_consoles_set_display(display_state);
     }
 
     text_consoles_set_display(display_state);

-    qemu_chr_initial_reset();

 
     for (i = 0; i < MAX_MONITOR_DEVICES; i++) {
         if (monitor_devices[i] && monitor_hds[i]) {
 
     for (i = 0; i < MAX_MONITOR_DEVICES; i++) {
         if (monitor_devices[i] && monitor_hds[i]) {

-            monitor_init(monitor_hds[i],
-                         MONITOR_USE_READLINE |
-                         ((i == 0) ? MONITOR_IS_DEFAULT : 0));
+            monitor_init(monitor_hds[i], monitor_flags[i]);

         }
     }
 
         }
     }
 


@@ -5883,6 +5848,11 @@ int main(int argc, char **argv, char **envp)
         exit(1);
     }
 
         exit(1);
     }
 

+    qdev_machine_creation_done();
+
+    rom_load_all();
+
+    qemu_system_reset();

     if (loadvm) {
         if (load_vmstate(cur_mon, loadvm) < 0) {
             autostart = 0;
     if (loadvm) {
         if (load_vmstate(cur_mon, loadvm) < 0) {
             autostart = 0;