vmware-vga: Remove dead DIRECT_VRAM mode

[qemu.git] / vl.c

diff --git a/vl.c b/vl.c
index 52402a2b73b764f85d2307e26f311ebe70d1ae5b..9cd67a37465a685f5501577a7a87b64ce3445065 100644 (file)
--- a/vl.c
+++ b/vl.c
@@ -228,6 +228,9 @@ int ctrl_grab = 0;
 unsigned int nb_prom_envs = 0;
 const char *prom_envs[MAX_PROM_ENVS];
 int boot_menu;
 unsigned int nb_prom_envs = 0;
 const char *prom_envs[MAX_PROM_ENVS];
 int boot_menu;

+uint8_t *boot_splash_filedata;
+int boot_splash_filedata_size;
+uint8_t qemu_extra_params_fw[2];

 
 typedef struct FWBootEntry FWBootEntry;
 
 
 typedef struct FWBootEntry FWBootEntry;
 


@@ -262,6 +265,7 @@ int kvm_allowed = 0;
 int xen_allowed = 0;
 uint32_t xen_domid;
 enum xen_mode xen_mode = XEN_EMULATE;
 int xen_allowed = 0;
 uint32_t xen_domid;
 enum xen_mode xen_mode = XEN_EMULATE;

+static int tcg_tb_size;

 
 static int default_serial = 1;
 static int default_parallel = 1;
 
 static int default_serial = 1;
 static int default_parallel = 1;


@@ -293,6 +297,14 @@ static struct {
     { .driver = "qxl-vga",              .flag = &default_vga       },
 };
 
     { .driver = "qxl-vga",              .flag = &default_vga       },
 };
 

+static void res_free(void)
+{
+    if (boot_splash_filedata != NULL) {
+        g_free(boot_splash_filedata);
+        boot_splash_filedata = NULL;
+    }
+}
+

 static int default_driver_check(QemuOpts *opts, void *opaque)
 {
     const char *driver = qemu_opt_get(opts, "driver");
 static int default_driver_check(QemuOpts *opts, void *opaque)
 {
     const char *driver = qemu_opt_get(opts, "driver");


@@ -454,7 +466,7 @@ static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
         if (vlan->id == id)
             return &vlan->net;
     }
         if (vlan->id == id)
             return &vlan->net;
     }

-    vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
+    vlan = g_malloc0(sizeof(struct bt_vlan_s));

     vlan->id = id;
     pvlan = &first_bt_vlan;
     while (*pvlan != NULL)
     vlan->id = id;
     pvlan = &first_bt_vlan;
     while (*pvlan != NULL)


@@ -729,7 +741,7 @@ static void restore_boot_devices(void *opaque)
     qemu_boot_set(standard_boot_devices);
 
     qemu_unregister_reset(restore_boot_devices, standard_boot_devices);
     qemu_boot_set(standard_boot_devices);
 
     qemu_unregister_reset(restore_boot_devices, standard_boot_devices);

-    qemu_free(standard_boot_devices);
+    g_free(standard_boot_devices);

 }
 
 void add_boot_device_path(int32_t bootindex, DeviceState *dev,
 }
 
 void add_boot_device_path(int32_t bootindex, DeviceState *dev,


@@ -743,9 +755,9 @@ void add_boot_device_path(int32_t bootindex, DeviceState *dev,
 
     assert(dev != NULL || suffix != NULL);
 
 
     assert(dev != NULL || suffix != NULL);
 

-    node = qemu_mallocz(sizeof(FWBootEntry));
+    node = g_malloc0(sizeof(FWBootEntry));

     node->bootindex = bootindex;
     node->bootindex = bootindex;

-    node->suffix = suffix ? qemu_strdup(suffix) : NULL;
+    node->suffix = suffix ? g_strdup(suffix) : NULL;

     node->dev = dev;
 
     QTAILQ_FOREACH(i, &fw_boot_order, link) {
     node->dev = dev;
 
     QTAILQ_FOREACH(i, &fw_boot_order, link) {


@@ -786,13 +798,13 @@ char *get_boot_devices_list(uint32_t *size)
         if (i->suffix && devpath) {
             size_t bootpathlen = strlen(devpath) + strlen(i->suffix) + 1;
 
         if (i->suffix && devpath) {
             size_t bootpathlen = strlen(devpath) + strlen(i->suffix) + 1;
 

-            bootpath = qemu_malloc(bootpathlen);
+            bootpath = g_malloc(bootpathlen);

             snprintf(bootpath, bootpathlen, "%s%s", devpath, i->suffix);
             snprintf(bootpath, bootpathlen, "%s%s", devpath, i->suffix);

-            qemu_free(devpath);
+            g_free(devpath);

         } else if (devpath) {
             bootpath = devpath;
         } else {
         } else if (devpath) {
             bootpath = devpath;
         } else {

-            bootpath = qemu_strdup(i->suffix);
+            bootpath = g_strdup(i->suffix);

             assert(bootpath);
         }
 
             assert(bootpath);
         }
 


@@ -800,10 +812,10 @@ char *get_boot_devices_list(uint32_t *size)
             list[total-1] = '\n';
         }
         len = strlen(bootpath) + 1;
             list[total-1] = '\n';
         }
         len = strlen(bootpath) + 1;

-        list = qemu_realloc(list, total + len);
+        list = g_realloc(list, total + len);

         memcpy(&list[total], bootpath, len);
         total += len;
         memcpy(&list[total], bootpath, len);
         total += len;

-        qemu_free(bootpath);
+        g_free(bootpath);

     }
 
     *size = total;
     }
 
     *size = total;


