iscsi: add support for getting CHAP password via QCryptoSecret API

[qemu.git] / vl.c

diff --git a/vl.c b/vl.c
index f481a1e5aa3f87dd8c613b4c1001b69f825855c1..b87e29268cf3ed1e973579906ecd14f71eb981d9 100644 (file)
--- a/vl.c
+++ b/vl.c
@@ -21,14 +21,8 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */

-#include <unistd.h>
-#include <fcntl.h>
-#include <signal.h>
-#include <time.h>
-#include <errno.h>
-#include <sys/time.h>
+#include "qemu/osdep.h"

 
 

-#include "config-host.h"

 
 #ifdef CONFIG_SECCOMP
 #include "sysemu/seccomp.h"
 
 #ifdef CONFIG_SECCOMP
 #include "sysemu/seccomp.h"


@@ -113,7 +107,6 @@ int main(int argc, char **argv)
 #include "qemu/queue.h"
 #include "sysemu/cpus.h"
 #include "sysemu/arch_init.h"
 #include "qemu/queue.h"
 #include "sysemu/cpus.h"
 #include "sysemu/arch_init.h"

-#include "qemu/osdep.h"

 
 #include "ui/qemu-spice.h"
 #include "qapi/string-input-visitor.h"
 
 #include "ui/qemu-spice.h"
 #include "qapi/string-input-visitor.h"


@@ -123,6 +116,7 @@ int main(int argc, char **argv)
 #include "exec/semihost.h"
 #include "crypto/init.h"
 #include "sysemu/replay.h"
 #include "exec/semihost.h"
 #include "crypto/init.h"
 #include "sysemu/replay.h"

+#include "qapi/qmp/qerror.h"

 
 #define MAX_VIRTIO_CONSOLES 1
 #define MAX_SCLP_CONSOLES 1
 
 #define MAX_VIRTIO_CONSOLES 1
 #define MAX_SCLP_CONSOLES 1


