Diff for /qemu/vl.c between versions 1.1.1.21 and 1.1.1.22

version 1.1.1.21, 2018/04/24 19:16:33 version 1.1.1.22, 2018/04/24 19:33:29
Line 152  int main(int argc, char **argv) Line 152  int main(int argc, char **argv)
 #ifdef CONFIG_VIRTFS  #ifdef CONFIG_VIRTFS
 #include "fsdev/qemu-fsdev.h"  #include "fsdev/qemu-fsdev.h"
 #endif  #endif
   #include "qtest.h"
   
 #include "disas.h"  #include "disas.h"
   
Line 201  CharDriverState *serial_hds[MAX_SERIAL_P Line 202  CharDriverState *serial_hds[MAX_SERIAL_P
 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];  CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
 CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];  CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
 int win2k_install_hack = 0;  int win2k_install_hack = 0;
 int rtc_td_hack = 0;  
 int usb_enabled = 0;  int usb_enabled = 0;
 int singlestep = 0;  int singlestep = 0;
 int smp_cpus = 1;  int smp_cpus = 1;
Line 218  int no_reboot = 0; Line 218  int no_reboot = 0;
 int no_shutdown = 0;  int no_shutdown = 0;
 int cursor_hide = 1;  int cursor_hide = 1;
 int graphic_rotate = 0;  int graphic_rotate = 0;
 uint8_t irq0override = 1;  
 const char *watchdog;  const char *watchdog;
 QEMUOptionRom option_rom[MAX_OPTION_ROMS];  QEMUOptionRom option_rom[MAX_OPTION_ROMS];
 int nb_option_roms;  int nb_option_roms;