@@ -1002,7 +1014,7 @@ void pcmcia_socket_register(PCMCIASocket *socket)
 {
     struct pcmcia_socket_entry_s *entry;
 
 {
     struct pcmcia_socket_entry_s *entry;
 

-    entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
+    entry = g_malloc(sizeof(struct pcmcia_socket_entry_s));

     entry->socket = socket;
     entry->next = pcmcia_sockets;
     pcmcia_sockets = entry;
     entry->socket = socket;
     entry->next = pcmcia_sockets;
     pcmcia_sockets = entry;


@@ -1016,7 +1028,7 @@ void pcmcia_socket_unregister(PCMCIASocket *socket)
     for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
         if (entry->socket == socket) {
             *ptr = entry->next;
     for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
         if (entry->socket == socket) {
             *ptr = entry->next;

-            qemu_free(entry);
+            g_free(entry);

         }
 }
 
         }
 }
 


@@ -1117,7 +1129,7 @@ VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
 {
     VMChangeStateEntry *e;
 
 {
     VMChangeStateEntry *e;
 

-    e = qemu_mallocz(sizeof (*e));
+    e = g_malloc0(sizeof (*e));

 
     e->cb = cb;
     e->opaque = opaque;
 
     e->cb = cb;
     e->opaque = opaque;


@@ -1128,7 +1140,7 @@ VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
 {
     QLIST_REMOVE (e, entries);
 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
 {
     QLIST_REMOVE (e, entries);

-    qemu_free (e);
+    g_free (e);

 }
 
 void vm_state_notify(int running, int reason)
 }
 
 void vm_state_notify(int running, int reason)


@@ -1233,7 +1245,7 @@ static int qemu_vmstop_requested(void)
 
 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
 {
 
 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
 {

-    QEMUResetEntry *re = qemu_mallocz(sizeof(QEMUResetEntry));
+    QEMUResetEntry *re = g_malloc0(sizeof(QEMUResetEntry));

 
     re->func = func;
     re->opaque = opaque;
 
     re->func = func;
     re->opaque = opaque;


@@ -1247,7 +1259,7 @@ void qemu_unregister_reset(QEMUResetHandler *func, void *opaque)
     QTAILQ_FOREACH(re, &reset_handlers, entry) {
         if (re->func == func && re->opaque == opaque) {
             QTAILQ_REMOVE(&reset_handlers, re, entry);
     QTAILQ_FOREACH(re, &reset_handlers, entry) {
         if (re->func == func && re->opaque == opaque) {
             QTAILQ_REMOVE(&reset_handlers, re, entry);

-            qemu_free(re);
+            g_free(re);

             return;
         }
     }
             return;
         }
     }


@@ -1309,7 +1321,7 @@ void qemu_system_vmstop_request(int reason)
     qemu_notify_event();
 }
 
     qemu_notify_event();
 }
 

-void main_loop_wait(int nonblocking)
+int main_loop_wait(int nonblocking)

 {
     fd_set rfds, wfds, xfds;
     int ret, nfds;
 {
     fd_set rfds, wfds, xfds;
     int ret, nfds;


@@ -1337,9 +1349,15 @@ void main_loop_wait(int nonblocking)
     qemu_iohandler_fill(&nfds, &rfds, &wfds, &xfds);
     slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
 
     qemu_iohandler_fill(&nfds, &rfds, &wfds, &xfds);
     slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
 

-    qemu_mutex_unlock_iothread();
+    if (timeout > 0) {
+        qemu_mutex_unlock_iothread();
+    }
+

     ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
     ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);

-    qemu_mutex_lock_iothread();
+
+    if (timeout > 0) {
+        qemu_mutex_lock_iothread();
+    }

 
     qemu_iohandler_poll(&rfds, &wfds, &xfds, ret);
     slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));
 
     qemu_iohandler_poll(&rfds, &wfds, &xfds, ret);
     slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));