@@ -226,7 +220,6 @@ static struct {
     { .driver = "ide-drive",            .flag = &default_cdrom     },
     { .driver = "scsi-cd",              .flag = &default_cdrom     },
     { .driver = "virtio-serial-pci",    .flag = &default_virtcon   },
     { .driver = "ide-drive",            .flag = &default_cdrom     },
     { .driver = "scsi-cd",              .flag = &default_cdrom     },
     { .driver = "virtio-serial-pci",    .flag = &default_virtcon   },

-    { .driver = "virtio-serial-s390",   .flag = &default_virtcon   },

     { .driver = "virtio-serial",        .flag = &default_virtcon   },
     { .driver = "VGA",                  .flag = &default_vga       },
     { .driver = "isa-vga",              .flag = &default_vga       },
     { .driver = "virtio-serial",        .flag = &default_virtcon   },
     { .driver = "VGA",                  .flag = &default_vga       },
     { .driver = "isa-vga",              .flag = &default_vga       },


@@ -270,9 +263,13 @@ static QemuOptsList qemu_sandbox_opts = {
 
 static QemuOptsList qemu_trace_opts = {
     .name = "trace",
 
 static QemuOptsList qemu_trace_opts = {
     .name = "trace",

-    .implied_opt_name = "trace",
+    .implied_opt_name = "enable",

     .head = QTAILQ_HEAD_INITIALIZER(qemu_trace_opts.head),
     .desc = {
     .head = QTAILQ_HEAD_INITIALIZER(qemu_trace_opts.head),
     .desc = {

+        {
+            .name = "enable",
+            .type = QEMU_OPT_STRING,
+        },

         {
             .name = "events",
             .type = QEMU_OPT_STRING,
         {
             .name = "events",
             .type = QEMU_OPT_STRING,


@@ -475,6 +472,12 @@ static QemuOptsList qemu_icount_opts = {
         }, {
             .name = "sleep",
             .type = QEMU_OPT_BOOL,
         }, {
             .name = "sleep",
             .type = QEMU_OPT_BOOL,

+        }, {
+            .name = "rr",
+            .type = QEMU_OPT_STRING,
+        }, {
+            .name = "rrfile",
+            .type = QEMU_OPT_STRING,

         },
         { /* end of list */ }
     },
         },
         { /* end of list */ }
     },


@@ -563,8 +566,8 @@ static int default_driver_check(void *opaque, QemuOpts *opts, Error **errp)
 
 static RunState current_run_state = RUN_STATE_PRELAUNCH;
 
 
 static RunState current_run_state = RUN_STATE_PRELAUNCH;
 

-/* We use RUN_STATE_MAX but any invalid value will do */
-static RunState vmstop_requested = RUN_STATE_MAX;
+/* We use RUN_STATE__MAX but any invalid value will do */
+static RunState vmstop_requested = RUN_STATE__MAX;

 static QemuMutex vmstop_lock;
 
 typedef struct {
 static QemuMutex vmstop_lock;
 
 typedef struct {


@@ -576,6 +579,7 @@ static const RunStateTransition runstate_transitions_def[] = {
     /*     from      ->     to      */
     { RUN_STATE_DEBUG, RUN_STATE_RUNNING },
     { RUN_STATE_DEBUG, RUN_STATE_FINISH_MIGRATE },
     /*     from      ->     to      */
     { RUN_STATE_DEBUG, RUN_STATE_RUNNING },
     { RUN_STATE_DEBUG, RUN_STATE_FINISH_MIGRATE },

+    { RUN_STATE_DEBUG, RUN_STATE_PRELAUNCH },

 
     { RUN_STATE_INMIGRATE, RUN_STATE_INTERNAL_ERROR },
     { RUN_STATE_INMIGRATE, RUN_STATE_IO_ERROR },
 
     { RUN_STATE_INMIGRATE, RUN_STATE_INTERNAL_ERROR },
     { RUN_STATE_INMIGRATE, RUN_STATE_IO_ERROR },


@@ -586,18 +590,24 @@ static const RunStateTransition runstate_transitions_def[] = {
     { RUN_STATE_INMIGRATE, RUN_STATE_WATCHDOG },
     { RUN_STATE_INMIGRATE, RUN_STATE_GUEST_PANICKED },
     { RUN_STATE_INMIGRATE, RUN_STATE_FINISH_MIGRATE },
     { RUN_STATE_INMIGRATE, RUN_STATE_WATCHDOG },
     { RUN_STATE_INMIGRATE, RUN_STATE_GUEST_PANICKED },
     { RUN_STATE_INMIGRATE, RUN_STATE_FINISH_MIGRATE },

+    { RUN_STATE_INMIGRATE, RUN_STATE_PRELAUNCH },
+    { RUN_STATE_INMIGRATE, RUN_STATE_POSTMIGRATE },

 
     { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PAUSED },
     { RUN_STATE_INTERNAL_ERROR, RUN_STATE_FINISH_MIGRATE },
 
     { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PAUSED },
     { RUN_STATE_INTERNAL_ERROR, RUN_STATE_FINISH_MIGRATE },

+    { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PRELAUNCH },

 
     { RUN_STATE_IO_ERROR, RUN_STATE_RUNNING },
     { RUN_STATE_IO_ERROR, RUN_STATE_FINISH_MIGRATE },
 
     { RUN_STATE_IO_ERROR, RUN_STATE_RUNNING },
     { RUN_STATE_IO_ERROR, RUN_STATE_FINISH_MIGRATE },

+    { RUN_STATE_IO_ERROR, RUN_STATE_PRELAUNCH },

 
     { RUN_STATE_PAUSED, RUN_STATE_RUNNING },
     { RUN_STATE_PAUSED, RUN_STATE_FINISH_MIGRATE },
 
     { RUN_STATE_PAUSED, RUN_STATE_RUNNING },
     { RUN_STATE_PAUSED, RUN_STATE_FINISH_MIGRATE },

+    { RUN_STATE_PAUSED, RUN_STATE_PRELAUNCH },

 
     { RUN_STATE_POSTMIGRATE, RUN_STATE_RUNNING },
     { RUN_STATE_POSTMIGRATE, RUN_STATE_FINISH_MIGRATE },
 
     { RUN_STATE_POSTMIGRATE, RUN_STATE_RUNNING },
     { RUN_STATE_POSTMIGRATE, RUN_STATE_FINISH_MIGRATE },

+    { RUN_STATE_POSTMIGRATE, RUN_STATE_PRELAUNCH },

 
     { RUN_STATE_PRELAUNCH, RUN_STATE_RUNNING },
     { RUN_STATE_PRELAUNCH, RUN_STATE_FINISH_MIGRATE },
 
     { RUN_STATE_PRELAUNCH, RUN_STATE_RUNNING },
     { RUN_STATE_PRELAUNCH, RUN_STATE_FINISH_MIGRATE },


@@ -605,8 +615,10 @@ static const RunStateTransition runstate_transitions_def[] = {
 
     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_RUNNING },
     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_POSTMIGRATE },
 
     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_RUNNING },
     { RUN_STATE_FINISH_MIGRATE, RUN_STATE_POSTMIGRATE },

+    { RUN_STATE_FINISH_MIGRATE, RUN_STATE_PRELAUNCH },

 
     { RUN_STATE_RESTORE_VM, RUN_STATE_RUNNING },
 
     { RUN_STATE_RESTORE_VM, RUN_STATE_RUNNING },

+    { RUN_STATE_RESTORE_VM, RUN_STATE_PRELAUNCH },

 
     { RUN_STATE_RUNNING, RUN_STATE_DEBUG },
     { RUN_STATE_RUNNING, RUN_STATE_INTERNAL_ERROR },
 
     { RUN_STATE_RUNNING, RUN_STATE_DEBUG },
     { RUN_STATE_RUNNING, RUN_STATE_INTERNAL_ERROR },


@@ -623,22 +635,26 @@ static const RunStateTransition runstate_transitions_def[] = {
 
     { RUN_STATE_SHUTDOWN, RUN_STATE_PAUSED },
     { RUN_STATE_SHUTDOWN, RUN_STATE_FINISH_MIGRATE },
 
     { RUN_STATE_SHUTDOWN, RUN_STATE_PAUSED },
     { RUN_STATE_SHUTDOWN, RUN_STATE_FINISH_MIGRATE },

+    { RUN_STATE_SHUTDOWN, RUN_STATE_PRELAUNCH },

 
     { RUN_STATE_DEBUG, RUN_STATE_SUSPENDED },
     { RUN_STATE_RUNNING, RUN_STATE_SUSPENDED },
     { RUN_STATE_SUSPENDED, RUN_STATE_RUNNING },
     { RUN_STATE_SUSPENDED, RUN_STATE_FINISH_MIGRATE },
 
     { RUN_STATE_DEBUG, RUN_STATE_SUSPENDED },
     { RUN_STATE_RUNNING, RUN_STATE_SUSPENDED },
     { RUN_STATE_SUSPENDED, RUN_STATE_RUNNING },
     { RUN_STATE_SUSPENDED, RUN_STATE_FINISH_MIGRATE },

+    { RUN_STATE_SUSPENDED, RUN_STATE_PRELAUNCH },

 
     { RUN_STATE_WATCHDOG, RUN_STATE_RUNNING },
     { RUN_STATE_WATCHDOG, RUN_STATE_FINISH_MIGRATE },
 
     { RUN_STATE_WATCHDOG, RUN_STATE_RUNNING },
     { RUN_STATE_WATCHDOG, RUN_STATE_FINISH_MIGRATE },

+    { RUN_STATE_WATCHDOG, RUN_STATE_PRELAUNCH },

 
     { RUN_STATE_GUEST_PANICKED, RUN_STATE_RUNNING },
     { RUN_STATE_GUEST_PANICKED, RUN_STATE_FINISH_MIGRATE },
 
     { RUN_STATE_GUEST_PANICKED, RUN_STATE_RUNNING },
     { RUN_STATE_GUEST_PANICKED, RUN_STATE_FINISH_MIGRATE },

+    { RUN_STATE_GUEST_PANICKED, RUN_STATE_PRELAUNCH },

 
 

-    { RUN_STATE_MAX, RUN_STATE_MAX },
+    { RUN_STATE__MAX, RUN_STATE__MAX },

 };
 
 };
 

-static bool runstate_valid_transitions[RUN_STATE_MAX][RUN_STATE_MAX];
+static bool runstate_valid_transitions[RUN_STATE__MAX][RUN_STATE__MAX];

 
 bool runstate_check(RunState state)
 {
 
 bool runstate_check(RunState state)
 {


@@ -662,7 +678,7 @@ static void runstate_init(void)
     const RunStateTransition *p;
 
     memset(&runstate_valid_transitions, 0, sizeof(runstate_valid_transitions));
     const RunStateTransition *p;
 
     memset(&runstate_valid_transitions, 0, sizeof(runstate_valid_transitions));

-    for (p = &runstate_transitions_def[0]; p->from != RUN_STATE_MAX; p++) {
+    for (p = &runstate_transitions_def[0]; p->from != RUN_STATE__MAX; p++) {

         runstate_valid_transitions[p->from][p->to] = true;
     }
 
         runstate_valid_transitions[p->from][p->to] = true;
     }
 


@@ -672,7 +688,7 @@ static void runstate_init(void)
 /* This function will abort() on invalid state transitions */
 void runstate_set(RunState new_state)
 {
 /* This function will abort() on invalid state transitions */
 void runstate_set(RunState new_state)
 {

-    assert(new_state < RUN_STATE_MAX);
+    assert(new_state < RUN_STATE__MAX);

 
     if (!runstate_valid_transitions[current_run_state][new_state]) {
         error_report("invalid runstate transition: '%s' -> '%s'",
 
     if (!runstate_valid_transitions[current_run_state][new_state]) {
         error_report("invalid runstate transition: '%s' -> '%s'",


@@ -710,9 +726,9 @@ static bool qemu_vmstop_requested(RunState *r)
 {
     qemu_mutex_lock(&vmstop_lock);
     *r = vmstop_requested;
 {
     qemu_mutex_lock(&vmstop_lock);
     *r = vmstop_requested;

-    vmstop_requested = RUN_STATE_MAX;
+    vmstop_requested = RUN_STATE__MAX;

     qemu_mutex_unlock(&vmstop_lock);
     qemu_mutex_unlock(&vmstop_lock);

-    return *r < RUN_STATE_MAX;
+    return *r < RUN_STATE__MAX;

 }
 
 void qemu_system_vmstop_request_prepare(void)
 }
 
 void qemu_system_vmstop_request_prepare(void)


@@ -732,7 +748,7 @@ void vm_start(void)
     RunState requested;
 
     qemu_vmstop_requested(&requested);
     RunState requested;
 
     qemu_vmstop_requested(&requested);

-    if (runstate_is_running() && requested == RUN_STATE_MAX) {
+    if (runstate_is_running() && requested == RUN_STATE__MAX) {

         return;
     }
 
         return;
     }
 


@@ -847,7 +863,11 @@ static void configure_rtc(QemuOpts *opts)
         if (!strcmp(value, "utc")) {
             rtc_utc = 1;
         } else if (!strcmp(value, "localtime")) {
         if (!strcmp(value, "utc")) {
             rtc_utc = 1;
         } else if (!strcmp(value, "localtime")) {

+            Error *blocker = NULL;

             rtc_utc = 0;
             rtc_utc = 0;

+            error_setg(&blocker, QERR_REPLAY_NOT_SUPPORTED,
+                      "-rtc base=localtime");
+            replay_add_blocker(blocker);

         } else {
             configure_rtc_date_offset(value, 0);
         }
         } else {
             configure_rtc_date_offset(value, 0);
         }


@@ -1256,6 +1276,11 @@ static void smp_parse(QemuOpts *opts)
         exit(1);
     }
 
         exit(1);
     }
 

+    if (smp_cpus > 1 || smp_cores > 1 || smp_threads > 1) {
+        Error *blocker = NULL;
+        error_setg(&blocker, QERR_REPLAY_NOT_SUPPORTED, "smp");
+        replay_add_blocker(blocker);
+    }

 }
 
 static void realtime_init(void)
 }
 
 static void realtime_init(void)


@@ -1520,12 +1545,14 @@ MachineInfoList *qmp_query_machines(Error **errp)
 static int machine_help_func(QemuOpts *opts, MachineState *machine)
 {
     ObjectProperty *prop;
 static int machine_help_func(QemuOpts *opts, MachineState *machine)
 {
     ObjectProperty *prop;

+    ObjectPropertyIterator iter;

 
     if (!qemu_opt_has_help_opt(opts)) {
         return 0;
     }
 
 
     if (!qemu_opt_has_help_opt(opts)) {
         return 0;
     }
 

-    QTAILQ_FOREACH(prop, &OBJECT(machine)->properties, node) {
+    object_property_iter_init(&iter, OBJECT(machine));
+    while ((prop = object_property_iter_next(&iter))) {

         if (!prop->set) {
             continue;
         }
         if (!prop->set) {
             continue;
         }


@@ -1642,15 +1669,21 @@ static void qemu_kill_report(void)
 static int qemu_reset_requested(void)
 {
     int r = reset_requested;
 static int qemu_reset_requested(void)
 {
     int r = reset_requested;

-    reset_requested = 0;
-    return r;
+    if (r && replay_checkpoint(CHECKPOINT_RESET_REQUESTED)) {
+        reset_requested = 0;
+        return r;
+    }
+    return false;

 }
 
 static int qemu_suspend_requested(void)
 {
     int r = suspend_requested;
 }
 
 static int qemu_suspend_requested(void)
 {
     int r = suspend_requested;

-    suspend_requested = 0;
-    return r;
+    if (r && replay_checkpoint(CHECKPOINT_SUSPEND_REQUESTED)) {
+        suspend_requested = 0;
+        return r;
+    }
+    return false;

 }
 
 static WakeupReason qemu_wakeup_requested(void)
 }
 
 static WakeupReason qemu_wakeup_requested(void)


@@ -1798,7 +1831,12 @@ void qemu_system_killed(int signal, pid_t pid)
     shutdown_signal = signal;
     shutdown_pid = pid;
     no_shutdown = 0;
     shutdown_signal = signal;
     shutdown_pid = pid;
     no_shutdown = 0;

-    qemu_system_shutdown_request();
+
+    /* Cannot call qemu_system_shutdown_request directly because
+     * we are in a signal handler.
+     */
+    shutdown_requested = 1;
+    qemu_notify_event();

 }
 
 void qemu_system_shutdown_request(void)
 }
 
 void qemu_system_shutdown_request(void)


@@ -1856,8 +1894,9 @@ static bool main_loop_should_exit(void)
         cpu_synchronize_all_states();
         qemu_system_reset(VMRESET_REPORT);
         resume_all_vcpus();
         cpu_synchronize_all_states();
         qemu_system_reset(VMRESET_REPORT);
         resume_all_vcpus();

-        if (runstate_needs_reset()) {
-            runstate_set(RUN_STATE_PAUSED);
+        if (!runstate_check(RUN_STATE_RUNNING) &&
+                !runstate_check(RUN_STATE_INMIGRATE)) {
+            runstate_set(RUN_STATE_PRELAUNCH);

         }
     }
     if (qemu_wakeup_requested()) {
         }
     }
     if (qemu_wakeup_requested()) {


@@ -2518,11 +2557,7 @@ static int virtcon_parse(const char *devname)
     }
 
     bus_opts = qemu_opts_create(device, NULL, 0, &error_abort);
     }
 
     bus_opts = qemu_opts_create(device, NULL, 0, &error_abort);

-    if (arch_type == QEMU_ARCH_S390X) {
-        qemu_opt_set(bus_opts, "driver", "virtio-serial-s390", &error_abort);
-    } else {
-        qemu_opt_set(bus_opts, "driver", "virtio-serial-pci", &error_abort);
-    }
+    qemu_opt_set(bus_opts, "driver", "virtio-serial", &error_abort);

 
     dev_opts = qemu_opts_create(device, NULL, 0, &error_abort);
     qemu_opt_set(dev_opts, "driver", "virtconsole", &error_abort);
 
     dev_opts = qemu_opts_create(device, NULL, 0, &error_abort);
     qemu_opt_set(dev_opts, "driver", "virtconsole", &error_abort);


@@ -2727,6 +2762,33 @@ static const QEMUOption *lookup_opt(int argc, char **argv,
     return popt;
 }
 
     return popt;
 }
 

+static MachineClass *select_machine(void)
+{
+    MachineClass *machine_class = find_default_machine();
+    const char *optarg;
+    QemuOpts *opts;
+    Location loc;
+
+    loc_push_none(&loc);
+
+    opts = qemu_get_machine_opts();
+    qemu_opts_loc_restore(opts);
+
+    optarg = qemu_opt_get(opts, "type");
+    if (optarg) {
+        machine_class = machine_parse(optarg);
+    }
+
+    if (!machine_class) {
+        error_report("No machine specified, and there is no default");
+        error_printf("Use -machine help to list supported machines\n");
+        exit(1);
+    }
+
+    loc_pop(&loc);
+    return machine_class;
+}
+

 static int machine_set_property(void *opaque,
                                 const char *name, const char *value,
                                 Error **errp)
 static int machine_set_property(void *opaque,
                                 const char *name, const char *value,
                                 Error **errp)


@@ -2795,62 +2857,6 @@ static bool object_create_delayed(const char *type)
 }
 
 
 }
 
 

-static int object_create(void *opaque, QemuOpts *opts, Error **errp)
-{
-    Error *err = NULL;
-    char *type = NULL;
-    char *id = NULL;
-    void *dummy = NULL;
-    OptsVisitor *ov;
-    QDict *pdict;
-    bool (*type_predicate)(const char *) = opaque;
-
-    ov = opts_visitor_new(opts);
-    pdict = qemu_opts_to_qdict(opts, NULL);
-
-    visit_start_struct(opts_get_visitor(ov), &dummy, NULL, NULL, 0, &err);
-    if (err) {
-        goto out;
-    }
-
-    qdict_del(pdict, "qom-type");
-    visit_type_str(opts_get_visitor(ov), &type, "qom-type", &err);
-    if (err) {
-        goto out;
-    }
-    if (!type_predicate(type)) {
-        goto out;
-    }
-
-    qdict_del(pdict, "id");
-    visit_type_str(opts_get_visitor(ov), &id, "id", &err);
-    if (err) {
-        goto out;
-    }
-
-    object_add(type, id, pdict, opts_get_visitor(ov), &err);
-    if (err) {
-        goto out;
-    }
-    visit_end_struct(opts_get_visitor(ov), &err);
-    if (err) {
-        qmp_object_del(id, NULL);
-    }
-
-out:
-    opts_visitor_cleanup(ov);
-
-    QDECREF(pdict);
-    g_free(id);
-    g_free(type);
-    g_free(dummy);
-    if (err) {
-        error_report_err(err);
-        return -1;
-    }
-    return 0;
-}
-

 static void set_memory_options(uint64_t *ram_slots, ram_addr_t *maxram_size,
                                MachineClass *mc)
 {
 static void set_memory_options(uint64_t *ram_slots, ram_addr_t *maxram_size,
                                MachineClass *mc)
 {


@@ -2859,6 +2865,10 @@ static void set_memory_options(uint64_t *ram_slots, ram_addr_t *maxram_size,
     const char *maxmem_str, *slots_str;
     const ram_addr_t default_ram_size = mc->default_ram_size;
     QemuOpts *opts = qemu_find_opts_singleton("memory");
     const char *maxmem_str, *slots_str;
     const ram_addr_t default_ram_size = mc->default_ram_size;
     QemuOpts *opts = qemu_find_opts_singleton("memory");

+    Location loc;
+
+    loc_push_none(&loc);
+    qemu_opts_loc_restore(opts);

 
     sz = 0;
     mem_str = qemu_opt_get(opts, "size");
 
     sz = 0;
     mem_str = qemu_opt_get(opts, "size");


@@ -2933,6 +2943,8 @@ static void set_memory_options(uint64_t *ram_slots, ram_addr_t *maxram_size,
                 "'%s' option", slots_str ? "maxmem" : "slots");
         exit(EXIT_FAILURE);
     }
                 "'%s' option", slots_str ? "maxmem" : "slots");
         exit(EXIT_FAILURE);
     }

+
+    loc_pop(&loc);

 }
 
 int main(int argc, char **argv, char **envp)
 }
 
 int main(int argc, char **argv, char **envp)


@@ -2964,8 +2976,7 @@ int main(int argc, char **argv, char **envp)
     bool userconfig = true;
     const char *log_mask = NULL;
     const char *log_file = NULL;
     bool userconfig = true;
     const char *log_mask = NULL;
     const char *log_file = NULL;

-    const char *trace_events = NULL;
-    const char *trace_file = NULL;
+    char *trace_file = NULL;

     ram_addr_t maxram_size;
     uint64_t ram_slots = 0;
     FILE *vmstate_dump_file = NULL;
     ram_addr_t maxram_size;
     uint64_t ram_slots = 0;
     FILE *vmstate_dump_file = NULL;


@@ -3013,7 +3024,7 @@ int main(int argc, char **argv, char **envp)
     runstate_init();
 
     if (qcrypto_init(&err) < 0) {
     runstate_init();
 
     if (qcrypto_init(&err) < 0) {

-        error_report("cannot initialize crypto: %s", error_get_pretty(err));
+        error_reportf_err(err, "cannot initialize crypto: ");

         exit(1);
     }
     rtc_clock = QEMU_CLOCK_HOST;
         exit(1);
     }
     rtc_clock = QEMU_CLOCK_HOST;


@@ -3022,7 +3033,6 @@ int main(int argc, char **argv, char **envp)
     os_setup_early_signal_handling();
 
     module_call_init(MODULE_INIT_MACHINE);
     os_setup_early_signal_handling();
 
     module_call_init(MODULE_INIT_MACHINE);

-    machine_class = find_default_machine();

     cpu_model = NULL;
     snapshot = 0;
     cyls = heads = secs = 0;
     cpu_model = NULL;
     snapshot = 0;
     cyls = heads = secs = 0;


@@ -3284,12 +3294,18 @@ int main(int argc, char **argv, char **envp)
 #endif
 #ifdef CONFIG_SLIRP
             case QEMU_OPTION_tftp:
 #endif
 #ifdef CONFIG_SLIRP
             case QEMU_OPTION_tftp:

+                error_report("The -tftp option is deprecated. "
+                             "Please use '-netdev user,tftp=...' instead.");

                 legacy_tftp_prefix = optarg;
                 break;
             case QEMU_OPTION_bootp:
                 legacy_tftp_prefix = optarg;
                 break;
             case QEMU_OPTION_bootp:

+                error_report("The -bootp option is deprecated. "
+                             "Please use '-netdev user,bootfile=...' instead.");

                 legacy_bootp_filename = optarg;
                 break;
             case QEMU_OPTION_redir:
                 legacy_bootp_filename = optarg;
                 break;
             case QEMU_OPTION_redir:

+                error_report("The -redir option is deprecated. "
+                             "Please use '-netdev user,hostfwd=...' instead.");

                 if (net_slirp_redir(optarg) < 0)
                     exit(1);
                 break;
                 if (net_slirp_redir(optarg) < 0)
                     exit(1);
                 break;


@@ -3877,12 +3893,19 @@ int main(int argc, char **argv, char **envp)
             case QEMU_OPTION_trace:
             {
                 opts = qemu_opts_parse_noisily(qemu_find_opts("trace"),
             case QEMU_OPTION_trace:
             {
                 opts = qemu_opts_parse_noisily(qemu_find_opts("trace"),

-                                               optarg, false);
+                                               optarg, true);

                 if (!opts) {
                     exit(1);
                 }
                 if (!opts) {
                     exit(1);
                 }

-                trace_events = qemu_opt_get(opts, "events");
-                trace_file = qemu_opt_get(opts, "file");
+                if (qemu_opt_get(opts, "enable")) {
+                    trace_enable_events(qemu_opt_get(opts, "enable"));
+                }
+                trace_init_events(qemu_opt_get(opts, "events"));
+                if (trace_file) {
+                    g_free(trace_file);
+                }
+                trace_file = g_strdup(qemu_opt_get(opts, "file"));
+                qemu_opts_del(opts);

                 break;
             }
             case QEMU_OPTION_readconfig:
                 break;
             }
             case QEMU_OPTION_readconfig:


@@ -3992,23 +4015,18 @@ int main(int argc, char **argv, char **envp)
             }
         }
     }
             }
         }
     }