Line 271  static int default_serial = 1; Line 270  static int default_serial = 1;
 static int default_parallel = 1;  static int default_parallel = 1;
 static int default_virtcon = 1;  static int default_virtcon = 1;
 static int default_monitor = 1;  static int default_monitor = 1;
 static int default_vga = 1;  
 static int default_floppy = 1;  static int default_floppy = 1;
 static int default_cdrom = 1;  static int default_cdrom = 1;
 static int default_sdcard = 1;  static int default_sdcard = 1;
   static int default_vga = 1;
   
 static struct {  static struct {
     const char *driver;      const char *driver;
Line 291  static struct { Line 290  static struct {
     { .driver = "virtio-serial-s390",   .flag = &default_virtcon   },      { .driver = "virtio-serial-s390",   .flag = &default_virtcon   },
     { .driver = "virtio-serial",        .flag = &default_virtcon   },      { .driver = "virtio-serial",        .flag = &default_virtcon   },
     { .driver = "VGA",                  .flag = &default_vga       },      { .driver = "VGA",                  .flag = &default_vga       },
       { .driver = "isa-vga",              .flag = &default_vga       },
     { .driver = "cirrus-vga",           .flag = &default_vga       },      { .driver = "cirrus-vga",           .flag = &default_vga       },
       { .driver = "isa-cirrus-vga",       .flag = &default_vga       },
     { .driver = "vmware-svga",          .flag = &default_vga       },      { .driver = "vmware-svga",          .flag = &default_vga       },
     { .driver = "isa-vga",              .flag = &default_vga       },  
     { .driver = "qxl-vga",              .flag = &default_vga       },      { .driver = "qxl-vga",              .flag = &default_vga       },
 };  };
   
Line 373  static const RunStateTransition runstate Line 373  static const RunStateTransition runstate
     { RUN_STATE_SHUTDOWN, RUN_STATE_PAUSED },      { RUN_STATE_SHUTDOWN, RUN_STATE_PAUSED },
     { RUN_STATE_SHUTDOWN, RUN_STATE_FINISH_MIGRATE },      { RUN_STATE_SHUTDOWN, 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_WATCHDOG, RUN_STATE_RUNNING },      { RUN_STATE_WATCHDOG, RUN_STATE_RUNNING },
     { RUN_STATE_WATCHDOG, RUN_STATE_FINISH_MIGRATE },      { RUN_STATE_WATCHDOG, RUN_STATE_FINISH_MIGRATE },
   
Line 537  static void configure_rtc(QemuOpts *opts Line 542  static void configure_rtc(QemuOpts *opts
     if (value) {      if (value) {
         if (!strcmp(value, "host")) {          if (!strcmp(value, "host")) {
             rtc_clock = host_clock;              rtc_clock = host_clock;
           } else if (!strcmp(value, "rt")) {
               rtc_clock = rt_clock;
         } else if (!strcmp(value, "vm")) {          } else if (!strcmp(value, "vm")) {
             rtc_clock = vm_clock;              rtc_clock = vm_clock;
         } else {          } else {
Line 547  static void configure_rtc(QemuOpts *opts Line 554  static void configure_rtc(QemuOpts *opts
     value = qemu_opt_get(opts, "driftfix");      value = qemu_opt_get(opts, "driftfix");
     if (value) {      if (value) {
         if (!strcmp(value, "slew")) {          if (!strcmp(value, "slew")) {
             rtc_td_hack = 1;              static GlobalProperty slew_lost_ticks[] = {
                   {
                       .driver   = "mc146818rtc",
                       .property = "lost_tick_policy",
                       .value    = "slew",
                   },
                   { /* end of list */ }
               };
   
               qdev_prop_register_global_list(slew_lost_ticks);
         } else if (!strcmp(value, "none")) {          } else if (!strcmp(value, "none")) {
             rtc_td_hack = 0;              /* discard is default */
         } else {          } else {
             fprintf(stderr, "qemu: invalid option value '%s'\n", value);              fprintf(stderr, "qemu: invalid option value '%s'\n", value);
             exit(1);              exit(1);
Line 820  static void validate_bootdevices(char *d Line 836  static void validate_bootdevices(char *d
         /* Allowed boot devices are:          /* Allowed boot devices are:
          * a-b: floppy disk drives           * a-b: floppy disk drives
          * c-f: IDE disk drives           * c-f: IDE disk drives
          * g-m: machine implementation dependant drives           * g-m: machine implementation dependent drives
          * n-p: network devices           * n-p: network devices
          * It's up to each machine implementation to check if the given boot           * It's up to each machine implementation to check if the given boot
          * devices match the actual hardware implementation and firmware           * devices match the actual hardware implementation and firmware
Line 1051  static int usb_device_add(const char *de Line 1067  static int usb_device_add(const char *de
 #ifndef CONFIG_LINUX  #ifndef CONFIG_LINUX
     /* only the linux version is qdev-ified, usb-bsd still needs this */      /* only the linux version is qdev-ified, usb-bsd still needs this */
     if (strstart(devname, "host:", &p)) {      if (strstart(devname, "host:", &p)) {
         dev = usb_host_device_open(p);          dev = usb_host_device_open(usb_bus_find(-1), p);
     } else      } else
 #endif  #endif
     if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {      if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
         dev = usb_bt_init(devname[2] ? hci_init(p) :          dev = usb_bt_init(usb_bus_find(-1),
                         bt_new_hci(qemu_find_bt_vlan(0)));                            devname[2] ? hci_init(p)
                                        : bt_new_hci(qemu_find_bt_vlan(0)));
     } else {      } else {
         return -1;          return -1;
     }      }
Line 1186  static QEMUMachine *find_machine(const c Line 1203  static QEMUMachine *find_machine(const c
     return NULL;      return NULL;
 }  }
   
 static QEMUMachine *find_default_machine(void)  QEMUMachine *find_default_machine(void)
 {  {
     QEMUMachine *m;      QEMUMachine *m;
   
Line 1282  static int shutdown_requested, shutdown_ Line 1299  static int shutdown_requested, shutdown_
 static pid_t shutdown_pid;  static pid_t shutdown_pid;
 static int powerdown_requested;  static int powerdown_requested;
 static int debug_requested;  static int debug_requested;
   static int suspend_requested;
   static NotifierList suspend_notifiers =
       NOTIFIER_LIST_INITIALIZER(suspend_notifiers);
   static NotifierList wakeup_notifiers =
       NOTIFIER_LIST_INITIALIZER(wakeup_notifiers);
   static uint32_t wakeup_reason_mask = ~0;
 static RunState vmstop_requested = RUN_STATE_MAX;  static RunState vmstop_requested = RUN_STATE_MAX;
   
 int qemu_shutdown_requested_get(void)  int qemu_shutdown_requested_get(void)
Line 1303  int qemu_shutdown_requested(void) Line 1326  int qemu_shutdown_requested(void)
   
 void qemu_kill_report(void)  void qemu_kill_report(void)
 {  {
     if (shutdown_signal != -1) {      if (!qtest_enabled() && shutdown_signal != -1) {
         fprintf(stderr, "qemu: terminating on signal %d", shutdown_signal);          fprintf(stderr, "qemu: terminating on signal %d", shutdown_signal);
         if (shutdown_pid == 0) {          if (shutdown_pid == 0) {
             /* This happens for eg ^C at the terminal, so it's worth              /* This happens for eg ^C at the terminal, so it's worth
Line 1324  int qemu_reset_requested(void) Line 1347  int qemu_reset_requested(void)
     return r;      return r;
 }  }
   
   static int qemu_suspend_requested(void)
   {
       int r = suspend_requested;
       suspend_requested = 0;
       return r;
   }
   
 int qemu_powerdown_requested(void)  int qemu_powerdown_requested(void)
 {  {
     int r = powerdown_requested;      int r = powerdown_requested;
Line 1397  void qemu_system_reset_request(void) Line 1427  void qemu_system_reset_request(void)
     qemu_notify_event();      qemu_notify_event();
 }  }
   
   static void qemu_system_suspend(void)
   {
       pause_all_vcpus();
       notifier_list_notify(&suspend_notifiers, NULL);
       runstate_set(RUN_STATE_SUSPENDED);
       monitor_protocol_event(QEVENT_SUSPEND, NULL);
   }
   
   void qemu_system_suspend_request(void)
   {
       if (runstate_check(RUN_STATE_SUSPENDED)) {
           return;
       }
       suspend_requested = 1;
       cpu_stop_current();
       qemu_notify_event();
   }
   
   void qemu_register_suspend_notifier(Notifier *notifier)
   {
       notifier_list_add(&suspend_notifiers, notifier);
   }
   
   void qemu_system_wakeup_request(WakeupReason reason)
   {
       if (!runstate_check(RUN_STATE_SUSPENDED)) {
           return;
       }
       if (!(wakeup_reason_mask & (1 << reason))) {
           return;
       }
       runstate_set(RUN_STATE_RUNNING);
       monitor_protocol_event(QEVENT_WAKEUP, NULL);
       notifier_list_notify(&wakeup_notifiers, &reason);
       reset_requested = 1;
       qemu_notify_event();
   }
   
   void qemu_system_wakeup_enable(WakeupReason reason, bool enabled)
   {
       if (enabled) {
           wakeup_reason_mask |= (1 << reason);
       } else {
           wakeup_reason_mask &= ~(1 << reason);
       }
   }
   
   void qemu_register_wakeup_notifier(Notifier *notifier)
   {
       notifier_list_add(&wakeup_notifiers, notifier);
   }
   
 void qemu_system_killed(int signal, pid_t pid)  void qemu_system_killed(int signal, pid_t pid)
 {  {
     shutdown_signal = signal;      shutdown_signal = signal;
Line 1437  static bool main_loop_should_exit(void) Line 1519  static bool main_loop_should_exit(void)
     if (qemu_debug_requested()) {      if (qemu_debug_requested()) {
         vm_stop(RUN_STATE_DEBUG);          vm_stop(RUN_STATE_DEBUG);
     }      }
       if (qemu_suspend_requested()) {
           qemu_system_suspend();
       }
     if (qemu_shutdown_requested()) {      if (qemu_shutdown_requested()) {
         qemu_kill_report();          qemu_kill_report();
         monitor_protocol_event(QEVENT_SHUTDOWN, NULL);          monitor_protocol_event(QEVENT_SHUTDOWN, NULL);
Line 1492  static void version(void) Line 1577  static void version(void)
   
 static void help(int exitcode)  static void help(int exitcode)
 {  {
     const char *options_help =  
 #define DEF(option, opt_arg, opt_enum, opt_help, arch_mask)     \  
         opt_help  
 #define DEFHEADING(text) stringify(text) "\n"  
 #include "qemu-options.def"  
 #undef DEF  
 #undef DEFHEADING  
 #undef GEN_DOCS  
         ;  
     version();      version();
     printf("usage: %s [options] [disk_image]\n"      printf("usage: %s [options] [disk_image]\n\n"
            "\n"             "'disk_image' is a raw hard disk image for IDE hard disk 0\n\n",
            "'disk_image' is a raw hard disk image for IDE hard disk 0\n"              error_get_progname());
            "\n"  
            "%s\n"  #define QEMU_OPTIONS_GENERATE_HELP
            "During emulation, the following keys are useful:\n"  #include "qemu-options-wrapper.h"
   
       printf("\nDuring emulation, the following keys are useful:\n"
            "ctrl-alt-f      toggle full screen\n"             "ctrl-alt-f      toggle full screen\n"
            "ctrl-alt-n      switch to virtual console 'n'\n"             "ctrl-alt-n      switch to virtual console 'n'\n"
            "ctrl-alt        toggle mouse and keyboard grab\n"             "ctrl-alt        toggle mouse and keyboard grab\n"
            "\n"             "\n"
            "When using -nographic, press 'ctrl-a h' to get some help.\n",             "When using -nographic, press 'ctrl-a h' to get some help.\n");
            "qemu",  
            options_help);  
     exit(exitcode);      exit(exitcode);
 }  }
   
Line 1529  typedef struct QEMUOption { Line 1606  typedef struct QEMUOption {
   
 static const QEMUOption qemu_options[] = {  static const QEMUOption qemu_options[] = {
     { "h", 0, QEMU_OPTION_h, QEMU_ARCH_ALL },      { "h", 0, QEMU_OPTION_h, QEMU_ARCH_ALL },
 #define DEF(option, opt_arg, opt_enum, opt_help, arch_mask)     \  #define QEMU_OPTIONS_GENERATE_OPTIONS
     { option, opt_arg, opt_enum, arch_mask },  #include "qemu-options-wrapper.h"
 #define DEFHEADING(text)  
 #include "qemu-options.def"  
 #undef DEF  
 #undef DEFHEADING  
 #undef GEN_DOCS  
     { NULL },      { NULL },
 };  };
   
   static bool vga_available(void)
   {
       return qdev_exists("VGA") || qdev_exists("isa-vga");
   }
   
   static bool cirrus_vga_available(void)
   {
       return qdev_exists("cirrus-vga") || qdev_exists("isa-cirrus-vga");
   }
   
   static bool vmware_vga_available(void)
   {
       return qdev_exists("vmware-svga");
   }
   
 static void select_vgahw (const char *p)  static void select_vgahw (const char *p)
 {  {
     const char *opts;      const char *opts;
   
     default_vga = 0;  
     vga_interface_type = VGA_NONE;      vga_interface_type = VGA_NONE;
     if (strstart(p, "std", &opts)) {      if (strstart(p, "std", &opts)) {
         vga_interface_type = VGA_STD;          if (vga_available()) {
               vga_interface_type = VGA_STD;
           } else {
               fprintf(stderr, "Error: standard VGA not available\n");
               exit(0);
           }
     } else if (strstart(p, "cirrus", &opts)) {      } else if (strstart(p, "cirrus", &opts)) {
         vga_interface_type = VGA_CIRRUS;          if (cirrus_vga_available()) {
               vga_interface_type = VGA_CIRRUS;
           } else {
               fprintf(stderr, "Error: Cirrus VGA not available\n");
               exit(0);
           }
     } else if (strstart(p, "vmware", &opts)) {      } else if (strstart(p, "vmware", &opts)) {
         vga_interface_type = VGA_VMWARE;          if (vmware_vga_available()) {
               vga_interface_type = VGA_VMWARE;
           } else {
               fprintf(stderr, "Error: VMWare SVGA not available\n");
               exit(0);
           }
     } else if (strstart(p, "xenfb", &opts)) {      } else if (strstart(p, "xenfb", &opts)) {
         vga_interface_type = VGA_XENFB;          vga_interface_type = VGA_XENFB;
     } else if (strstart(p, "qxl", &opts)) {      } else if (strstart(p, "qxl", &opts)) {
Line 1839  struct device_config { Line 1941  struct device_config {
         DEV_PARALLEL,  /* -parallel      */          DEV_PARALLEL,  /* -parallel      */
         DEV_VIRTCON,   /* -virtioconsole */          DEV_VIRTCON,   /* -virtioconsole */
         DEV_DEBUGCON,  /* -debugcon */          DEV_DEBUGCON,  /* -debugcon */
           DEV_GDB,       /* -gdb, -s */
     } type;      } type;
     const char *cmdline;      const char *cmdline;
       Location loc;
     QTAILQ_ENTRY(device_config) next;      QTAILQ_ENTRY(device_config) next;
 };  };
 QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs);  QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs);
Line 1852  static void add_device_config(int type,  Line 1956  static void add_device_config(int type, 
     conf = g_malloc0(sizeof(*conf));      conf = g_malloc0(sizeof(*conf));
     conf->type = type;      conf->type = type;
     conf->cmdline = cmdline;      conf->cmdline = cmdline;
       loc_save(&conf->loc);
     QTAILQ_INSERT_TAIL(&device_configs, conf, next);      QTAILQ_INSERT_TAIL(&device_configs, conf, next);
 }  }
   
Line 1863  static int foreach_device_config(int typ Line 1968  static int foreach_device_config(int typ
     QTAILQ_FOREACH(conf, &device_configs, next) {      QTAILQ_FOREACH(conf, &device_configs, next) {
         if (conf->type != type)          if (conf->type != type)
             continue;              continue;
           loc_push_restore(&conf->loc);
         rc = func(conf->cmdline);          rc = func(conf->cmdline);
           loc_pop(&conf->loc);
         if (0 != rc)          if (0 != rc)
             return rc;              return rc;
     }      }
Line 1929  static int virtcon_parse(const char *dev Line 2036  static int virtcon_parse(const char *dev
     }      }
   
     bus_opts = qemu_opts_create(device, NULL, 0);      bus_opts = qemu_opts_create(device, NULL, 0);
     qemu_opt_set(bus_opts, "driver", "virtio-serial");      if (arch_type == QEMU_ARCH_S390X) {
           qemu_opt_set(bus_opts, "driver", "virtio-serial-s390");
       } else {
           qemu_opt_set(bus_opts, "driver", "virtio-serial-pci");
       } 
   
     dev_opts = qemu_opts_create(device, NULL, 0);      dev_opts = qemu_opts_create(device, NULL, 0);
     qemu_opt_set(dev_opts, "driver", "virtconsole");      qemu_opt_set(dev_opts, "driver", "virtconsole");
Line 1977  static QEMUMachine *machine_parse(const  Line 2088  static QEMUMachine *machine_parse(const 
     printf("Supported machines are:\n");      printf("Supported machines are:\n");
     for (m = first_machine; m != NULL; m = m->next) {      for (m = first_machine; m != NULL; m = m->next) {
         if (m->alias) {          if (m->alias) {
             printf("%-10s %s (alias of %s)\n", m->alias, m->desc, m->name);              printf("%-20s %s (alias of %s)\n", m->alias, m->desc, m->name);
         }          }
         printf("%-10s %s%s\n", m->name, m->desc,          printf("%-20s %s%s\n", m->name, m->desc,
                m->is_default ? " (default)" : "");                 m->is_default ? " (default)" : "");
     }      }
     exit(!name || *name != '?');      exit(!name || *name != '?');
Line 2001  static struct { Line 2112  static struct {
     { "tcg", "tcg", tcg_available, tcg_init, &tcg_allowed },      { "tcg", "tcg", tcg_available, tcg_init, &tcg_allowed },
     { "xen", "Xen", xen_available, xen_init, &xen_allowed },      { "xen", "Xen", xen_available, xen_init, &xen_allowed },
     { "kvm", "KVM", kvm_available, kvm_init, &kvm_allowed },      { "kvm", "KVM", kvm_available, kvm_init, &kvm_allowed },
       { "qtest", "QTest", qtest_available, qtest_init, &qtest_allowed },
 };  };
   
 static int configure_accelerator(void)  static int configure_accelerator(void)
Line 2008  static int configure_accelerator(void) Line 2120  static int configure_accelerator(void)
     const char *p = NULL;      const char *p = NULL;
     char buf[10];      char buf[10];
     int i, ret;      int i, ret;
     bool accel_initalised = 0;      bool accel_initialised = 0;
     bool init_failed = 0;      bool init_failed = 0;
   
     QemuOptsList *list = qemu_find_opts("machine");      QemuOptsList *list = qemu_find_opts("machine");
Line 2021  static int configure_accelerator(void) Line 2133  static int configure_accelerator(void)
         p = "tcg";          p = "tcg";
     }      }
   
     while (!accel_initalised && *p != '\0') {      while (!accel_initialised && *p != '\0') {
         if (*p == ':') {          if (*p == ':') {
             p++;              p++;
         }          }
Line 2042  static int configure_accelerator(void) Line 2154  static int configure_accelerator(void)
                     }                      }
                     *(accel_list[i].allowed) = 0;                      *(accel_list[i].allowed) = 0;
                 } else {                  } else {
                     accel_initalised = 1;                      accel_initialised = 1;
                 }                  }
                 break;                  break;
             }              }
Line 2052  static int configure_accelerator(void) Line 2164  static int configure_accelerator(void)
         }          }
     }      }
   
     if (!accel_initalised) {      if (!accel_initialised) {
         fprintf(stderr, "No accelerator found!\n");          fprintf(stderr, "No accelerator found!\n");
         exit(1);          exit(1);
     }      }
Line 2061  static int configure_accelerator(void) Line 2173  static int configure_accelerator(void)
         fprintf(stderr, "Back to %s accelerator.\n", accel_list[i].name);          fprintf(stderr, "Back to %s accelerator.\n", accel_list[i].name);
     }      }
   
     return !accel_initalised;      return !accel_initialised;
 }  }
   
 void qemu_add_exit_notifier(Notifier *notify)  void qemu_add_exit_notifier(Notifier *notify)
Line 2071  void qemu_add_exit_notifier(Notifier *no Line 2183  void qemu_add_exit_notifier(Notifier *no
   
 void qemu_remove_exit_notifier(Notifier *notify)  void qemu_remove_exit_notifier(Notifier *notify)
 {  {
     notifier_list_remove(&exit_notifiers, notify);      notifier_remove(notify);
 }  }
   
 static void qemu_run_exit_notifiers(void)  static void qemu_run_exit_notifiers(void)
Line 2149  static void free_and_trace(gpointer mem) Line 2261  static void free_and_trace(gpointer mem)
     free(mem);      free(mem);
 }  }
   
   int qemu_init_main_loop(void)
   {
       return main_loop_init();
   }
   
 int main(int argc, char **argv, char **envp)  int main(int argc, char **argv, char **envp)
 {  {
     const char *gdbstub_dev = NULL;  
     int i;      int i;
     int snapshot, linux_boot;      int snapshot, linux_boot;
     const char *icount_option = NULL;      const char *icount_option = NULL;
Line 2161  int main(int argc, char **argv, char **e Line 2277  int main(int argc, char **argv, char **e
     DisplayState *ds;      DisplayState *ds;
     DisplayChangeListener *dcl;      DisplayChangeListener *dcl;
     int cyls, heads, secs, translation;      int cyls, heads, secs, translation;
     QemuOpts *hda_opts = NULL, *opts;      QemuOpts *hda_opts = NULL, *opts, *machine_opts;
     QemuOptsList *olist;      QemuOptsList *olist;
     int optind;      int optind;
     const char *optarg;      const char *optarg;
     const char *loadvm = NULL;      const char *loadvm = NULL;
     QEMUMachine *machine;      QEMUMachine *machine;
     const char *cpu_model;      const char *cpu_model;
       const char *vga_model = "none";
     const char *pid_file = NULL;      const char *pid_file = NULL;
     const char *incoming = NULL;      const char *incoming = NULL;
 #ifdef CONFIG_VNC  #ifdef CONFIG_VNC
     int show_vnc_port = 0;      int show_vnc_port = 0;
 #endif  #endif
     int defconfig = 1;      bool defconfig = true;
       bool userconfig = true;
     const char *log_mask = NULL;      const char *log_mask = NULL;
     const char *log_file = NULL;      const char *log_file = NULL;
     GMemVTable mem_trace = {      GMemVTable mem_trace = {
Line 2189  int main(int argc, char **argv, char **e Line 2307  int main(int argc, char **argv, char **e
   
     g_mem_set_vtable(&mem_trace);      g_mem_set_vtable(&mem_trace);
     if (!g_thread_supported()) {      if (!g_thread_supported()) {
   #if !GLIB_CHECK_VERSION(2, 31, 0)
         g_thread_init(NULL);          g_thread_init(NULL);
   #else
           fprintf(stderr, "glib threading failed to initialize.\n");
           exit(1);
   #endif
     }      }
   
       module_call_init(MODULE_INIT_QOM);
   
     runstate_init();      runstate_init();
   
     init_clocks();      init_clocks();
Line 2205  int main(int argc, char **argv, char **e Line 2330  int main(int argc, char **argv, char **e
     module_call_init(MODULE_INIT_MACHINE);      module_call_init(MODULE_INIT_MACHINE);
     machine = find_default_machine();      machine = find_default_machine();
     cpu_model = NULL;      cpu_model = NULL;
     initrd_filename = NULL;  
     ram_size = 0;      ram_size = 0;
     snapshot = 0;      snapshot = 0;
     kernel_filename = NULL;  
     kernel_cmdline = "";  
     cyls = heads = secs = 0;      cyls = heads = secs = 0;
     translation = BIOS_ATA_TRANSLATION_AUTO;      translation = BIOS_ATA_TRANSLATION_AUTO;
   
Line 2236  int main(int argc, char **argv, char **e Line 2358  int main(int argc, char **argv, char **e
             popt = lookup_opt(argc, argv, &optarg, &optind);              popt = lookup_opt(argc, argv, &optarg, &optind);
             switch (popt->index) {              switch (popt->index) {
             case QEMU_OPTION_nodefconfig:              case QEMU_OPTION_nodefconfig:
                 defconfig=0;                  defconfig = false;
                   break;
               case QEMU_OPTION_nouserconfig:
                   userconfig = false;
                 break;                  break;
             }              }
         }          }
Line 2244  int main(int argc, char **argv, char **e Line 2369  int main(int argc, char **argv, char **e
   
     if (defconfig) {      if (defconfig) {
         int ret;          int ret;
           ret = qemu_read_default_config_files(userconfig);
         ret = qemu_read_config_file(CONFIG_QEMU_CONFDIR "/qemu.conf");          if (ret < 0) {
         if (ret < 0 && ret != -ENOENT) {  
             exit(1);  
         }  
   
         ret = qemu_read_config_file(arch_config_name);  
         if (ret < 0 && ret != -ENOENT) {  
             exit(1);              exit(1);
         }          }
     }      }
     cpudef_init();  
   
     /* second pass of option parsing */      /* second pass of option parsing */
     optind = 1;      optind = 1;
Line 2278  int main(int argc, char **argv, char **e Line 2396  int main(int argc, char **argv, char **e
                 break;                  break;
             case QEMU_OPTION_cpu:              case QEMU_OPTION_cpu:
                 /* hw initialization will check this */                  /* hw initialization will check this */
                 if (*optarg == '?') {                  cpu_model = optarg;
                     list_cpus(stdout, &fprintf, optarg);  
                     exit(0);  
                 } else {  
                     cpu_model = optarg;  
                 }  
                 break;  
             case QEMU_OPTION_initrd:  
                 initrd_filename = optarg;  
                 break;                  break;
             case QEMU_OPTION_hda:              case QEMU_OPTION_hda:
                 {                  {
Line 2418  int main(int argc, char **argv, char **e Line 2528  int main(int argc, char **argv, char **e
                 }                  }
                 break;                  break;
             case QEMU_OPTION_kernel:              case QEMU_OPTION_kernel:
                 kernel_filename = optarg;                  qemu_opts_set(qemu_find_opts("machine"), 0, "kernel", optarg);
                   break;
               case QEMU_OPTION_initrd:
                   qemu_opts_set(qemu_find_opts("machine"), 0, "initrd", optarg);
                 break;                  break;
             case QEMU_OPTION_append:              case QEMU_OPTION_append:
                 kernel_cmdline = optarg;                  qemu_opts_set(qemu_find_opts("machine"), 0, "append", optarg);
                   break;
               case QEMU_OPTION_dtb:
                   qemu_opts_set(qemu_find_opts("machine"), 0, "dtb", optarg);
                 break;                  break;
             case QEMU_OPTION_cdrom:              case QEMU_OPTION_cdrom:
                 drive_add(IF_DEFAULT, 2, optarg, CDROM_OPTS);                  drive_add(IF_DEFAULT, 2, optarg, CDROM_OPTS);
Line 2496  int main(int argc, char **argv, char **e Line 2612  int main(int argc, char **argv, char **e
                     exit(1);                      exit(1);
                 }                  }
                 break;                  break;
   #ifdef CONFIG_LIBISCSI
               case QEMU_OPTION_iscsi:
                   opts = qemu_opts_parse(qemu_find_opts("iscsi"), optarg, 0);
                   if (!opts) {
                       exit(1);
                   }
                   break;
   #endif
 #ifdef CONFIG_SLIRP  #ifdef CONFIG_SLIRP
             case QEMU_OPTION_tftp:              case QEMU_OPTION_tftp:
                 legacy_tftp_prefix = optarg;                  legacy_tftp_prefix = optarg;
Line 2565  int main(int argc, char **argv, char **e Line 2689  int main(int argc, char **argv, char **e
                 log_file = optarg;                  log_file = optarg;
                 break;                  break;
             case QEMU_OPTION_s:              case QEMU_OPTION_s:
                 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;                  add_device_config(DEV_GDB, "tcp::" DEFAULT_GDBSTUB_PORT);
                 break;                  break;
             case QEMU_OPTION_gdb:              case QEMU_OPTION_gdb:
                 gdbstub_dev = optarg;                  add_device_config(DEV_GDB, optarg);
                 break;                  break;
             case QEMU_OPTION_L:              case QEMU_OPTION_L:
                 data_dir = optarg;                  data_dir = optarg;
Line 2589  int main(int argc, char **argv, char **e Line 2713  int main(int argc, char **argv, char **e
                 rtc_utc = 0;                  rtc_utc = 0;
                 break;                  break;
             case QEMU_OPTION_vga:              case QEMU_OPTION_vga:
                 select_vgahw (optarg);                  vga_model = optarg;
                   default_vga = 0;
                 break;                  break;
             case QEMU_OPTION_g:              case QEMU_OPTION_g:
                 {                  {
Line 2669  int main(int argc, char **argv, char **e Line 2794  int main(int argc, char **argv, char **e
             case QEMU_OPTION_virtfs: {              case QEMU_OPTION_virtfs: {
                 QemuOpts *fsdev;                  QemuOpts *fsdev;
                 QemuOpts *device;                  QemuOpts *device;
                 const char *writeout;                  const char *writeout, *sock_fd, *socket;
   
                 olist = qemu_find_opts("virtfs");                  olist = qemu_find_opts("virtfs");
                 if (!olist) {                  if (!olist) {
Line 2683  int main(int argc, char **argv, char **e Line 2808  int main(int argc, char **argv, char **e
                 }                  }
   
                 if (qemu_opt_get(opts, "fsdriver") == NULL ||                  if (qemu_opt_get(opts, "fsdriver") == NULL ||
                         qemu_opt_get(opts, "mount_tag") == NULL ||                      qemu_opt_get(opts, "mount_tag") == NULL) {
                         qemu_opt_get(opts, "path") == NULL) {                      fprintf(stderr, "Usage: -virtfs fsdriver,mount_tag=tag.\n");
                     fprintf(stderr, "Usage: -virtfs fsdriver,path=/share_path/,"  
                             "[security_model={mapped|passthrough|none}],"  
                             "mount_tag=tag.\n");  
                     exit(1);                      exit(1);
                 }                  }
                 fsdev = qemu_opts_create(qemu_find_opts("fsdev"),                  fsdev = qemu_opts_create(qemu_find_opts("fsdev"),
Line 2712  int main(int argc, char **argv, char **e Line 2834  int main(int argc, char **argv, char **e
                 qemu_opt_set(fsdev, "path", qemu_opt_get(opts, "path"));                  qemu_opt_set(fsdev, "path", qemu_opt_get(opts, "path"));
                 qemu_opt_set(fsdev, "security_model",                  qemu_opt_set(fsdev, "security_model",
                              qemu_opt_get(opts, "security_model"));                               qemu_opt_get(opts, "security_model"));
                   socket = qemu_opt_get(opts, "socket");
                   if (socket) {
                       qemu_opt_set(fsdev, "socket", socket);
                   }
                   sock_fd = qemu_opt_get(opts, "sock_fd");
                   if (sock_fd) {
                       qemu_opt_set(fsdev, "sock_fd", sock_fd);
                   }
   
                 qemu_opt_set_bool(fsdev, "readonly",                  qemu_opt_set_bool(fsdev, "readonly",
                                 qemu_opt_get_bool(opts, "readonly", 0));                                  qemu_opt_get_bool(opts, "readonly", 0));
Line 2733  int main(int argc, char **argv, char **e Line 2863  int main(int argc, char **argv, char **e
                     exit(1);                      exit(1);
                 }                  }
                 qemu_opt_set(fsdev, "fsdriver", "synth");                  qemu_opt_set(fsdev, "fsdriver", "synth");
                 qemu_opt_set(fsdev, "path", "/"); /* ignored */  
   
                 device = qemu_opts_create(qemu_find_opts("device"), NULL, 0);                  device = qemu_opts_create(qemu_find_opts("device"), NULL, 0);
                 qemu_opt_set(device, "driver", "virtio-9p-pci");                  qemu_opt_set(device, "driver", "virtio-9p-pci");
Line 2816  int main(int argc, char **argv, char **e Line 2945  int main(int argc, char **argv, char **e
             case QEMU_OPTION_win2k_hack:              case QEMU_OPTION_win2k_hack:
                 win2k_install_hack = 1;                  win2k_install_hack = 1;
                 break;                  break;
             case QEMU_OPTION_rtc_td_hack:              case QEMU_OPTION_rtc_td_hack: {
                 rtc_td_hack = 1;                  static GlobalProperty slew_lost_ticks[] = {
                       {
                           .driver   = "mc146818rtc",
                           .property = "lost_tick_policy",
                           .value    = "slew",
                       },
                       { /* end of list */ }
                   };
   
                   qdev_prop_register_global_list(slew_lost_ticks);
                 break;                  break;
               }
             case QEMU_OPTION_acpitable:              case QEMU_OPTION_acpitable:
                 do_acpitable_option(optarg);                  do_acpitable_option(optarg);
                 break;                  break;
Line 2827  int main(int argc, char **argv, char **e Line 2966  int main(int argc, char **argv, char **e
                 break;                  break;
             case QEMU_OPTION_enable_kvm:              case QEMU_OPTION_enable_kvm:
                 olist = qemu_find_opts("machine");                  olist = qemu_find_opts("machine");
                 qemu_opts_reset(olist);  
                 qemu_opts_parse(olist, "accel=kvm", 0);                  qemu_opts_parse(olist, "accel=kvm", 0);
                 break;                  break;
             case QEMU_OPTION_machine:              case QEMU_OPTION_machine:
                 olist = qemu_find_opts("machine");                  olist = qemu_find_opts("machine");
                 qemu_opts_reset(olist);  
                 opts = qemu_opts_parse(olist, optarg, 1);                  opts = qemu_opts_parse(olist, optarg, 1);
                 if (!opts) {                  if (!opts) {
                     fprintf(stderr, "parse error: %s\n", optarg);                      fprintf(stderr, "parse error: %s\n", optarg);
Line 2976  int main(int argc, char **argv, char **e Line 3113  int main(int argc, char **argv, char **e
                 break;                  break;
             case QEMU_OPTION_incoming:              case QEMU_OPTION_incoming:
                 incoming = optarg;                  incoming = optarg;
                   runstate_set(RUN_STATE_INMIGRATE);
                 break;                  break;
             case QEMU_OPTION_nodefaults:              case QEMU_OPTION_nodefaults:
                 default_serial = 0;                  default_serial = 0;
                 default_parallel = 0;                  default_parallel = 0;
                 default_virtcon = 0;                  default_virtcon = 0;
                 default_monitor = 0;                  default_monitor = 0;
                 default_vga = 0;  
                 default_net = 0;                  default_net = 0;
                 default_floppy = 0;                  default_floppy = 0;
                 default_cdrom = 0;                  default_cdrom = 0;
                 default_sdcard = 0;                  default_sdcard = 0;
                   default_vga = 0;
                 break;                  break;
             case QEMU_OPTION_xen_domid:              case QEMU_OPTION_xen_domid:
                 if (!(xen_available())) {                  if (!(xen_available())) {
Line 3057  int main(int argc, char **argv, char **e Line 3195  int main(int argc, char **argv, char **e
                     fclose(fp);                      fclose(fp);
                     break;                      break;
                 }                  }
               case QEMU_OPTION_qtest:
                   qtest_chrdev = optarg;
                   break;
               case QEMU_OPTION_qtest_log:
                   qtest_log = optarg;
                   break;
             default:              default:
                 os_parse_cmd_args(popt->index, optarg);                  os_parse_cmd_args(popt->index, optarg);
             }              }
Line 3064  int main(int argc, char **argv, char **e Line 3208  int main(int argc, char **argv, char **e
     }      }
     loc_set_none();      loc_set_none();
   
       /* Init CPU def lists, based on config
        * - Must be called after all the qemu_read_config_file() calls
        * - Must be called before list_cpus()
        * - Must be called before machine->init()
        */
       cpudef_init();
   
       if (cpu_model && *cpu_model == '?') {
           list_cpus(stdout, &fprintf, cpu_model);
           exit(0);
       }
   
     /* Open the logfile at this point, if necessary. We can't open the logfile      /* Open the logfile at this point, if necessary. We can't open the logfile
      * when encountering either of the logging options (-d or -D) because the       * when encountering either of the logging options (-d or -D) because the
      * other one may be encountered later on the command line, changing the       * other one may be encountered later on the command line, changing the
Line 3115  int main(int argc, char **argv, char **e Line 3271  int main(int argc, char **argv, char **e
      * specified either by the configuration file or by the command line.       * specified either by the configuration file or by the command line.
      */       */
     if (machine->default_machine_opts) {      if (machine->default_machine_opts) {
         QemuOptsList *list = qemu_find_opts("machine");          qemu_opts_set_defaults(qemu_find_opts("machine"),
         const char *p = NULL;                                 machine->default_machine_opts, 0);
   
         if (!QTAILQ_EMPTY(&list->head)) {  
             p = qemu_opt_get(QTAILQ_FIRST(&list->head), "accel");  
         }  
         if (p == NULL) {  
             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);  
                 exit(1);  
             }  
         }  
     }      }
   
     qemu_opts_foreach(qemu_find_opts("device"), default_driver_check, NULL, 0);      qemu_opts_foreach(qemu_find_opts("device"), default_driver_check, NULL, 0);
Line 3144  int main(int argc, char **argv, char **e Line 3287  int main(int argc, char **argv, char **e
     if (!machine->use_virtcon) {      if (!machine->use_virtcon) {
         default_virtcon = 0;          default_virtcon = 0;
     }      }
     if (machine->no_vga) {  
         default_vga = 0;  
     }  
     if (machine->no_floppy) {      if (machine->no_floppy) {
         default_floppy = 0;          default_floppy = 0;
     }      }
Line 3182  int main(int argc, char **argv, char **e Line 3322  int main(int argc, char **argv, char **e
         if (default_virtcon)          if (default_virtcon)
             add_device_config(DEV_VIRTCON, "vc:80Cx24C");              add_device_config(DEV_VIRTCON, "vc:80Cx24C");
     }      }
     if (default_vga)  
         vga_interface_type = VGA_CIRRUS;  
   
     socket_init();      socket_init();
   
Line 3214  int main(int argc, char **argv, char **e Line 3352  int main(int argc, char **argv, char **e
         fprintf(stderr, "qemu_init_main_loop failed\n");          fprintf(stderr, "qemu_init_main_loop failed\n");
         exit(1);          exit(1);
     }      }
   
       machine_opts = qemu_opts_find(qemu_find_opts("machine"), 0);
       if (machine_opts) {
           kernel_filename = qemu_opt_get(machine_opts, "kernel");
           initrd_filename = qemu_opt_get(machine_opts, "initrd");
           kernel_cmdline = qemu_opt_get(machine_opts, "append");
       } else {
           kernel_filename = initrd_filename = kernel_cmdline = NULL;
       }
   
       if (!kernel_cmdline) {
           kernel_cmdline = "";
       }
   
     linux_boot = (kernel_filename != NULL);      linux_boot = (kernel_filename != NULL);
   
     if (!linux_boot && *kernel_cmdline != '\0') {      if (!linux_boot && *kernel_cmdline != '\0') {
Line 3226  int main(int argc, char **argv, char **e Line 3378  int main(int argc, char **argv, char **e
         exit(1);          exit(1);
     }      }
   
       if (!linux_boot && machine_opts && qemu_opt_get(machine_opts, "dtb")) {
           fprintf(stderr, "-dtb only allowed with -kernel option\n");
           exit(1);
       }
   
     os_set_line_buffering();      os_set_line_buffering();
   
     if (init_timer_alarm() < 0) {      if (init_timer_alarm() < 0) {
Line 3233  int main(int argc, char **argv, char **e Line 3390  int main(int argc, char **argv, char **e
         exit(1);          exit(1);
     }      }
   
   #ifdef CONFIG_SPICE
       /* spice needs the timers to be initialized by this point */
       qemu_spice_init();
   #endif
   
     if (icount_option && (kvm_enabled() || xen_enabled())) {      if (icount_option && (kvm_enabled() || xen_enabled())) {
         fprintf(stderr, "-icount is not allowed with kvm or xen\n");          fprintf(stderr, "-icount is not allowed with kvm or xen\n");
         exit(1);          exit(1);
Line 3313  int main(int argc, char **argv, char **e Line 3475  int main(int argc, char **argv, char **e
          * real machines which also use this scheme.           * real machines which also use this scheme.
          */           */
         if (i == nb_numa_nodes) {          if (i == nb_numa_nodes) {
             for (i = 0; i < smp_cpus; i++) {              for (i = 0; i < max_cpus; i++) {
                 node_cpumask[i % nb_numa_nodes] |= 1 << i;                  node_cpumask[i % nb_numa_nodes] |= 1 << i;
             }              }
         }          }
Line 3332  int main(int argc, char **argv, char **e Line 3494  int main(int argc, char **argv, char **e
     if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)      if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
         exit(1);          exit(1);
   
     module_call_init(MODULE_INIT_DEVICE);      /* If no default VGA is requested, the default is "none".  */
       if (default_vga && cirrus_vga_available()) {
           vga_model = "cirrus";
       }
       select_vgahw(vga_model);
   
     if (qemu_opts_foreach(qemu_find_opts("device"), device_help_func, NULL, 0) != 0)      if (qemu_opts_foreach(qemu_find_opts("device"), device_help_func, NULL, 0) != 0)
         exit(0);          exit(0);
Line 3348  int main(int argc, char **argv, char **e Line 3514  int main(int argc, char **argv, char **e
     }      }
     qemu_add_globals();      qemu_add_globals();
   
       qdev_machine_init();
   
     machine->init(ram_size, boot_devices,      machine->init(ram_size, boot_devices,
                   kernel_filename, kernel_cmdline, initrd_filename, cpu_model);                    kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
   
Line 3442  int main(int argc, char **argv, char **e Line 3610  int main(int argc, char **argv, char **e
     }      }
     text_consoles_set_display(ds);      text_consoles_set_display(ds);
   
     if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {      if (foreach_device_config(DEV_GDB, gdbserver_start) < 0) {
         fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",  
                 gdbstub_dev);  
         exit(1);          exit(1);
     }      }
   
Line 3468  int main(int argc, char **argv, char **e Line 3634  int main(int argc, char **argv, char **e
     }      }
   
     if (incoming) {      if (incoming) {
         runstate_set(RUN_STATE_INMIGRATE);          Error *errp = NULL;
         int ret = qemu_start_incoming_migration(incoming);          int ret = qemu_start_incoming_migration(incoming, &errp);
         if (ret < 0) {          if (ret < 0) {
               if (error_is_set(&errp)) {
                   fprintf(stderr, "Migrate: %s\n", error_get_pretty(errp));
                   error_free(errp);
               }
             fprintf(stderr, "Migration failed. Exit code %s(%d), exiting.\n",              fprintf(stderr, "Migration failed. Exit code %s(%d), exiting.\n",
                     incoming, ret);                      incoming, ret);
             exit(ret);              exit(ret);

Removed from v.1.1.1.21  
changed lines
  Added in v.1.1.1.22


unix.superglobalmegacorp.com