@@ -1350,6 +1368,7 @@ void main_loop_wait(int nonblocking)
        them.  */
     qemu_bh_poll();
 
        them.  */
     qemu_bh_poll();
 

+    return ret;

 }
 
 #ifndef CONFIG_IOTHREAD
 }
 
 #ifndef CONFIG_IOTHREAD


@@ -1367,7 +1386,8 @@ qemu_irq qemu_system_powerdown;
 
 static void main_loop(void)
 {
 
 static void main_loop(void)
 {

-    bool nonblocking = false;
+    bool nonblocking;
+    int last_io __attribute__ ((unused)) = 0;

 #ifdef CONFIG_PROFILER
     int64_t ti;
 #endif
 #ifdef CONFIG_PROFILER
     int64_t ti;
 #endif


@@ -1376,7 +1396,9 @@ static void main_loop(void)
     qemu_main_loop_start();
 
     for (;;) {
     qemu_main_loop_start();
 
     for (;;) {

-#ifndef CONFIG_IOTHREAD
+#ifdef CONFIG_IOTHREAD
+        nonblocking = !kvm_enabled() && last_io > 0;
+#else

         nonblocking = cpu_exec_all();
         if (vm_request_pending()) {
             nonblocking = true;
         nonblocking = cpu_exec_all();
         if (vm_request_pending()) {
             nonblocking = true;


@@ -1385,7 +1407,7 @@ static void main_loop(void)
 #ifdef CONFIG_PROFILER
         ti = profile_getclock();
 #endif
 #ifdef CONFIG_PROFILER
         ti = profile_getclock();
 #endif

-        main_loop_wait(nonblocking);
+        last_io = main_loop_wait(nonblocking);

 #ifdef CONFIG_PROFILER
         dev_time += profile_getclock() - ti;
 #endif
 #ifdef CONFIG_PROFILER
         dev_time += profile_getclock() - ti;
 #endif


@@ -1398,7 +1420,6 @@ static void main_loop(void)
             monitor_protocol_event(QEVENT_SHUTDOWN, NULL);
             if (no_shutdown) {
                 vm_stop(VMSTOP_SHUTDOWN);
             monitor_protocol_event(QEVENT_SHUTDOWN, NULL);
             if (no_shutdown) {
                 vm_stop(VMSTOP_SHUTDOWN);

-                no_shutdown = 0;

             } else
                 break;
         }
             } else
                 break;
         }


@@ -1637,7 +1658,7 @@ char *qemu_find_file(int type, const char *name)
     /* If name contains path separators then try it as a straight path.  */
     if ((strchr(name, '/') || strchr(name, '\\'))
         && access(name, R_OK) == 0) {
     /* If name contains path separators then try it as a straight path.  */
     if ((strchr(name, '/') || strchr(name, '\\'))
         && access(name, R_OK) == 0) {

-        return qemu_strdup(name);
+        return g_strdup(name);

     }
     switch (type) {
     case QEMU_FILE_TYPE_BIOS:
     }
     switch (type) {
     case QEMU_FILE_TYPE_BIOS:


@@ -1650,10 +1671,10 @@ char *qemu_find_file(int type, const char *name)
         abort();
     }
     len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;
         abort();
     }
     len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;

-    buf = qemu_mallocz(len);
+    buf = g_malloc0(len);

     snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
     if (access(buf, R_OK)) {
     snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
     if (access(buf, R_OK)) {

-        qemu_free(buf);
+        g_free(buf);

         return NULL;
     }
     return buf;
         return NULL;
     }
     return buf;


@@ -1678,7 +1699,7 @@ static int chardev_init_func(QemuOpts *opts, void *opaque)
 {
     CharDriverState *chr;
 
 {
     CharDriverState *chr;
 

-    chr = qemu_chr_open_opts(opts, NULL);
+    chr = qemu_chr_new_from_opts(opts, NULL);

     if (!chr)
         return -1;
     return 0;
     if (!chr)
         return -1;
     return 0;


@@ -1784,7 +1805,7 @@ static void add_device_config(int type, const char *cmdline)
 {
     struct device_config *conf;
 
 {
     struct device_config *conf;
 

-    conf = qemu_mallocz(sizeof(*conf));
+    conf = g_malloc0(sizeof(*conf));

     conf->type = type;
     conf->cmdline = cmdline;
     QTAILQ_INSERT_TAIL(&device_configs, conf, next);
     conf->type = type;
     conf->cmdline = cmdline;
     QTAILQ_INSERT_TAIL(&device_configs, conf, next);


@@ -1817,7 +1838,7 @@ static int serial_parse(const char *devname)
         exit(1);
     }
     snprintf(label, sizeof(label), "serial%d", index);
         exit(1);
     }
     snprintf(label, sizeof(label), "serial%d", index);

-    serial_hds[index] = qemu_chr_open(label, devname, NULL);
+    serial_hds[index] = qemu_chr_new(label, devname, NULL);

     if (!serial_hds[index]) {
         fprintf(stderr, "qemu: could not open serial device '%s': %s\n",
                 devname, strerror(errno));
     if (!serial_hds[index]) {
         fprintf(stderr, "qemu: could not open serial device '%s': %s\n",
                 devname, strerror(errno));


@@ -1839,7 +1860,7 @@ static int parallel_parse(const char *devname)
         exit(1);
     }
     snprintf(label, sizeof(label), "parallel%d", index);
         exit(1);
     }
     snprintf(label, sizeof(label), "parallel%d", index);

-    parallel_hds[index] = qemu_chr_open(label, devname, NULL);
+    parallel_hds[index] = qemu_chr_new(label, devname, NULL);

     if (!parallel_hds[index]) {
         fprintf(stderr, "qemu: could not open parallel device '%s': %s\n",
                 devname, strerror(errno));
     if (!parallel_hds[index]) {
         fprintf(stderr, "qemu: could not open parallel device '%s': %s\n",
                 devname, strerror(errno));


@@ -1870,7 +1891,7 @@ static int virtcon_parse(const char *devname)
     qemu_opt_set(dev_opts, "driver", "virtconsole");
 
     snprintf(label, sizeof(label), "virtcon%d", index);
     qemu_opt_set(dev_opts, "driver", "virtconsole");
 
     snprintf(label, sizeof(label), "virtcon%d", index);

-    virtcon_hds[index] = qemu_chr_open(label, devname, NULL);
+    virtcon_hds[index] = qemu_chr_new(label, devname, NULL);

     if (!virtcon_hds[index]) {
         fprintf(stderr, "qemu: could not open virtio console '%s': %s\n",
                 devname, strerror(errno));
     if (!virtcon_hds[index]) {
         fprintf(stderr, "qemu: could not open virtio console '%s': %s\n",
                 devname, strerror(errno));


@@ -1886,7 +1907,7 @@ static int debugcon_parse(const char *devname)
 {   
     QemuOpts *opts;
 
 {   
     QemuOpts *opts;
 

-    if (!qemu_chr_open("debugcon", devname, NULL)) {
+    if (!qemu_chr_new("debugcon", devname, NULL)) {

         exit(1);
     }
     opts = qemu_opts_create(qemu_find_opts("device"), "debugcon", 1);
         exit(1);
     }
     opts = qemu_opts_create(qemu_find_opts("device"), "debugcon", 1);


@@ -1899,8 +1920,30 @@ static int debugcon_parse(const char *devname)
     return 0;
 }
 
     return 0;
 }
 

+static QEMUMachine *machine_parse(const char *name)
+{
+    QEMUMachine *m, *machine = NULL;
+
+    if (name) {
+        machine = find_machine(name);
+    }
+    if (machine) {
+        return machine;
+    }
+    printf("Supported machines are:\n");
+    for (m = first_machine; m != NULL; m = m->next) {
+        if (m->alias) {
+            printf("%-10s %s (alias of %s)\n", m->alias, m->desc, m->name);
+        }
+        printf("%-10s %s%s\n", m->name, m->desc,
+               m->is_default ? " (default)" : "");
+    }
+    exit(!name || *name != '?');
+}
+

 static int tcg_init(void)
 {
 static int tcg_init(void)
 {

+    tcg_exec_init(tcg_tb_size * 1024 * 1024);

     return 0;
 }
 
     return 0;
 }
 


@@ -1989,7 +2032,7 @@ void qemu_remove_exit_notifier(Notifier *notify)
 
 static void qemu_run_exit_notifiers(void)
 {
 
 static void qemu_run_exit_notifiers(void)
 {

-    notifier_list_notify(&exit_notifiers);
+    notifier_list_notify(&exit_notifiers, NULL);

 }
 
 void qemu_add_machine_init_done_notifier(Notifier *notify)
 }
 
 void qemu_add_machine_init_done_notifier(Notifier *notify)


@@ -1999,7 +2042,7 @@ void qemu_add_machine_init_done_notifier(Notifier *notify)
 
 static void qemu_run_machine_init_done_notifiers(void)
 {
 
 static void qemu_run_machine_init_done_notifiers(void)
 {

-    notifier_list_notify(&machine_init_done_notifiers);
+    notifier_list_notify(&machine_init_done_notifiers, NULL);

 }
 
 static const QEMUOption *lookup_opt(int argc, char **argv,
 }
 
 static const QEMUOption *lookup_opt(int argc, char **argv,


@@ -2042,6 +2085,26 @@ static const QEMUOption *lookup_opt(int argc, char **argv,
     return popt;
 }
 
     return popt;
 }
 

+static gpointer malloc_and_trace(gsize n_bytes)
+{
+    void *ptr = malloc(n_bytes);
+    trace_qemu_malloc(n_bytes, ptr);
+    return ptr;
+}
+
+static gpointer realloc_and_trace(gpointer mem, gsize n_bytes)
+{
+    void *ptr = realloc(mem, n_bytes);
+    trace_qemu_realloc(mem, n_bytes, ptr);
+    return ptr;
+}
+
+static void free_and_trace(gpointer mem)
+{
+    trace_qemu_free(mem);
+    free(mem);
+}
+

 int main(int argc, char **argv, char **envp)
 {
     const char *gdbstub_dev = NULL;
 int main(int argc, char **argv, char **envp)
 {
     const char *gdbstub_dev = NULL;


@@ -2061,7 +2124,6 @@ int main(int argc, char **argv, char **envp)
     const char *loadvm = NULL;
     QEMUMachine *machine;
     const char *cpu_model;
     const char *loadvm = NULL;
     QEMUMachine *machine;
     const char *cpu_model;

-    int tb_size;

     const char *pid_file = NULL;
     const char *incoming = NULL;
 #ifdef CONFIG_VNC
     const char *pid_file = NULL;
     const char *incoming = NULL;
 #ifdef CONFIG_VNC


@@ -2071,10 +2133,17 @@ int main(int argc, char **argv, char **envp)
     const char *trace_file = NULL;
     const char *log_mask = NULL;
     const char *log_file = NULL;
     const char *trace_file = NULL;
     const char *log_mask = NULL;
     const char *log_file = NULL;

+    GMemVTable mem_trace = {
+        .malloc = malloc_and_trace,
+        .realloc = realloc_and_trace,
+        .free = free_and_trace,
+    };

 
     atexit(qemu_run_exit_notifiers);
     error_set_progname(argv[0]);
 
 
     atexit(qemu_run_exit_notifiers);
     error_set_progname(argv[0]);
 

+    g_mem_set_vtable(&mem_trace);
+

     init_clocks();
 
     qemu_cache_utils_init(envp);
     init_clocks();
 
     qemu_cache_utils_init(envp);


@@ -2101,7 +2170,6 @@ int main(int argc, char **argv, char **envp)
     nb_numa_nodes = 0;
     nb_nics = 0;
 
     nb_numa_nodes = 0;
     nb_nics = 0;
 

-    tb_size = 0;

     autostart= 1;
 
     /* first pass of option parsing */
     autostart= 1;
 
     /* first pass of option parsing */


@@ -2155,20 +2223,7 @@ int main(int argc, char **argv, char **envp)
             }
             switch(popt->index) {
             case QEMU_OPTION_M:
             }
             switch(popt->index) {
             case QEMU_OPTION_M:

-                machine = find_machine(optarg);
-                if (!machine) {
-                    QEMUMachine *m;
-                    printf("Supported machines are:\n");
-                    for(m = first_machine; m != NULL; m = m->next) {
-                        if (m->alias)
-                            printf("%-10s %s (alias of %s)\n",
-                                   m->alias, m->desc, m->name);
-                        printf("%-10s %s%s\n",
-                               m->name, m->desc,
-                               m->is_default ? " (default)" : "");
-                    }
-                    exit(*optarg != '?');
-                }
+                machine = machine_parse(optarg);

                 break;
             case QEMU_OPTION_cpu:
                 /* hw initialization will check this */
                 break;
             case QEMU_OPTION_cpu:
                 /* hw initialization will check this */


@@ -2300,7 +2355,16 @@ int main(int argc, char **argv, char **envp)
 #endif
                 break;
             case QEMU_OPTION_portrait:
 #endif
                 break;
             case QEMU_OPTION_portrait:

-                graphic_rotate = 1;
+                graphic_rotate = 90;
+                break;
+            case QEMU_OPTION_rotate:
+                graphic_rotate = strtol(optarg, (char **) &optarg, 10);
+                if (graphic_rotate != 0 && graphic_rotate != 90 &&
+                    graphic_rotate != 180 && graphic_rotate != 270) {
+                    fprintf(stderr,
+                        "qemu: only 90, 180, 270 deg rotation is available\n");
+                    exit(1);
+                }

                 break;
             case QEMU_OPTION_kernel:
                 kernel_filename = optarg;
                 break;
             case QEMU_OPTION_kernel:
                 kernel_filename = optarg;


@@ -2314,7 +2378,8 @@ int main(int argc, char **argv, char **envp)
             case QEMU_OPTION_boot:
                 {
                     static const char * const params[] = {
             case QEMU_OPTION_boot:
                 {
                     static const char * const params[] = {

-                        "order", "once", "menu", NULL
+                        "order", "once", "menu",
+                        "splash", "splash-time", NULL

                     };
                     char buf[sizeof(boot_devices)];
                     char *standard_boot_devices;
                     };
                     char buf[sizeof(boot_devices)];
                     char *standard_boot_devices;


@@ -2339,7 +2404,7 @@ int main(int argc, char **argv, char **envp)
                         if (get_param_value(buf, sizeof(buf),
                                             "once", optarg)) {
                             validate_bootdevices(buf);
                         if (get_param_value(buf, sizeof(buf),
                                             "once", optarg)) {
                             validate_bootdevices(buf);

-                            standard_boot_devices = qemu_strdup(boot_devices);
+                            standard_boot_devices = g_strdup(boot_devices);

                             pstrcpy(boot_devices, sizeof(boot_devices), buf);
                             qemu_register_reset(restore_boot_devices,
                                                 standard_boot_devices);
                             pstrcpy(boot_devices, sizeof(boot_devices), buf);
                             qemu_register_reset(restore_boot_devices,
                                                 standard_boot_devices);


@@ -2357,6 +2422,8 @@ int main(int argc, char **argv, char **envp)
                                 exit(1);
                             }
                         }
                                 exit(1);
                             }
                         }

+                        qemu_opts_parse(qemu_find_opts("boot-opts"),
+                                        optarg, 0);

                     }
                 }
                 break;
                     }
                 }
                 break;


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

-                /* On 32-bit hosts, QEMU is limited by virtual address space */
-                if (value > (2047 << 20) && HOST_LONG_BITS == 32) {
-                    fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
-                    exit(1);
-                }

                 if (value != (uint64_t)(ram_addr_t)value) {
                     fprintf(stderr, "qemu: ram size too large\n");
                     exit(1);
                 if (value != (uint64_t)(ram_addr_t)value) {
                     fprintf(stderr, "qemu: ram size too large\n");
                     exit(1);


@@ -2689,11 +2751,15 @@ int main(int argc, char **argv, char **envp)
             case QEMU_OPTION_machine:
                 olist = qemu_find_opts("machine");
                 qemu_opts_reset(olist);
             case QEMU_OPTION_machine:
                 olist = qemu_find_opts("machine");
                 qemu_opts_reset(olist);

-                opts = qemu_opts_parse(olist, optarg, 0);
+                opts = qemu_opts_parse(olist, optarg, 1);

                 if (!opts) {
                     fprintf(stderr, "parse error: %s\n", optarg);
                     exit(1);
                 }
                 if (!opts) {
                     fprintf(stderr, "parse error: %s\n", optarg);
                     exit(1);
                 }

+                optarg = qemu_opt_get(opts, "type");
+                if (optarg) {
+                    machine = machine_parse(optarg);
+                }

                 break;
             case QEMU_OPTION_usb:
                 usb_enabled = 1;
                 break;
             case QEMU_OPTION_usb:
                 usb_enabled = 1;


@@ -2779,7 +2845,7 @@ int main(int argc, char **argv, char **envp)
                 semihosting_enabled = 1;
                 break;
             case QEMU_OPTION_name:
                 semihosting_enabled = 1;
                 break;
             case QEMU_OPTION_name:

-                qemu_name = qemu_strdup(optarg);
+                qemu_name = g_strdup(optarg);

                 {
                     char *p = strchr(qemu_name, ',');
                     if (p != NULL) {
                 {
                     char *p = strchr(qemu_name, ',');
                     if (p != NULL) {


@@ -2818,9 +2884,10 @@ int main(int argc, char **argv, char **envp)
                 configure_rtc(opts);
                 break;
             case QEMU_OPTION_tb_size:
                 configure_rtc(opts);
                 break;
             case QEMU_OPTION_tb_size:

-                tb_size = strtol(optarg, NULL, 0);
-                if (tb_size < 0)
-                    tb_size = 0;
+                tcg_tb_size = strtol(optarg, NULL, 0);
+                if (tcg_tb_size < 0) {
+                    tcg_tb_size = 0;
+                }

                 break;
             case QEMU_OPTION_icount:
                 icount_option = optarg;
                 break;
             case QEMU_OPTION_icount:
                 icount_option = optarg;


@@ -2967,8 +3034,8 @@ int main(int argc, char **argv, char **envp)
             p = qemu_opt_get(QTAILQ_FIRST(&list->head), "accel");
         }
         if (p == NULL) {
             p = qemu_opt_get(QTAILQ_FIRST(&list->head), "accel");
         }
         if (p == NULL) {

-            opts = qemu_opts_parse(qemu_find_opts("machine"),
-                                   machine->default_machine_opts, 0);
+            qemu_opts_reset(list);
+            opts = qemu_opts_parse(list, machine->default_machine_opts, 0);

             if (!opts) {
                 fprintf(stderr, "parse error for machine %s: %s\n",
                         machine->name, machine->default_machine_opts);
             if (!opts) {
                 fprintf(stderr, "parse error for machine %s: %s\n",
                         machine->name, machine->default_machine_opts);


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

+    /* init the memory */
+    if (ram_size == 0) {
+        ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
+    }
+

     configure_accelerator();
 
     if (qemu_init_main_loop()) {
     configure_accelerator();
 
     if (qemu_init_main_loop()) {


@@ -3081,12 +3153,15 @@ int main(int argc, char **argv, char **envp)
     if (foreach_device_config(DEV_BT, bt_parse))
         exit(1);
 
     if (foreach_device_config(DEV_BT, bt_parse))
         exit(1);
 

-    /* init the memory */
-    if (ram_size == 0)
-        ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
+    if (!xen_enabled()) {
+        /* On 32-bit hosts, QEMU is limited by virtual address space */
+        if (ram_size > (2047 << 20) && HOST_LONG_BITS == 32) {
+            fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
+            exit(1);
+        }
+    }

 
 

-    /* init the dynamic translator */
-    cpu_exec_init_all(tb_size * 1024 * 1024);
+    cpu_exec_init_all();

 
     bdrv_init_with_whitelist();
 
 
     bdrv_init_with_whitelist();
 


@@ -3111,8 +3186,8 @@ int main(int argc, char **argv, char **envp)
     if (nb_numa_nodes > 0) {
         int i;
 
     if (nb_numa_nodes > 0) {
         int i;
 

-        if (nb_numa_nodes > smp_cpus) {
-            nb_numa_nodes = smp_cpus;
+        if (nb_numa_nodes > MAX_NODES) {
+            nb_numa_nodes = MAX_NODES;

         }
 
         /* If no memory size if given for any node, assume the default case
         }
 
         /* If no memory size if given for any node, assume the default case


@@ -3318,6 +3393,7 @@ int main(int argc, char **argv, char **envp)
     main_loop();
     quit_timers();
     net_cleanup();
     main_loop();
     quit_timers();
     net_cleanup();

+    res_free();

 
     return 0;
 }
 
     return 0;
 }