+    /*
+     * Clear error location left behind by the loop.
+     * Best done right after the loop.  Do not insert code here!
+     */
+    loc_set_none();

 
 

-    opts = qemu_get_machine_opts();
-    optarg = qemu_opt_get(opts, "type");
-    if (optarg) {
-        machine_class = machine_parse(optarg);
-    }
+    replay_configure(icount_opts);

 
 

-    if (machine_class == NULL) {
-        error_report("No machine specified, and there is no default");
-        error_printf("Use -machine help to list supported machines\n");
-        exit(1);
-    }
+    machine_class = select_machine();

 
     set_memory_options(&ram_slots, &maxram_size, machine_class);
 
 
     set_memory_options(&ram_slots, &maxram_size, machine_class);
 

-    loc_set_none();
-

     os_daemonize();
 
     if (qemu_init_main_loop(&main_loop_err)) {
     os_daemonize();
 
     if (qemu_init_main_loop(&main_loop_err)) {


@@ -4048,7 +4066,7 @@ int main(int argc, char **argv, char **envp)
     cpu_exec_init_all();
 
     if (machine_class->hw_version) {
     cpu_exec_init_all();
 
     if (machine_class->hw_version) {

-        qemu_set_version(machine_class->hw_version);
+        qemu_set_hw_version(machine_class->hw_version);

     }
 
     /* Init CPU def lists, based on config
     }
 
     /* Init CPU def lists, based on config


@@ -4063,6 +4081,8 @@ int main(int argc, char **argv, char **envp)
         exit(0);
     }
 
         exit(0);
     }
 

+    trace_init_file(trace_file);
+

     /* Open the logfile at this point and set the log mask if necessary.
      */
     if (log_file) {
     /* Open the logfile at this point and set the log mask if necessary.
      */
     if (log_file) {


@@ -4077,12 +4097,12 @@ int main(int argc, char **argv, char **envp)
             exit(1);
         }
         qemu_set_log(mask);
             exit(1);
         }
         qemu_set_log(mask);

+    } else {
+        qemu_set_log(0);

     }
 
     }
 

-    if (!is_daemonized()) {
-        if (!trace_init_backends(trace_events, trace_file)) {
-            exit(1);
-        }
+    if (!trace_init_backends()) {
+        exit(1);

     }
 
     /* If no data_dir is specified then try to find it relative to the
     }
 
     /* If no data_dir is specified then try to find it relative to the


@@ -4256,11 +4276,13 @@ int main(int argc, char **argv, char **envp)
         exit(1);
     }
 
         exit(1);
     }
 

+    page_size_init();

     socket_init();
 
     if (qemu_opts_foreach(qemu_find_opts("object"),
     socket_init();
 
     if (qemu_opts_foreach(qemu_find_opts("object"),

-                          object_create,
-                          object_create_initial, NULL)) {
+                          user_creatable_add_opts_foreach,
+                          object_create_initial, &err)) {
+        error_report_err(err);

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


@@ -4296,12 +4318,7 @@ int main(int argc, char **argv, char **envp)
     configure_accelerator(current_machine);
 
     if (qtest_chrdev) {
     configure_accelerator(current_machine);
 
     if (qtest_chrdev) {

-        Error *local_err = NULL;
-        qtest_init(qtest_chrdev, qtest_log, &local_err);
-        if (local_err) {
-            error_report_err(local_err);
-            exit(1);
-        }
+        qtest_init(qtest_chrdev, qtest_log, &error_fatal);

     }
 
     machine_opts = qemu_get_machine_opts();
     }
 
     machine_opts = qemu_get_machine_opts();


@@ -4312,24 +4329,14 @@ int main(int argc, char **argv, char **envp)
 
     opts = qemu_opts_find(qemu_find_opts("boot-opts"), NULL);
     if (opts) {
 
     opts = qemu_opts_find(qemu_find_opts("boot-opts"), NULL);
     if (opts) {

-        Error *local_err = NULL;
-

         boot_order = qemu_opt_get(opts, "order");
         if (boot_order) {
         boot_order = qemu_opt_get(opts, "order");
         if (boot_order) {

-            validate_bootdevices(boot_order, &local_err);
-            if (local_err) {
-                error_report_err(local_err);
-                exit(1);
-            }
+            validate_bootdevices(boot_order, &error_fatal);

         }
 
         boot_once = qemu_opt_get(opts, "once");
         if (boot_once) {
         }
 
         boot_once = qemu_opt_get(opts, "once");
         if (boot_once) {

-            validate_bootdevices(boot_once, &local_err);
-            if (local_err) {
-                error_report_err(local_err);
-                exit(1);
-            }
+            validate_bootdevices(boot_once, &error_fatal);

         }
 
         boot_menu = qemu_opt_get_bool(opts, "menu", boot_menu);
         }
 
         boot_menu = qemu_opt_get_bool(opts, "menu", boot_menu);


@@ -4392,8 +4399,9 @@ int main(int argc, char **argv, char **envp)
     }
 
     if (qemu_opts_foreach(qemu_find_opts("object"),
     }
 
     if (qemu_opts_foreach(qemu_find_opts("object"),

-                          object_create,
-                          object_create_delayed, NULL)) {
+                          user_creatable_add_opts_foreach,
+                          object_create_delayed, &err)) {
+        error_report_err(err);

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


@@ -4426,9 +4434,10 @@ int main(int argc, char **argv, char **envp)
     }
 
     /* open the virtual block devices */
     }
 
     /* open the virtual block devices */

-    if (snapshot)
-        qemu_opts_foreach(qemu_find_opts("drive"),
-                          drive_enable_snapshot, NULL, NULL);
+    if (snapshot || replay_mode != REPLAY_MODE_NONE) {
+        qemu_opts_foreach(qemu_find_opts("drive"), drive_enable_snapshot,
+                          NULL, NULL);
+    }

     if (qemu_opts_foreach(qemu_find_opts("drive"), drive_init_func,
                           &machine_class->block_default_type, NULL)) {
         exit(1);
     if (qemu_opts_foreach(qemu_find_opts("drive"), drive_init_func,
                           &machine_class->block_default_type, NULL)) {
         exit(1);


@@ -4483,6 +4492,10 @@ int main(int argc, char **argv, char **envp)
     }
     qemu_add_globals();
 
     }
     qemu_add_globals();
 

+    /* This checkpoint is required by replay to separate prior clock
+       reading from the other reads, because timer polling functions query
+       clock values from the log. */
+    replay_checkpoint(CHECKPOINT_INIT);

     qdev_machine_init();
 
     current_machine->ram_size = ram_size;
     qdev_machine_init();
 
     current_machine->ram_size = ram_size;


@@ -4527,12 +4540,7 @@ int main(int argc, char **argv, char **envp)
     net_check_clients();
 
     if (boot_once) {
     net_check_clients();
 
     if (boot_once) {

-        Error *local_err = NULL;
-        qemu_boot_set(boot_once, &local_err);
-        if (local_err) {
-            error_report("%s", error_get_pretty(local_err));
-            exit(1);
-        }
+        qemu_boot_set(boot_once, &error_fatal);

         qemu_register_reset(restore_boot_order, g_strdup(boot_order));
     }
 
         qemu_register_reset(restore_boot_order, g_strdup(boot_order));
     }
 


@@ -4601,6 +4609,12 @@ int main(int argc, char **argv, char **envp)
         exit(1);
     }
 
         exit(1);
     }
 

+    replay_start();
+
+    /* This checkpoint is required by replay to separate prior clock
+       reading from the other reads, because timer polling functions query
+       clock values from the log. */
+    replay_checkpoint(CHECKPOINT_RESET);

     qemu_system_reset(VMRESET_SILENT);
     register_global_state();
     if (loadvm) {
     qemu_system_reset(VMRESET_SILENT);
     register_global_state();
     if (loadvm) {


@@ -4620,9 +4634,7 @@ int main(int argc, char **argv, char **envp)
         Error *local_err = NULL;
         qemu_start_incoming_migration(incoming, &local_err);
         if (local_err) {
         Error *local_err = NULL;
         qemu_start_incoming_migration(incoming, &local_err);
         if (local_err) {

-            error_report("-incoming %s: %s", incoming,
-                         error_get_pretty(local_err));
-            error_free(local_err);
+            error_reportf_err(local_err, "-incoming %s: ", incoming);

             exit(1);
         }
     } else if (autostart) {
             exit(1);
         }
     } else if (autostart) {


@@ -4631,13 +4643,9 @@ int main(int argc, char **argv, char **envp)
 
     os_setup_post();
 
 
     os_setup_post();
 

-    if (is_daemonized()) {
-        if (!trace_init_backends(trace_events, trace_file)) {
-            exit(1);
-        }
-    }
-

     main_loop();
     main_loop();

+    replay_disable_events();
+

     bdrv_close_all();
     pause_all_vcpus();
     res_free();
     bdrv_close_all();
     pause_all_vcpus();
     res_free();