File:  [Qemu by Fabrice Bellard] / qemu / vl.c
Revision 1.1.1.18 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:33:14 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu0140, HEAD
qemu 0.14.0

    1: /*
    2:  * QEMU System Emulator
    3:  *
    4:  * Copyright (c) 2003-2008 Fabrice Bellard
    5:  *
    6:  * Permission is hereby granted, free of charge, to any person obtaining a copy
    7:  * of this software and associated documentation files (the "Software"), to deal
    8:  * in the Software without restriction, including without limitation the rights
    9:  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   10:  * copies of the Software, and to permit persons to whom the Software is
   11:  * furnished to do so, subject to the following conditions:
   12:  *
   13:  * The above copyright notice and this permission notice shall be included in
   14:  * all copies or substantial portions of the Software.
   15:  *
   16:  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   17:  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   18:  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
   19:  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   20:  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   21:  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   22:  * THE SOFTWARE.
   23:  */
   24: #include <unistd.h>
   25: #include <fcntl.h>
   26: #include <signal.h>
   27: #include <time.h>
   28: #include <errno.h>
   29: #include <sys/time.h>
   30: #include <zlib.h>
   31: 
   32: /* Needed early for CONFIG_BSD etc. */
   33: #include "config-host.h"
   34: 
   35: #ifndef _WIN32
   36: #include <libgen.h>
   37: #include <sys/times.h>
   38: #include <sys/wait.h>
   39: #include <termios.h>
   40: #include <sys/mman.h>
   41: #include <sys/ioctl.h>
   42: #include <sys/resource.h>
   43: #include <sys/socket.h>
   44: #include <netinet/in.h>
   45: #include <net/if.h>
   46: #include <arpa/inet.h>
   47: #include <dirent.h>
   48: #include <netdb.h>
   49: #include <sys/select.h>
   50: #ifdef CONFIG_SIMPLE_TRACE
   51: #include "trace.h"
   52: #endif
   53: 
   54: #ifdef CONFIG_BSD
   55: #include <sys/stat.h>
   56: #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
   57: #include <libutil.h>
   58: #include <sys/sysctl.h>
   59: #else
   60: #include <util.h>
   61: #endif
   62: #else
   63: #ifdef __linux__
   64: #include <pty.h>
   65: #include <malloc.h>
   66: 
   67: #include <linux/ppdev.h>
   68: #include <linux/parport.h>
   69: #endif
   70: #ifdef __sun__
   71: #include <sys/stat.h>
   72: #include <sys/ethernet.h>
   73: #include <sys/sockio.h>
   74: #include <netinet/arp.h>
   75: #include <netinet/in_systm.h>
   76: #include <netinet/ip.h>
   77: #include <netinet/ip_icmp.h> // must come after ip.h
   78: #include <netinet/udp.h>
   79: #include <netinet/tcp.h>
   80: #include <net/if.h>
   81: #include <syslog.h>
   82: #include <stropts.h>
   83: #endif
   84: #endif
   85: #endif
   86: 
   87: #if defined(__OpenBSD__)
   88: #include <util.h>
   89: #endif
   90: 
   91: #if defined(CONFIG_VDE)
   92: #include <libvdeplug.h>
   93: #endif
   94: 
   95: #ifdef _WIN32
   96: #include <windows.h>
   97: #endif
   98: 
   99: #ifdef CONFIG_SDL
  100: #if defined(__APPLE__) || defined(main)
  101: #include <SDL.h>
  102: int qemu_main(int argc, char **argv, char **envp);
  103: int main(int argc, char **argv)
  104: {
  105:     return qemu_main(argc, argv, NULL);
  106: }
  107: #undef main
  108: #define main qemu_main
  109: #endif
  110: #endif /* CONFIG_SDL */
  111: 
  112: #ifdef CONFIG_COCOA
  113: #undef main
  114: #define main qemu_main
  115: #endif /* CONFIG_COCOA */
  116: 
  117: #include "hw/hw.h"
  118: #include "hw/boards.h"
  119: #include "hw/usb.h"
  120: #include "hw/pcmcia.h"
  121: #include "hw/pc.h"
  122: #include "hw/isa.h"
  123: #include "hw/baum.h"
  124: #include "hw/bt.h"
  125: #include "hw/watchdog.h"
  126: #include "hw/smbios.h"
  127: #include "hw/xen.h"
  128: #include "hw/qdev.h"
  129: #include "hw/loader.h"
  130: #include "bt-host.h"
  131: #include "net.h"
  132: #include "net/slirp.h"
  133: #include "monitor.h"
  134: #include "console.h"
  135: #include "sysemu.h"
  136: #include "gdbstub.h"
  137: #include "qemu-timer.h"
  138: #include "qemu-char.h"
  139: #include "cache-utils.h"
  140: #include "block.h"
  141: #include "blockdev.h"
  142: #include "block-migration.h"
  143: #include "dma.h"
  144: #include "audio/audio.h"
  145: #include "migration.h"
  146: #include "kvm.h"
  147: #include "qemu-option.h"
  148: #include "qemu-config.h"
  149: #include "qemu-objects.h"
  150: #include "qemu-options.h"
  151: #ifdef CONFIG_VIRTFS
  152: #include "fsdev/qemu-fsdev.h"
  153: #endif
  154: 
  155: #include "disas.h"
  156: 
  157: #include "qemu_socket.h"
  158: 
  159: #include "slirp/libslirp.h"
  160: 
  161: #include "trace.h"
  162: #include "qemu-queue.h"
  163: #include "cpus.h"
  164: #include "arch_init.h"
  165: 
  166: #include "ui/qemu-spice.h"
  167: 
  168: //#define DEBUG_NET
  169: //#define DEBUG_SLIRP
  170: 
  171: #define DEFAULT_RAM_SIZE 128
  172: 
  173: #define MAX_VIRTIO_CONSOLES 1
  174: 
  175: static const char *data_dir;
  176: const char *bios_name = NULL;
  177: enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
  178: DisplayType display_type = DT_DEFAULT;
  179: int display_remote = 0;
  180: const char* keyboard_layout = NULL;
  181: ram_addr_t ram_size;
  182: const char *mem_path = NULL;
  183: #ifdef MAP_POPULATE
  184: int mem_prealloc = 0; /* force preallocation of physical target memory */
  185: #endif
  186: int nb_nics;
  187: NICInfo nd_table[MAX_NICS];
  188: int vm_running;
  189: int autostart;
  190: int incoming_expected; /* Started with -incoming and waiting for incoming */
  191: static int rtc_utc = 1;
  192: static int rtc_date_offset = -1; /* -1 means no change */
  193: QEMUClock *rtc_clock;
  194: int vga_interface_type = VGA_NONE;
  195: static int full_screen = 0;
  196: #ifdef CONFIG_SDL
  197: static int no_frame = 0;
  198: #endif
  199: int no_quit = 0;
  200: CharDriverState *serial_hds[MAX_SERIAL_PORTS];
  201: CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
  202: CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
  203: int win2k_install_hack = 0;
  204: int rtc_td_hack = 0;
  205: int usb_enabled = 0;
  206: int singlestep = 0;
  207: int smp_cpus = 1;
  208: int max_cpus = 0;
  209: int smp_cores = 1;
  210: int smp_threads = 1;
  211: const char *vnc_display;
  212: int acpi_enabled = 1;
  213: int no_hpet = 0;
  214: int fd_bootchk = 1;
  215: int no_reboot = 0;
  216: int no_shutdown = 0;
  217: int cursor_hide = 1;
  218: int graphic_rotate = 0;
  219: uint8_t irq0override = 1;
  220: const char *watchdog;
  221: QEMUOptionRom option_rom[MAX_OPTION_ROMS];
  222: int nb_option_roms;
  223: int semihosting_enabled = 0;
  224: int old_param = 0;
  225: const char *qemu_name;
  226: int alt_grab = 0;
  227: int ctrl_grab = 0;
  228: unsigned int nb_prom_envs = 0;
  229: const char *prom_envs[MAX_PROM_ENVS];
  230: int boot_menu;
  231: 
  232: typedef struct FWBootEntry FWBootEntry;
  233: 
  234: struct FWBootEntry {
  235:     QTAILQ_ENTRY(FWBootEntry) link;
  236:     int32_t bootindex;
  237:     DeviceState *dev;
  238:     char *suffix;
  239: };
  240: 
  241: QTAILQ_HEAD(, FWBootEntry) fw_boot_order = QTAILQ_HEAD_INITIALIZER(fw_boot_order);
  242: 
  243: int nb_numa_nodes;
  244: uint64_t node_mem[MAX_NODES];
  245: uint64_t node_cpumask[MAX_NODES];
  246: 
  247: static QEMUTimer *nographic_timer;
  248: 
  249: uint8_t qemu_uuid[16];
  250: 
  251: static QEMUBootSetHandler *boot_set_handler;
  252: static void *boot_set_opaque;
  253: 
  254: static NotifierList exit_notifiers =
  255:     NOTIFIER_LIST_INITIALIZER(exit_notifiers);
  256: 
  257: static NotifierList machine_init_done_notifiers =
  258:     NOTIFIER_LIST_INITIALIZER(machine_init_done_notifiers);
  259: 
  260: int kvm_allowed = 0;
  261: uint32_t xen_domid;
  262: enum xen_mode xen_mode = XEN_EMULATE;
  263: 
  264: static int default_serial = 1;
  265: static int default_parallel = 1;
  266: static int default_virtcon = 1;
  267: static int default_monitor = 1;
  268: static int default_vga = 1;
  269: static int default_floppy = 1;
  270: static int default_cdrom = 1;
  271: static int default_sdcard = 1;
  272: 
  273: static struct {
  274:     const char *driver;
  275:     int *flag;
  276: } default_list[] = {
  277:     { .driver = "isa-serial",           .flag = &default_serial    },
  278:     { .driver = "isa-parallel",         .flag = &default_parallel  },
  279:     { .driver = "isa-fdc",              .flag = &default_floppy    },
  280:     { .driver = "ide-drive",            .flag = &default_cdrom     },
  281:     { .driver = "virtio-serial-pci",    .flag = &default_virtcon   },
  282:     { .driver = "virtio-serial-s390",   .flag = &default_virtcon   },
  283:     { .driver = "virtio-serial",        .flag = &default_virtcon   },
  284:     { .driver = "VGA",                  .flag = &default_vga       },
  285:     { .driver = "cirrus-vga",           .flag = &default_vga       },
  286:     { .driver = "vmware-svga",          .flag = &default_vga       },
  287: };
  288: 
  289: static int default_driver_check(QemuOpts *opts, void *opaque)
  290: {
  291:     const char *driver = qemu_opt_get(opts, "driver");
  292:     int i;
  293: 
  294:     if (!driver)
  295:         return 0;
  296:     for (i = 0; i < ARRAY_SIZE(default_list); i++) {
  297:         if (strcmp(default_list[i].driver, driver) != 0)
  298:             continue;
  299:         *(default_list[i].flag) = 0;
  300:     }
  301:     return 0;
  302: }
  303: 
  304: /***********************************************************/
  305: /* real time host monotonic timer */
  306: 
  307: /***********************************************************/
  308: /* host time/date access */
  309: void qemu_get_timedate(struct tm *tm, int offset)
  310: {
  311:     time_t ti;
  312:     struct tm *ret;
  313: 
  314:     time(&ti);
  315:     ti += offset;
  316:     if (rtc_date_offset == -1) {
  317:         if (rtc_utc)
  318:             ret = gmtime(&ti);
  319:         else
  320:             ret = localtime(&ti);
  321:     } else {
  322:         ti -= rtc_date_offset;
  323:         ret = gmtime(&ti);
  324:     }
  325: 
  326:     memcpy(tm, ret, sizeof(struct tm));
  327: }
  328: 
  329: int qemu_timedate_diff(struct tm *tm)
  330: {
  331:     time_t seconds;
  332: 
  333:     if (rtc_date_offset == -1)
  334:         if (rtc_utc)
  335:             seconds = mktimegm(tm);
  336:         else
  337:             seconds = mktime(tm);
  338:     else
  339:         seconds = mktimegm(tm) + rtc_date_offset;
  340: 
  341:     return seconds - time(NULL);
  342: }
  343: 
  344: void rtc_change_mon_event(struct tm *tm)
  345: {
  346:     QObject *data;
  347: 
  348:     data = qobject_from_jsonf("{ 'offset': %d }", qemu_timedate_diff(tm));
  349:     monitor_protocol_event(QEVENT_RTC_CHANGE, data);
  350:     qobject_decref(data);
  351: }
  352: 
  353: static void configure_rtc_date_offset(const char *startdate, int legacy)
  354: {
  355:     time_t rtc_start_date;
  356:     struct tm tm;
  357: 
  358:     if (!strcmp(startdate, "now") && legacy) {
  359:         rtc_date_offset = -1;
  360:     } else {
  361:         if (sscanf(startdate, "%d-%d-%dT%d:%d:%d",
  362:                    &tm.tm_year,
  363:                    &tm.tm_mon,
  364:                    &tm.tm_mday,
  365:                    &tm.tm_hour,
  366:                    &tm.tm_min,
  367:                    &tm.tm_sec) == 6) {
  368:             /* OK */
  369:         } else if (sscanf(startdate, "%d-%d-%d",
  370:                           &tm.tm_year,
  371:                           &tm.tm_mon,
  372:                           &tm.tm_mday) == 3) {
  373:             tm.tm_hour = 0;
  374:             tm.tm_min = 0;
  375:             tm.tm_sec = 0;
  376:         } else {
  377:             goto date_fail;
  378:         }
  379:         tm.tm_year -= 1900;
  380:         tm.tm_mon--;
  381:         rtc_start_date = mktimegm(&tm);
  382:         if (rtc_start_date == -1) {
  383:         date_fail:
  384:             fprintf(stderr, "Invalid date format. Valid formats are:\n"
  385:                             "'2006-06-17T16:01:21' or '2006-06-17'\n");
  386:             exit(1);
  387:         }
  388:         rtc_date_offset = time(NULL) - rtc_start_date;
  389:     }
  390: }
  391: 
  392: static void configure_rtc(QemuOpts *opts)
  393: {
  394:     const char *value;
  395: 
  396:     value = qemu_opt_get(opts, "base");
  397:     if (value) {
  398:         if (!strcmp(value, "utc")) {
  399:             rtc_utc = 1;
  400:         } else if (!strcmp(value, "localtime")) {
  401:             rtc_utc = 0;
  402:         } else {
  403:             configure_rtc_date_offset(value, 0);
  404:         }
  405:     }
  406:     value = qemu_opt_get(opts, "clock");
  407:     if (value) {
  408:         if (!strcmp(value, "host")) {
  409:             rtc_clock = host_clock;
  410:         } else if (!strcmp(value, "vm")) {
  411:             rtc_clock = vm_clock;
  412:         } else {
  413:             fprintf(stderr, "qemu: invalid option value '%s'\n", value);
  414:             exit(1);
  415:         }
  416:     }
  417:     value = qemu_opt_get(opts, "driftfix");
  418:     if (value) {
  419:         if (!strcmp(value, "slew")) {
  420:             rtc_td_hack = 1;
  421:         } else if (!strcmp(value, "none")) {
  422:             rtc_td_hack = 0;
  423:         } else {
  424:             fprintf(stderr, "qemu: invalid option value '%s'\n", value);
  425:             exit(1);
  426:         }
  427:     }
  428: }
  429: 
  430: /***********************************************************/
  431: /* Bluetooth support */
  432: static int nb_hcis;
  433: static int cur_hci;
  434: static struct HCIInfo *hci_table[MAX_NICS];
  435: 
  436: static struct bt_vlan_s {
  437:     struct bt_scatternet_s net;
  438:     int id;
  439:     struct bt_vlan_s *next;
  440: } *first_bt_vlan;
  441: 
  442: /* find or alloc a new bluetooth "VLAN" */
  443: static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
  444: {
  445:     struct bt_vlan_s **pvlan, *vlan;
  446:     for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
  447:         if (vlan->id == id)
  448:             return &vlan->net;
  449:     }
  450:     vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
  451:     vlan->id = id;
  452:     pvlan = &first_bt_vlan;
  453:     while (*pvlan != NULL)
  454:         pvlan = &(*pvlan)->next;
  455:     *pvlan = vlan;
  456:     return &vlan->net;
  457: }
  458: 
  459: static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
  460: {
  461: }
  462: 
  463: static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
  464: {
  465:     return -ENOTSUP;
  466: }
  467: 
  468: static struct HCIInfo null_hci = {
  469:     .cmd_send = null_hci_send,
  470:     .sco_send = null_hci_send,
  471:     .acl_send = null_hci_send,
  472:     .bdaddr_set = null_hci_addr_set,
  473: };
  474: 
  475: struct HCIInfo *qemu_next_hci(void)
  476: {
  477:     if (cur_hci == nb_hcis)
  478:         return &null_hci;
  479: 
  480:     return hci_table[cur_hci++];
  481: }
  482: 
  483: static struct HCIInfo *hci_init(const char *str)
  484: {
  485:     char *endp;
  486:     struct bt_scatternet_s *vlan = 0;
  487: 
  488:     if (!strcmp(str, "null"))
  489:         /* null */
  490:         return &null_hci;
  491:     else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
  492:         /* host[:hciN] */
  493:         return bt_host_hci(str[4] ? str + 5 : "hci0");
  494:     else if (!strncmp(str, "hci", 3)) {
  495:         /* hci[,vlan=n] */
  496:         if (str[3]) {
  497:             if (!strncmp(str + 3, ",vlan=", 6)) {
  498:                 vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
  499:                 if (*endp)
  500:                     vlan = 0;
  501:             }
  502:         } else
  503:             vlan = qemu_find_bt_vlan(0);
  504:         if (vlan)
  505:            return bt_new_hci(vlan);
  506:     }
  507: 
  508:     fprintf(stderr, "qemu: Unknown bluetooth HCI `%s'.\n", str);
  509: 
  510:     return 0;
  511: }
  512: 
  513: static int bt_hci_parse(const char *str)
  514: {
  515:     struct HCIInfo *hci;
  516:     bdaddr_t bdaddr;
  517: 
  518:     if (nb_hcis >= MAX_NICS) {
  519:         fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
  520:         return -1;
  521:     }
  522: 
  523:     hci = hci_init(str);
  524:     if (!hci)
  525:         return -1;
  526: 
  527:     bdaddr.b[0] = 0x52;
  528:     bdaddr.b[1] = 0x54;
  529:     bdaddr.b[2] = 0x00;
  530:     bdaddr.b[3] = 0x12;
  531:     bdaddr.b[4] = 0x34;
  532:     bdaddr.b[5] = 0x56 + nb_hcis;
  533:     hci->bdaddr_set(hci, bdaddr.b);
  534: 
  535:     hci_table[nb_hcis++] = hci;
  536: 
  537:     return 0;
  538: }
  539: 
  540: static void bt_vhci_add(int vlan_id)
  541: {
  542:     struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
  543: 
  544:     if (!vlan->slave)
  545:         fprintf(stderr, "qemu: warning: adding a VHCI to "
  546:                         "an empty scatternet %i\n", vlan_id);
  547: 
  548:     bt_vhci_init(bt_new_hci(vlan));
  549: }
  550: 
  551: static struct bt_device_s *bt_device_add(const char *opt)
  552: {
  553:     struct bt_scatternet_s *vlan;
  554:     int vlan_id = 0;
  555:     char *endp = strstr(opt, ",vlan=");
  556:     int len = (endp ? endp - opt : strlen(opt)) + 1;
  557:     char devname[10];
  558: 
  559:     pstrcpy(devname, MIN(sizeof(devname), len), opt);
  560: 
  561:     if (endp) {
  562:         vlan_id = strtol(endp + 6, &endp, 0);
  563:         if (*endp) {
  564:             fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
  565:             return 0;
  566:         }
  567:     }
  568: 
  569:     vlan = qemu_find_bt_vlan(vlan_id);
  570: 
  571:     if (!vlan->slave)
  572:         fprintf(stderr, "qemu: warning: adding a slave device to "
  573:                         "an empty scatternet %i\n", vlan_id);
  574: 
  575:     if (!strcmp(devname, "keyboard"))
  576:         return bt_keyboard_init(vlan);
  577: 
  578:     fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname);
  579:     return 0;
  580: }
  581: 
  582: static int bt_parse(const char *opt)
  583: {
  584:     const char *endp, *p;
  585:     int vlan;
  586: 
  587:     if (strstart(opt, "hci", &endp)) {
  588:         if (!*endp || *endp == ',') {
  589:             if (*endp)
  590:                 if (!strstart(endp, ",vlan=", 0))
  591:                     opt = endp + 1;
  592: 
  593:             return bt_hci_parse(opt);
  594:        }
  595:     } else if (strstart(opt, "vhci", &endp)) {
  596:         if (!*endp || *endp == ',') {
  597:             if (*endp) {
  598:                 if (strstart(endp, ",vlan=", &p)) {
  599:                     vlan = strtol(p, (char **) &endp, 0);
  600:                     if (*endp) {
  601:                         fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
  602:                         return 1;
  603:                     }
  604:                 } else {
  605:                     fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
  606:                     return 1;
  607:                 }
  608:             } else
  609:                 vlan = 0;
  610: 
  611:             bt_vhci_add(vlan);
  612:             return 0;
  613:         }
  614:     } else if (strstart(opt, "device:", &endp))
  615:         return !bt_device_add(endp);
  616: 
  617:     fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt);
  618:     return 1;
  619: }
  620: 
  621: /***********************************************************/
  622: /* QEMU Block devices */
  623: 
  624: #define HD_OPTS "media=disk"
  625: #define CDROM_OPTS "media=cdrom"
  626: #define FD_OPTS ""
  627: #define PFLASH_OPTS ""
  628: #define MTD_OPTS ""
  629: #define SD_OPTS ""
  630: 
  631: static int drive_init_func(QemuOpts *opts, void *opaque)
  632: {
  633:     int *use_scsi = opaque;
  634: 
  635:     return drive_init(opts, *use_scsi) == NULL;
  636: }
  637: 
  638: static int drive_enable_snapshot(QemuOpts *opts, void *opaque)
  639: {
  640:     if (NULL == qemu_opt_get(opts, "snapshot")) {
  641:         qemu_opt_set(opts, "snapshot", "on");
  642:     }
  643:     return 0;
  644: }
  645: 
  646: static void default_drive(int enable, int snapshot, int use_scsi,
  647:                           BlockInterfaceType type, int index,
  648:                           const char *optstr)
  649: {
  650:     QemuOpts *opts;
  651: 
  652:     if (type == IF_DEFAULT) {
  653:         type = use_scsi ? IF_SCSI : IF_IDE;
  654:     }
  655: 
  656:     if (!enable || drive_get_by_index(type, index)) {
  657:         return;
  658:     }
  659: 
  660:     opts = drive_add(type, index, NULL, optstr);
  661:     if (snapshot) {
  662:         drive_enable_snapshot(opts, NULL);
  663:     }
  664:     if (!drive_init(opts, use_scsi)) {
  665:         exit(1);
  666:     }
  667: }
  668: 
  669: void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque)
  670: {
  671:     boot_set_handler = func;
  672:     boot_set_opaque = opaque;
  673: }
  674: 
  675: int qemu_boot_set(const char *boot_devices)
  676: {
  677:     if (!boot_set_handler) {
  678:         return -EINVAL;
  679:     }
  680:     return boot_set_handler(boot_set_opaque, boot_devices);
  681: }
  682: 
  683: static void validate_bootdevices(char *devices)
  684: {
  685:     /* We just do some generic consistency checks */
  686:     const char *p;
  687:     int bitmap = 0;
  688: 
  689:     for (p = devices; *p != '\0'; p++) {
  690:         /* Allowed boot devices are:
  691:          * a-b: floppy disk drives
  692:          * c-f: IDE disk drives
  693:          * g-m: machine implementation dependant drives
  694:          * n-p: network devices
  695:          * It's up to each machine implementation to check if the given boot
  696:          * devices match the actual hardware implementation and firmware
  697:          * features.
  698:          */
  699:         if (*p < 'a' || *p > 'p') {
  700:             fprintf(stderr, "Invalid boot device '%c'\n", *p);
  701:             exit(1);
  702:         }
  703:         if (bitmap & (1 << (*p - 'a'))) {
  704:             fprintf(stderr, "Boot device '%c' was given twice\n", *p);
  705:             exit(1);
  706:         }
  707:         bitmap |= 1 << (*p - 'a');
  708:     }
  709: }
  710: 
  711: static void restore_boot_devices(void *opaque)
  712: {
  713:     char *standard_boot_devices = opaque;
  714:     static int first = 1;
  715: 
  716:     /* Restore boot order and remove ourselves after the first boot */
  717:     if (first) {
  718:         first = 0;
  719:         return;
  720:     }
  721: 
  722:     qemu_boot_set(standard_boot_devices);
  723: 
  724:     qemu_unregister_reset(restore_boot_devices, standard_boot_devices);
  725:     qemu_free(standard_boot_devices);
  726: }
  727: 
  728: void add_boot_device_path(int32_t bootindex, DeviceState *dev,
  729:                           const char *suffix)
  730: {
  731:     FWBootEntry *node, *i;
  732: 
  733:     if (bootindex < 0) {
  734:         return;
  735:     }
  736: 
  737:     assert(dev != NULL || suffix != NULL);
  738: 
  739:     node = qemu_mallocz(sizeof(FWBootEntry));
  740:     node->bootindex = bootindex;
  741:     node->suffix = suffix ? qemu_strdup(suffix) : NULL;
  742:     node->dev = dev;
  743: 
  744:     QTAILQ_FOREACH(i, &fw_boot_order, link) {
  745:         if (i->bootindex == bootindex) {
  746:             fprintf(stderr, "Two devices with same boot index %d\n", bootindex);
  747:             exit(1);
  748:         } else if (i->bootindex < bootindex) {
  749:             continue;
  750:         }
  751:         QTAILQ_INSERT_BEFORE(i, node, link);
  752:         return;
  753:     }
  754:     QTAILQ_INSERT_TAIL(&fw_boot_order, node, link);
  755: }
  756: 
  757: /*
  758:  * This function returns null terminated string that consist of new line
  759:  * separated device pathes.
  760:  *
  761:  * memory pointed by "size" is assigned total length of the array in bytes
  762:  *
  763:  */
  764: char *get_boot_devices_list(uint32_t *size)
  765: {
  766:     FWBootEntry *i;
  767:     uint32_t total = 0;
  768:     char *list = NULL;
  769: 
  770:     QTAILQ_FOREACH(i, &fw_boot_order, link) {
  771:         char *devpath = NULL, *bootpath;
  772:         int len;
  773: 
  774:         if (i->dev) {
  775:             devpath = qdev_get_fw_dev_path(i->dev);
  776:             assert(devpath);
  777:         }
  778: 
  779:         if (i->suffix && devpath) {
  780:             size_t bootpathlen = strlen(devpath) + strlen(i->suffix) + 1;
  781: 
  782:             bootpath = qemu_malloc(bootpathlen);
  783:             snprintf(bootpath, bootpathlen, "%s%s", devpath, i->suffix);
  784:             qemu_free(devpath);
  785:         } else if (devpath) {
  786:             bootpath = devpath;
  787:         } else {
  788:             bootpath = qemu_strdup(i->suffix);
  789:             assert(bootpath);
  790:         }
  791: 
  792:         if (total) {
  793:             list[total-1] = '\n';
  794:         }
  795:         len = strlen(bootpath) + 1;
  796:         list = qemu_realloc(list, total + len);
  797:         memcpy(&list[total], bootpath, len);
  798:         total += len;
  799:         qemu_free(bootpath);
  800:     }
  801: 
  802:     *size = total;
  803: 
  804:     return list;
  805: }
  806: 
  807: static void numa_add(const char *optarg)
  808: {
  809:     char option[128];
  810:     char *endptr;
  811:     unsigned long long value, endvalue;
  812:     int nodenr;
  813: 
  814:     optarg = get_opt_name(option, 128, optarg, ',') + 1;
  815:     if (!strcmp(option, "node")) {
  816:         if (get_param_value(option, 128, "nodeid", optarg) == 0) {
  817:             nodenr = nb_numa_nodes;
  818:         } else {
  819:             nodenr = strtoull(option, NULL, 10);
  820:         }
  821: 
  822:         if (get_param_value(option, 128, "mem", optarg) == 0) {
  823:             node_mem[nodenr] = 0;
  824:         } else {
  825:             int64_t sval;
  826:             sval = strtosz(option, NULL);
  827:             if (sval < 0) {
  828:                 fprintf(stderr, "qemu: invalid numa mem size: %s\n", optarg);
  829:                 exit(1);
  830:             }
  831:             node_mem[nodenr] = sval;
  832:         }
  833:         if (get_param_value(option, 128, "cpus", optarg) == 0) {
  834:             node_cpumask[nodenr] = 0;
  835:         } else {
  836:             value = strtoull(option, &endptr, 10);
  837:             if (value >= 64) {
  838:                 value = 63;
  839:                 fprintf(stderr, "only 64 CPUs in NUMA mode supported.\n");
  840:             } else {
  841:                 if (*endptr == '-') {
  842:                     endvalue = strtoull(endptr+1, &endptr, 10);
  843:                     if (endvalue >= 63) {
  844:                         endvalue = 62;
  845:                         fprintf(stderr,
  846:                             "only 63 CPUs in NUMA mode supported.\n");
  847:                     }
  848:                     value = (2ULL << endvalue) - (1ULL << value);
  849:                 } else {
  850:                     value = 1ULL << value;
  851:                 }
  852:             }
  853:             node_cpumask[nodenr] = value;
  854:         }
  855:         nb_numa_nodes++;
  856:     }
  857:     return;
  858: }
  859: 
  860: static void smp_parse(const char *optarg)
  861: {
  862:     int smp, sockets = 0, threads = 0, cores = 0;
  863:     char *endptr;
  864:     char option[128];
  865: 
  866:     smp = strtoul(optarg, &endptr, 10);
  867:     if (endptr != optarg) {
  868:         if (*endptr == ',') {
  869:             endptr++;
  870:         }
  871:     }
  872:     if (get_param_value(option, 128, "sockets", endptr) != 0)
  873:         sockets = strtoull(option, NULL, 10);
  874:     if (get_param_value(option, 128, "cores", endptr) != 0)
  875:         cores = strtoull(option, NULL, 10);
  876:     if (get_param_value(option, 128, "threads", endptr) != 0)
  877:         threads = strtoull(option, NULL, 10);
  878:     if (get_param_value(option, 128, "maxcpus", endptr) != 0)
  879:         max_cpus = strtoull(option, NULL, 10);
  880: 
  881:     /* compute missing values, prefer sockets over cores over threads */
  882:     if (smp == 0 || sockets == 0) {
  883:         sockets = sockets > 0 ? sockets : 1;
  884:         cores = cores > 0 ? cores : 1;
  885:         threads = threads > 0 ? threads : 1;
  886:         if (smp == 0) {
  887:             smp = cores * threads * sockets;
  888:         }
  889:     } else {
  890:         if (cores == 0) {
  891:             threads = threads > 0 ? threads : 1;
  892:             cores = smp / (sockets * threads);
  893:         } else {
  894:             threads = smp / (cores * sockets);
  895:         }
  896:     }
  897:     smp_cpus = smp;
  898:     smp_cores = cores > 0 ? cores : 1;
  899:     smp_threads = threads > 0 ? threads : 1;
  900:     if (max_cpus == 0)
  901:         max_cpus = smp_cpus;
  902: }
  903: 
  904: /***********************************************************/
  905: /* USB devices */
  906: 
  907: static int usb_device_add(const char *devname)
  908: {
  909:     const char *p;
  910:     USBDevice *dev = NULL;
  911: 
  912:     if (!usb_enabled)
  913:         return -1;
  914: 
  915:     /* drivers with .usbdevice_name entry in USBDeviceInfo */
  916:     dev = usbdevice_create(devname);
  917:     if (dev)
  918:         goto done;
  919: 
  920:     /* the other ones */
  921:     if (strstart(devname, "host:", &p)) {
  922:         dev = usb_host_device_open(p);
  923:     } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
  924:         dev = usb_bt_init(devname[2] ? hci_init(p) :
  925:                         bt_new_hci(qemu_find_bt_vlan(0)));
  926:     } else {
  927:         return -1;
  928:     }
  929:     if (!dev)
  930:         return -1;
  931: 
  932: done:
  933:     return 0;
  934: }
  935: 
  936: static int usb_device_del(const char *devname)
  937: {
  938:     int bus_num, addr;
  939:     const char *p;
  940: 
  941:     if (strstart(devname, "host:", &p))
  942:         return usb_host_device_close(p);
  943: 
  944:     if (!usb_enabled)
  945:         return -1;
  946: 
  947:     p = strchr(devname, '.');
  948:     if (!p)
  949:         return -1;
  950:     bus_num = strtoul(devname, NULL, 0);
  951:     addr = strtoul(p + 1, NULL, 0);
  952: 
  953:     return usb_device_delete_addr(bus_num, addr);
  954: }
  955: 
  956: static int usb_parse(const char *cmdline)
  957: {
  958:     int r;
  959:     r = usb_device_add(cmdline);
  960:     if (r < 0) {
  961:         fprintf(stderr, "qemu: could not add USB device '%s'\n", cmdline);
  962:     }
  963:     return r;
  964: }
  965: 
  966: void do_usb_add(Monitor *mon, const QDict *qdict)
  967: {
  968:     const char *devname = qdict_get_str(qdict, "devname");
  969:     if (usb_device_add(devname) < 0) {
  970:         error_report("could not add USB device '%s'", devname);
  971:     }
  972: }
  973: 
  974: void do_usb_del(Monitor *mon, const QDict *qdict)
  975: {
  976:     const char *devname = qdict_get_str(qdict, "devname");
  977:     if (usb_device_del(devname) < 0) {
  978:         error_report("could not delete USB device '%s'", devname);
  979:     }
  980: }
  981: 
  982: /***********************************************************/
  983: /* PCMCIA/Cardbus */
  984: 
  985: static struct pcmcia_socket_entry_s {
  986:     PCMCIASocket *socket;
  987:     struct pcmcia_socket_entry_s *next;
  988: } *pcmcia_sockets = 0;
  989: 
  990: void pcmcia_socket_register(PCMCIASocket *socket)
  991: {
  992:     struct pcmcia_socket_entry_s *entry;
  993: 
  994:     entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
  995:     entry->socket = socket;
  996:     entry->next = pcmcia_sockets;
  997:     pcmcia_sockets = entry;
  998: }
  999: 
 1000: void pcmcia_socket_unregister(PCMCIASocket *socket)
 1001: {
 1002:     struct pcmcia_socket_entry_s *entry, **ptr;
 1003: 
 1004:     ptr = &pcmcia_sockets;
 1005:     for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
 1006:         if (entry->socket == socket) {
 1007:             *ptr = entry->next;
 1008:             qemu_free(entry);
 1009:         }
 1010: }
 1011: 
 1012: void pcmcia_info(Monitor *mon)
 1013: {
 1014:     struct pcmcia_socket_entry_s *iter;
 1015: 
 1016:     if (!pcmcia_sockets)
 1017:         monitor_printf(mon, "No PCMCIA sockets\n");
 1018: 
 1019:     for (iter = pcmcia_sockets; iter; iter = iter->next)
 1020:         monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
 1021:                        iter->socket->attached ? iter->socket->card_string :
 1022:                        "Empty");
 1023: }
 1024: 
 1025: /***********************************************************/
 1026: /* I/O handling */
 1027: 
 1028: typedef struct IOHandlerRecord {
 1029:     int fd;
 1030:     IOCanReadHandler *fd_read_poll;
 1031:     IOHandler *fd_read;
 1032:     IOHandler *fd_write;
 1033:     int deleted;
 1034:     void *opaque;
 1035:     /* temporary data */
 1036:     struct pollfd *ufd;
 1037:     QLIST_ENTRY(IOHandlerRecord) next;
 1038: } IOHandlerRecord;
 1039: 
 1040: static QLIST_HEAD(, IOHandlerRecord) io_handlers =
 1041:     QLIST_HEAD_INITIALIZER(io_handlers);
 1042: 
 1043: 
 1044: /* XXX: fd_read_poll should be suppressed, but an API change is
 1045:    necessary in the character devices to suppress fd_can_read(). */
 1046: int qemu_set_fd_handler2(int fd,
 1047:                          IOCanReadHandler *fd_read_poll,
 1048:                          IOHandler *fd_read,
 1049:                          IOHandler *fd_write,
 1050:                          void *opaque)
 1051: {
 1052:     IOHandlerRecord *ioh;
 1053: 
 1054:     if (!fd_read && !fd_write) {
 1055:         QLIST_FOREACH(ioh, &io_handlers, next) {
 1056:             if (ioh->fd == fd) {
 1057:                 ioh->deleted = 1;
 1058:                 break;
 1059:             }
 1060:         }
 1061:     } else {
 1062:         QLIST_FOREACH(ioh, &io_handlers, next) {
 1063:             if (ioh->fd == fd)
 1064:                 goto found;
 1065:         }
 1066:         ioh = qemu_mallocz(sizeof(IOHandlerRecord));
 1067:         QLIST_INSERT_HEAD(&io_handlers, ioh, next);
 1068:     found:
 1069:         ioh->fd = fd;
 1070:         ioh->fd_read_poll = fd_read_poll;
 1071:         ioh->fd_read = fd_read;
 1072:         ioh->fd_write = fd_write;
 1073:         ioh->opaque = opaque;
 1074:         ioh->deleted = 0;
 1075:     }
 1076:     return 0;
 1077: }
 1078: 
 1079: int qemu_set_fd_handler(int fd,
 1080:                         IOHandler *fd_read,
 1081:                         IOHandler *fd_write,
 1082:                         void *opaque)
 1083: {
 1084:     return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
 1085: }
 1086: 
 1087: /***********************************************************/
 1088: /* machine registration */
 1089: 
 1090: static QEMUMachine *first_machine = NULL;
 1091: QEMUMachine *current_machine = NULL;
 1092: 
 1093: int qemu_register_machine(QEMUMachine *m)
 1094: {
 1095:     QEMUMachine **pm;
 1096:     pm = &first_machine;
 1097:     while (*pm != NULL)
 1098:         pm = &(*pm)->next;
 1099:     m->next = NULL;
 1100:     *pm = m;
 1101:     return 0;
 1102: }
 1103: 
 1104: static QEMUMachine *find_machine(const char *name)
 1105: {
 1106:     QEMUMachine *m;
 1107: 
 1108:     for(m = first_machine; m != NULL; m = m->next) {
 1109:         if (!strcmp(m->name, name))
 1110:             return m;
 1111:         if (m->alias && !strcmp(m->alias, name))
 1112:             return m;
 1113:     }
 1114:     return NULL;
 1115: }
 1116: 
 1117: static QEMUMachine *find_default_machine(void)
 1118: {
 1119:     QEMUMachine *m;
 1120: 
 1121:     for(m = first_machine; m != NULL; m = m->next) {
 1122:         if (m->is_default) {
 1123:             return m;
 1124:         }
 1125:     }
 1126:     return NULL;
 1127: }
 1128: 
 1129: /***********************************************************/
 1130: /* main execution loop */
 1131: 
 1132: static void gui_update(void *opaque)
 1133: {
 1134:     uint64_t interval = GUI_REFRESH_INTERVAL;
 1135:     DisplayState *ds = opaque;
 1136:     DisplayChangeListener *dcl = ds->listeners;
 1137: 
 1138:     qemu_flush_coalesced_mmio_buffer();
 1139:     dpy_refresh(ds);
 1140: 
 1141:     while (dcl != NULL) {
 1142:         if (dcl->gui_timer_interval &&
 1143:             dcl->gui_timer_interval < interval)
 1144:             interval = dcl->gui_timer_interval;
 1145:         dcl = dcl->next;
 1146:     }
 1147:     qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
 1148: }
 1149: 
 1150: static void nographic_update(void *opaque)
 1151: {
 1152:     uint64_t interval = GUI_REFRESH_INTERVAL;
 1153: 
 1154:     qemu_flush_coalesced_mmio_buffer();
 1155:     qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
 1156: }
 1157: 
 1158: struct vm_change_state_entry {
 1159:     VMChangeStateHandler *cb;
 1160:     void *opaque;
 1161:     QLIST_ENTRY (vm_change_state_entry) entries;
 1162: };
 1163: 
 1164: static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
 1165: 
 1166: VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
 1167:                                                      void *opaque)
 1168: {
 1169:     VMChangeStateEntry *e;
 1170: 
 1171:     e = qemu_mallocz(sizeof (*e));
 1172: 
 1173:     e->cb = cb;
 1174:     e->opaque = opaque;
 1175:     QLIST_INSERT_HEAD(&vm_change_state_head, e, entries);
 1176:     return e;
 1177: }
 1178: 
 1179: void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
 1180: {
 1181:     QLIST_REMOVE (e, entries);
 1182:     qemu_free (e);
 1183: }
 1184: 
 1185: void vm_state_notify(int running, int reason)
 1186: {
 1187:     VMChangeStateEntry *e;
 1188: 
 1189:     trace_vm_state_notify(running, reason);
 1190: 
 1191:     for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
 1192:         e->cb(e->opaque, running, reason);
 1193:     }
 1194: }
 1195: 
 1196: void vm_start(void)
 1197: {
 1198:     if (!vm_running) {
 1199:         cpu_enable_ticks();
 1200:         vm_running = 1;
 1201:         vm_state_notify(1, 0);
 1202:         resume_all_vcpus();
 1203:         monitor_protocol_event(QEVENT_RESUME, NULL);
 1204:     }
 1205: }
 1206: 
 1207: /* reset/shutdown handler */
 1208: 
 1209: typedef struct QEMUResetEntry {
 1210:     QTAILQ_ENTRY(QEMUResetEntry) entry;
 1211:     QEMUResetHandler *func;
 1212:     void *opaque;
 1213: } QEMUResetEntry;
 1214: 
 1215: static QTAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers =
 1216:     QTAILQ_HEAD_INITIALIZER(reset_handlers);
 1217: static int reset_requested;
 1218: static int shutdown_requested;
 1219: static int powerdown_requested;
 1220: int debug_requested;
 1221: int vmstop_requested;
 1222: 
 1223: int qemu_shutdown_requested(void)
 1224: {
 1225:     int r = shutdown_requested;
 1226:     shutdown_requested = 0;
 1227:     return r;
 1228: }
 1229: 
 1230: int qemu_reset_requested(void)
 1231: {
 1232:     int r = reset_requested;
 1233:     reset_requested = 0;
 1234:     return r;
 1235: }
 1236: 
 1237: int qemu_powerdown_requested(void)
 1238: {
 1239:     int r = powerdown_requested;
 1240:     powerdown_requested = 0;
 1241:     return r;
 1242: }
 1243: 
 1244: static int qemu_debug_requested(void)
 1245: {
 1246:     int r = debug_requested;
 1247:     debug_requested = 0;
 1248:     return r;
 1249: }
 1250: 
 1251: static int qemu_vmstop_requested(void)
 1252: {
 1253:     int r = vmstop_requested;
 1254:     vmstop_requested = 0;
 1255:     return r;
 1256: }
 1257: 
 1258: void qemu_register_reset(QEMUResetHandler *func, void *opaque)
 1259: {
 1260:     QEMUResetEntry *re = qemu_mallocz(sizeof(QEMUResetEntry));
 1261: 
 1262:     re->func = func;
 1263:     re->opaque = opaque;
 1264:     QTAILQ_INSERT_TAIL(&reset_handlers, re, entry);
 1265: }
 1266: 
 1267: void qemu_unregister_reset(QEMUResetHandler *func, void *opaque)
 1268: {
 1269:     QEMUResetEntry *re;
 1270: 
 1271:     QTAILQ_FOREACH(re, &reset_handlers, entry) {
 1272:         if (re->func == func && re->opaque == opaque) {
 1273:             QTAILQ_REMOVE(&reset_handlers, re, entry);
 1274:             qemu_free(re);
 1275:             return;
 1276:         }
 1277:     }
 1278: }
 1279: 
 1280: void qemu_system_reset(void)
 1281: {
 1282:     QEMUResetEntry *re, *nre;
 1283: 
 1284:     /* reset all devices */
 1285:     QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) {
 1286:         re->func(re->opaque);
 1287:     }
 1288:     monitor_protocol_event(QEVENT_RESET, NULL);
 1289:     cpu_synchronize_all_post_reset();
 1290: }
 1291: 
 1292: void qemu_system_reset_request(void)
 1293: {
 1294:     if (no_reboot) {
 1295:         shutdown_requested = 1;
 1296:     } else {
 1297:         reset_requested = 1;
 1298:     }
 1299:     qemu_notify_event();
 1300: }
 1301: 
 1302: void qemu_system_shutdown_request(void)
 1303: {
 1304:     shutdown_requested = 1;
 1305:     qemu_notify_event();
 1306: }
 1307: 
 1308: void qemu_system_powerdown_request(void)
 1309: {
 1310:     powerdown_requested = 1;
 1311:     qemu_notify_event();
 1312: }
 1313: 
 1314: void main_loop_wait(int nonblocking)
 1315: {
 1316:     IOHandlerRecord *ioh;
 1317:     fd_set rfds, wfds, xfds;
 1318:     int ret, nfds;
 1319:     struct timeval tv;
 1320:     int timeout;
 1321: 
 1322:     if (nonblocking)
 1323:         timeout = 0;
 1324:     else {
 1325:         timeout = qemu_calculate_timeout();
 1326:         qemu_bh_update_timeout(&timeout);
 1327:     }
 1328: 
 1329:     os_host_main_loop_wait(&timeout);
 1330: 
 1331:     /* poll any events */
 1332:     /* XXX: separate device handlers from system ones */
 1333:     nfds = -1;
 1334:     FD_ZERO(&rfds);
 1335:     FD_ZERO(&wfds);
 1336:     FD_ZERO(&xfds);
 1337:     QLIST_FOREACH(ioh, &io_handlers, next) {
 1338:         if (ioh->deleted)
 1339:             continue;
 1340:         if (ioh->fd_read &&
 1341:             (!ioh->fd_read_poll ||
 1342:              ioh->fd_read_poll(ioh->opaque) != 0)) {
 1343:             FD_SET(ioh->fd, &rfds);
 1344:             if (ioh->fd > nfds)
 1345:                 nfds = ioh->fd;
 1346:         }
 1347:         if (ioh->fd_write) {
 1348:             FD_SET(ioh->fd, &wfds);
 1349:             if (ioh->fd > nfds)
 1350:                 nfds = ioh->fd;
 1351:         }
 1352:     }
 1353: 
 1354:     tv.tv_sec = timeout / 1000;
 1355:     tv.tv_usec = (timeout % 1000) * 1000;
 1356: 
 1357:     slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
 1358: 
 1359:     qemu_mutex_unlock_iothread();
 1360:     ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
 1361:     qemu_mutex_lock_iothread();
 1362:     if (ret > 0) {
 1363:         IOHandlerRecord *pioh;
 1364: 
 1365:         QLIST_FOREACH_SAFE(ioh, &io_handlers, next, pioh) {
 1366:             if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
 1367:                 ioh->fd_read(ioh->opaque);
 1368:             }
 1369:             if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
 1370:                 ioh->fd_write(ioh->opaque);
 1371:             }
 1372: 
 1373:             /* Do this last in case read/write handlers marked it for deletion */
 1374:             if (ioh->deleted) {
 1375:                 QLIST_REMOVE(ioh, next);
 1376:                 qemu_free(ioh);
 1377:             }
 1378:         }
 1379:     }
 1380: 
 1381:     slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));
 1382: 
 1383:     qemu_run_all_timers();
 1384: 
 1385:     /* Check bottom-halves last in case any of the earlier events triggered
 1386:        them.  */
 1387:     qemu_bh_poll();
 1388: 
 1389: }
 1390: 
 1391: static int vm_can_run(void)
 1392: {
 1393:     if (powerdown_requested)
 1394:         return 0;
 1395:     if (reset_requested)
 1396:         return 0;
 1397:     if (shutdown_requested)
 1398:         return 0;
 1399:     if (debug_requested)
 1400:         return 0;
 1401:     return 1;
 1402: }
 1403: 
 1404: qemu_irq qemu_system_powerdown;
 1405: 
 1406: static void main_loop(void)
 1407: {
 1408:     int r;
 1409: 
 1410:     qemu_main_loop_start();
 1411: 
 1412:     for (;;) {
 1413:         do {
 1414:             bool nonblocking = false;
 1415: #ifdef CONFIG_PROFILER
 1416:             int64_t ti;
 1417: #endif
 1418: #ifndef CONFIG_IOTHREAD
 1419:             nonblocking = cpu_exec_all();
 1420: #endif
 1421: #ifdef CONFIG_PROFILER
 1422:             ti = profile_getclock();
 1423: #endif
 1424:             main_loop_wait(nonblocking);
 1425: #ifdef CONFIG_PROFILER
 1426:             dev_time += profile_getclock() - ti;
 1427: #endif
 1428:         } while (vm_can_run());
 1429: 
 1430:         if ((r = qemu_debug_requested())) {
 1431:             vm_stop(r);
 1432:         }
 1433:         if (qemu_shutdown_requested()) {
 1434:             monitor_protocol_event(QEVENT_SHUTDOWN, NULL);
 1435:             if (no_shutdown) {
 1436:                 vm_stop(0);
 1437:                 no_shutdown = 0;
 1438:             } else
 1439:                 break;
 1440:         }
 1441:         if (qemu_reset_requested()) {
 1442:             pause_all_vcpus();
 1443:             qemu_system_reset();
 1444:             resume_all_vcpus();
 1445:         }
 1446:         if (qemu_powerdown_requested()) {
 1447:             monitor_protocol_event(QEVENT_POWERDOWN, NULL);
 1448:             qemu_irq_raise(qemu_system_powerdown);
 1449:         }
 1450:         if ((r = qemu_vmstop_requested())) {
 1451:             vm_stop(r);
 1452:         }
 1453:     }
 1454:     bdrv_close_all();
 1455:     pause_all_vcpus();
 1456: }
 1457: 
 1458: static void version(void)
 1459: {
 1460:     printf("QEMU emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
 1461: }
 1462: 
 1463: static void help(int exitcode)
 1464: {
 1465:     const char *options_help =
 1466: #define DEF(option, opt_arg, opt_enum, opt_help, arch_mask)     \
 1467:         opt_help
 1468: #define DEFHEADING(text) stringify(text) "\n"
 1469: #include "qemu-options.def"
 1470: #undef DEF
 1471: #undef DEFHEADING
 1472: #undef GEN_DOCS
 1473:         ;
 1474:     version();
 1475:     printf("usage: %s [options] [disk_image]\n"
 1476:            "\n"
 1477:            "'disk_image' is a raw hard disk image for IDE hard disk 0\n"
 1478:            "\n"
 1479:            "%s\n"
 1480:            "During emulation, the following keys are useful:\n"
 1481:            "ctrl-alt-f      toggle full screen\n"
 1482:            "ctrl-alt-n      switch to virtual console 'n'\n"
 1483:            "ctrl-alt        toggle mouse and keyboard grab\n"
 1484:            "\n"
 1485:            "When using -nographic, press 'ctrl-a h' to get some help.\n",
 1486:            "qemu",
 1487:            options_help);
 1488:     exit(exitcode);
 1489: }
 1490: 
 1491: #define HAS_ARG 0x0001
 1492: 
 1493: typedef struct QEMUOption {
 1494:     const char *name;
 1495:     int flags;
 1496:     int index;
 1497:     uint32_t arch_mask;
 1498: } QEMUOption;
 1499: 
 1500: static const QEMUOption qemu_options[] = {
 1501:     { "h", 0, QEMU_OPTION_h, QEMU_ARCH_ALL },
 1502: #define DEF(option, opt_arg, opt_enum, opt_help, arch_mask)     \
 1503:     { option, opt_arg, opt_enum, arch_mask },
 1504: #define DEFHEADING(text)
 1505: #include "qemu-options.def"
 1506: #undef DEF
 1507: #undef DEFHEADING
 1508: #undef GEN_DOCS
 1509:     { NULL },
 1510: };
 1511: static void select_vgahw (const char *p)
 1512: {
 1513:     const char *opts;
 1514: 
 1515:     default_vga = 0;
 1516:     vga_interface_type = VGA_NONE;
 1517:     if (strstart(p, "std", &opts)) {
 1518:         vga_interface_type = VGA_STD;
 1519:     } else if (strstart(p, "cirrus", &opts)) {
 1520:         vga_interface_type = VGA_CIRRUS;
 1521:     } else if (strstart(p, "vmware", &opts)) {
 1522:         vga_interface_type = VGA_VMWARE;
 1523:     } else if (strstart(p, "xenfb", &opts)) {
 1524:         vga_interface_type = VGA_XENFB;
 1525:     } else if (strstart(p, "qxl", &opts)) {
 1526:         vga_interface_type = VGA_QXL;
 1527:     } else if (!strstart(p, "none", &opts)) {
 1528:     invalid_vga:
 1529:         fprintf(stderr, "Unknown vga type: %s\n", p);
 1530:         exit(1);
 1531:     }
 1532:     while (*opts) {
 1533:         const char *nextopt;
 1534: 
 1535:         if (strstart(opts, ",retrace=", &nextopt)) {
 1536:             opts = nextopt;
 1537:             if (strstart(opts, "dumb", &nextopt))
 1538:                 vga_retrace_method = VGA_RETRACE_DUMB;
 1539:             else if (strstart(opts, "precise", &nextopt))
 1540:                 vga_retrace_method = VGA_RETRACE_PRECISE;
 1541:             else goto invalid_vga;
 1542:         } else goto invalid_vga;
 1543:         opts = nextopt;
 1544:     }
 1545: }
 1546: 
 1547: static int balloon_parse(const char *arg)
 1548: {
 1549:     QemuOpts *opts;
 1550: 
 1551:     if (strcmp(arg, "none") == 0) {
 1552:         return 0;
 1553:     }
 1554: 
 1555:     if (!strncmp(arg, "virtio", 6)) {
 1556:         if (arg[6] == ',') {
 1557:             /* have params -> parse them */
 1558:             opts = qemu_opts_parse(qemu_find_opts("device"), arg+7, 0);
 1559:             if (!opts)
 1560:                 return  -1;
 1561:         } else {
 1562:             /* create empty opts */
 1563:             opts = qemu_opts_create(qemu_find_opts("device"), NULL, 0);
 1564:         }
 1565:         qemu_opt_set(opts, "driver", "virtio-balloon-pci");
 1566:         return 0;
 1567:     }
 1568: 
 1569:     return -1;
 1570: }
 1571: 
 1572: char *qemu_find_file(int type, const char *name)
 1573: {
 1574:     int len;
 1575:     const char *subdir;
 1576:     char *buf;
 1577: 
 1578:     /* If name contains path separators then try it as a straight path.  */
 1579:     if ((strchr(name, '/') || strchr(name, '\\'))
 1580:         && access(name, R_OK) == 0) {
 1581:         return qemu_strdup(name);
 1582:     }
 1583:     switch (type) {
 1584:     case QEMU_FILE_TYPE_BIOS:
 1585:         subdir = "";
 1586:         break;
 1587:     case QEMU_FILE_TYPE_KEYMAP:
 1588:         subdir = "keymaps/";
 1589:         break;
 1590:     default:
 1591:         abort();
 1592:     }
 1593:     len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;
 1594:     buf = qemu_mallocz(len);
 1595:     snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
 1596:     if (access(buf, R_OK)) {
 1597:         qemu_free(buf);
 1598:         return NULL;
 1599:     }
 1600:     return buf;
 1601: }
 1602: 
 1603: static int device_help_func(QemuOpts *opts, void *opaque)
 1604: {
 1605:     return qdev_device_help(opts);
 1606: }
 1607: 
 1608: static int device_init_func(QemuOpts *opts, void *opaque)
 1609: {
 1610:     DeviceState *dev;
 1611: 
 1612:     dev = qdev_device_add(opts);
 1613:     if (!dev)
 1614:         return -1;
 1615:     return 0;
 1616: }
 1617: 
 1618: static int chardev_init_func(QemuOpts *opts, void *opaque)
 1619: {
 1620:     CharDriverState *chr;
 1621: 
 1622:     chr = qemu_chr_open_opts(opts, NULL);
 1623:     if (!chr)
 1624:         return -1;
 1625:     return 0;
 1626: }
 1627: 
 1628: #ifdef CONFIG_VIRTFS
 1629: static int fsdev_init_func(QemuOpts *opts, void *opaque)
 1630: {
 1631:     int ret;
 1632:     ret = qemu_fsdev_add(opts);
 1633: 
 1634:     return ret;
 1635: }
 1636: #endif
 1637: 
 1638: static int mon_init_func(QemuOpts *opts, void *opaque)
 1639: {
 1640:     CharDriverState *chr;
 1641:     const char *chardev;
 1642:     const char *mode;
 1643:     int flags;
 1644: 
 1645:     mode = qemu_opt_get(opts, "mode");
 1646:     if (mode == NULL) {
 1647:         mode = "readline";
 1648:     }
 1649:     if (strcmp(mode, "readline") == 0) {
 1650:         flags = MONITOR_USE_READLINE;
 1651:     } else if (strcmp(mode, "control") == 0) {
 1652:         flags = MONITOR_USE_CONTROL;
 1653:     } else {
 1654:         fprintf(stderr, "unknown monitor mode \"%s\"\n", mode);
 1655:         exit(1);
 1656:     }
 1657: 
 1658:     if (qemu_opt_get_bool(opts, "pretty", 0))
 1659:         flags |= MONITOR_USE_PRETTY;
 1660: 
 1661:     if (qemu_opt_get_bool(opts, "default", 0))
 1662:         flags |= MONITOR_IS_DEFAULT;
 1663: 
 1664:     chardev = qemu_opt_get(opts, "chardev");
 1665:     chr = qemu_chr_find(chardev);
 1666:     if (chr == NULL) {
 1667:         fprintf(stderr, "chardev \"%s\" not found\n", chardev);
 1668:         exit(1);
 1669:     }
 1670: 
 1671:     monitor_init(chr, flags);
 1672:     return 0;
 1673: }
 1674: 
 1675: static void monitor_parse(const char *optarg, const char *mode)
 1676: {
 1677:     static int monitor_device_index = 0;
 1678:     QemuOpts *opts;
 1679:     const char *p;
 1680:     char label[32];
 1681:     int def = 0;
 1682: 
 1683:     if (strstart(optarg, "chardev:", &p)) {
 1684:         snprintf(label, sizeof(label), "%s", p);
 1685:     } else {
 1686:         snprintf(label, sizeof(label), "compat_monitor%d",
 1687:                  monitor_device_index);
 1688:         if (monitor_device_index == 0) {
 1689:             def = 1;
 1690:         }
 1691:         opts = qemu_chr_parse_compat(label, optarg);
 1692:         if (!opts) {
 1693:             fprintf(stderr, "parse error: %s\n", optarg);
 1694:             exit(1);
 1695:         }
 1696:     }
 1697: 
 1698:     opts = qemu_opts_create(qemu_find_opts("mon"), label, 1);
 1699:     if (!opts) {
 1700:         fprintf(stderr, "duplicate chardev: %s\n", label);
 1701:         exit(1);
 1702:     }
 1703:     qemu_opt_set(opts, "mode", mode);
 1704:     qemu_opt_set(opts, "chardev", label);
 1705:     if (def)
 1706:         qemu_opt_set(opts, "default", "on");
 1707:     monitor_device_index++;
 1708: }
 1709: 
 1710: struct device_config {
 1711:     enum {
 1712:         DEV_USB,       /* -usbdevice     */
 1713:         DEV_BT,        /* -bt            */
 1714:         DEV_SERIAL,    /* -serial        */
 1715:         DEV_PARALLEL,  /* -parallel      */
 1716:         DEV_VIRTCON,   /* -virtioconsole */
 1717:         DEV_DEBUGCON,  /* -debugcon */
 1718:     } type;
 1719:     const char *cmdline;
 1720:     QTAILQ_ENTRY(device_config) next;
 1721: };
 1722: QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs);
 1723: 
 1724: static void add_device_config(int type, const char *cmdline)
 1725: {
 1726:     struct device_config *conf;
 1727: 
 1728:     conf = qemu_mallocz(sizeof(*conf));
 1729:     conf->type = type;
 1730:     conf->cmdline = cmdline;
 1731:     QTAILQ_INSERT_TAIL(&device_configs, conf, next);
 1732: }
 1733: 
 1734: static int foreach_device_config(int type, int (*func)(const char *cmdline))
 1735: {
 1736:     struct device_config *conf;
 1737:     int rc;
 1738: 
 1739:     QTAILQ_FOREACH(conf, &device_configs, next) {
 1740:         if (conf->type != type)
 1741:             continue;
 1742:         rc = func(conf->cmdline);
 1743:         if (0 != rc)
 1744:             return rc;
 1745:     }
 1746:     return 0;
 1747: }
 1748: 
 1749: static int serial_parse(const char *devname)
 1750: {
 1751:     static int index = 0;
 1752:     char label[32];
 1753: 
 1754:     if (strcmp(devname, "none") == 0)
 1755:         return 0;
 1756:     if (index == MAX_SERIAL_PORTS) {
 1757:         fprintf(stderr, "qemu: too many serial ports\n");
 1758:         exit(1);
 1759:     }
 1760:     snprintf(label, sizeof(label), "serial%d", index);
 1761:     serial_hds[index] = qemu_chr_open(label, devname, NULL);
 1762:     if (!serial_hds[index]) {
 1763:         fprintf(stderr, "qemu: could not open serial device '%s': %s\n",
 1764:                 devname, strerror(errno));
 1765:         return -1;
 1766:     }
 1767:     index++;
 1768:     return 0;
 1769: }
 1770: 
 1771: static int parallel_parse(const char *devname)
 1772: {
 1773:     static int index = 0;
 1774:     char label[32];
 1775: 
 1776:     if (strcmp(devname, "none") == 0)
 1777:         return 0;
 1778:     if (index == MAX_PARALLEL_PORTS) {
 1779:         fprintf(stderr, "qemu: too many parallel ports\n");
 1780:         exit(1);
 1781:     }
 1782:     snprintf(label, sizeof(label), "parallel%d", index);
 1783:     parallel_hds[index] = qemu_chr_open(label, devname, NULL);
 1784:     if (!parallel_hds[index]) {
 1785:         fprintf(stderr, "qemu: could not open parallel device '%s': %s\n",
 1786:                 devname, strerror(errno));
 1787:         return -1;
 1788:     }
 1789:     index++;
 1790:     return 0;
 1791: }
 1792: 
 1793: static int virtcon_parse(const char *devname)
 1794: {
 1795:     QemuOptsList *device = qemu_find_opts("device");
 1796:     static int index = 0;
 1797:     char label[32];
 1798:     QemuOpts *bus_opts, *dev_opts;
 1799: 
 1800:     if (strcmp(devname, "none") == 0)
 1801:         return 0;
 1802:     if (index == MAX_VIRTIO_CONSOLES) {
 1803:         fprintf(stderr, "qemu: too many virtio consoles\n");
 1804:         exit(1);
 1805:     }
 1806: 
 1807:     bus_opts = qemu_opts_create(device, NULL, 0);
 1808:     qemu_opt_set(bus_opts, "driver", "virtio-serial");
 1809: 
 1810:     dev_opts = qemu_opts_create(device, NULL, 0);
 1811:     qemu_opt_set(dev_opts, "driver", "virtconsole");
 1812: 
 1813:     snprintf(label, sizeof(label), "virtcon%d", index);
 1814:     virtcon_hds[index] = qemu_chr_open(label, devname, NULL);
 1815:     if (!virtcon_hds[index]) {
 1816:         fprintf(stderr, "qemu: could not open virtio console '%s': %s\n",
 1817:                 devname, strerror(errno));
 1818:         return -1;
 1819:     }
 1820:     qemu_opt_set(dev_opts, "chardev", label);
 1821: 
 1822:     index++;
 1823:     return 0;
 1824: }
 1825: 
 1826: static int debugcon_parse(const char *devname)
 1827: {   
 1828:     QemuOpts *opts;
 1829: 
 1830:     if (!qemu_chr_open("debugcon", devname, NULL)) {
 1831:         exit(1);
 1832:     }
 1833:     opts = qemu_opts_create(qemu_find_opts("device"), "debugcon", 1);
 1834:     if (!opts) {
 1835:         fprintf(stderr, "qemu: already have a debugcon device\n");
 1836:         exit(1);
 1837:     }
 1838:     qemu_opt_set(opts, "driver", "isa-debugcon");
 1839:     qemu_opt_set(opts, "chardev", "debugcon");
 1840:     return 0;
 1841: }
 1842: 
 1843: void qemu_add_exit_notifier(Notifier *notify)
 1844: {
 1845:     notifier_list_add(&exit_notifiers, notify);
 1846: }
 1847: 
 1848: void qemu_remove_exit_notifier(Notifier *notify)
 1849: {
 1850:     notifier_list_remove(&exit_notifiers, notify);
 1851: }
 1852: 
 1853: static void qemu_run_exit_notifiers(void)
 1854: {
 1855:     notifier_list_notify(&exit_notifiers);
 1856: }
 1857: 
 1858: void qemu_add_machine_init_done_notifier(Notifier *notify)
 1859: {
 1860:     notifier_list_add(&machine_init_done_notifiers, notify);
 1861: }
 1862: 
 1863: static void qemu_run_machine_init_done_notifiers(void)
 1864: {
 1865:     notifier_list_notify(&machine_init_done_notifiers);
 1866: }
 1867: 
 1868: static const QEMUOption *lookup_opt(int argc, char **argv,
 1869:                                     const char **poptarg, int *poptind)
 1870: {
 1871:     const QEMUOption *popt;
 1872:     int optind = *poptind;
 1873:     char *r = argv[optind];
 1874:     const char *optarg;
 1875: 
 1876:     loc_set_cmdline(argv, optind, 1);
 1877:     optind++;
 1878:     /* Treat --foo the same as -foo.  */
 1879:     if (r[1] == '-')
 1880:         r++;
 1881:     popt = qemu_options;
 1882:     for(;;) {
 1883:         if (!popt->name) {
 1884:             error_report("invalid option");
 1885:             exit(1);
 1886:         }
 1887:         if (!strcmp(popt->name, r + 1))
 1888:             break;
 1889:         popt++;
 1890:     }
 1891:     if (popt->flags & HAS_ARG) {
 1892:         if (optind >= argc) {
 1893:             error_report("requires an argument");
 1894:             exit(1);
 1895:         }
 1896:         optarg = argv[optind++];
 1897:         loc_set_cmdline(argv, optind - 2, 2);
 1898:     } else {
 1899:         optarg = NULL;
 1900:     }
 1901: 
 1902:     *poptarg = optarg;
 1903:     *poptind = optind;
 1904: 
 1905:     return popt;
 1906: }
 1907: 
 1908: int main(int argc, char **argv, char **envp)
 1909: {
 1910:     const char *gdbstub_dev = NULL;
 1911:     int i;
 1912:     int snapshot, linux_boot;
 1913:     const char *icount_option = NULL;
 1914:     const char *initrd_filename;
 1915:     const char *kernel_filename, *kernel_cmdline;
 1916:     char boot_devices[33] = "cad"; /* default to HD->floppy->CD-ROM */
 1917:     DisplayState *ds;
 1918:     DisplayChangeListener *dcl;
 1919:     int cyls, heads, secs, translation;
 1920:     QemuOpts *hda_opts = NULL, *opts;
 1921:     QemuOptsList *olist;
 1922:     int optind;
 1923:     const char *optarg;
 1924:     const char *loadvm = NULL;
 1925:     QEMUMachine *machine;
 1926:     const char *cpu_model;
 1927:     int tb_size;
 1928:     const char *pid_file = NULL;
 1929:     const char *incoming = NULL;
 1930:     int show_vnc_port = 0;
 1931:     int defconfig = 1;
 1932: 
 1933: #ifdef CONFIG_SIMPLE_TRACE
 1934:     const char *trace_file = NULL;
 1935: #endif
 1936:     atexit(qemu_run_exit_notifiers);
 1937:     error_set_progname(argv[0]);
 1938: 
 1939:     init_clocks();
 1940: 
 1941:     qemu_cache_utils_init(envp);
 1942: 
 1943:     QLIST_INIT (&vm_change_state_head);
 1944:     os_setup_early_signal_handling();
 1945: 
 1946:     module_call_init(MODULE_INIT_MACHINE);
 1947:     machine = find_default_machine();
 1948:     cpu_model = NULL;
 1949:     initrd_filename = NULL;
 1950:     ram_size = 0;
 1951:     snapshot = 0;
 1952:     kernel_filename = NULL;
 1953:     kernel_cmdline = "";
 1954:     cyls = heads = secs = 0;
 1955:     translation = BIOS_ATA_TRANSLATION_AUTO;
 1956: 
 1957:     for (i = 0; i < MAX_NODES; i++) {
 1958:         node_mem[i] = 0;
 1959:         node_cpumask[i] = 0;
 1960:     }
 1961: 
 1962:     nb_numa_nodes = 0;
 1963:     nb_nics = 0;
 1964: 
 1965:     tb_size = 0;
 1966:     autostart= 1;
 1967: 
 1968:     /* first pass of option parsing */
 1969:     optind = 1;
 1970:     while (optind < argc) {
 1971:         if (argv[optind][0] != '-') {
 1972:             /* disk image */
 1973:             optind++;
 1974:             continue;
 1975:         } else {
 1976:             const QEMUOption *popt;
 1977: 
 1978:             popt = lookup_opt(argc, argv, &optarg, &optind);
 1979:             switch (popt->index) {
 1980:             case QEMU_OPTION_nodefconfig:
 1981:                 defconfig=0;
 1982:                 break;
 1983:             }
 1984:         }
 1985:     }
 1986: 
 1987:     if (defconfig) {
 1988:         int ret;
 1989: 
 1990:         ret = qemu_read_config_file(CONFIG_QEMU_CONFDIR "/qemu.conf");
 1991:         if (ret < 0 && ret != -ENOENT) {
 1992:             exit(1);
 1993:         }
 1994: 
 1995:         ret = qemu_read_config_file(arch_config_name);
 1996:         if (ret < 0 && ret != -ENOENT) {
 1997:             exit(1);
 1998:         }
 1999:     }
 2000:     cpudef_init();
 2001: 
 2002:     /* second pass of option parsing */
 2003:     optind = 1;
 2004:     for(;;) {
 2005:         if (optind >= argc)
 2006:             break;
 2007:         if (argv[optind][0] != '-') {
 2008: 	    hda_opts = drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS);
 2009:         } else {
 2010:             const QEMUOption *popt;
 2011: 
 2012:             popt = lookup_opt(argc, argv, &optarg, &optind);
 2013:             if (!(popt->arch_mask & arch_type)) {
 2014:                 printf("Option %s not supported for this target\n", popt->name);
 2015:                 exit(1);
 2016:             }
 2017:             switch(popt->index) {
 2018:             case QEMU_OPTION_M:
 2019:                 machine = find_machine(optarg);
 2020:                 if (!machine) {
 2021:                     QEMUMachine *m;
 2022:                     printf("Supported machines are:\n");
 2023:                     for(m = first_machine; m != NULL; m = m->next) {
 2024:                         if (m->alias)
 2025:                             printf("%-10s %s (alias of %s)\n",
 2026:                                    m->alias, m->desc, m->name);
 2027:                         printf("%-10s %s%s\n",
 2028:                                m->name, m->desc,
 2029:                                m->is_default ? " (default)" : "");
 2030:                     }
 2031:                     exit(*optarg != '?');
 2032:                 }
 2033:                 break;
 2034:             case QEMU_OPTION_cpu:
 2035:                 /* hw initialization will check this */
 2036:                 if (*optarg == '?') {
 2037:                     list_cpus(stdout, &fprintf, optarg);
 2038:                     exit(0);
 2039:                 } else {
 2040:                     cpu_model = optarg;
 2041:                 }
 2042:                 break;
 2043:             case QEMU_OPTION_initrd:
 2044:                 initrd_filename = optarg;
 2045:                 break;
 2046:             case QEMU_OPTION_hda:
 2047:                 {
 2048:                     char buf[256];
 2049:                     if (cyls == 0)
 2050:                         snprintf(buf, sizeof(buf), "%s", HD_OPTS);
 2051:                     else
 2052:                         snprintf(buf, sizeof(buf),
 2053:                                  "%s,cyls=%d,heads=%d,secs=%d%s",
 2054:                                  HD_OPTS , cyls, heads, secs,
 2055:                                  translation == BIOS_ATA_TRANSLATION_LBA ?
 2056:                                  ",trans=lba" :
 2057:                                  translation == BIOS_ATA_TRANSLATION_NONE ?
 2058:                                  ",trans=none" : "");
 2059:                     drive_add(IF_DEFAULT, 0, optarg, buf);
 2060:                     break;
 2061:                 }
 2062:             case QEMU_OPTION_hdb:
 2063:             case QEMU_OPTION_hdc:
 2064:             case QEMU_OPTION_hdd:
 2065:                 drive_add(IF_DEFAULT, popt->index - QEMU_OPTION_hda, optarg,
 2066:                           HD_OPTS);
 2067:                 break;
 2068:             case QEMU_OPTION_drive:
 2069:                 drive_def(optarg);
 2070: 	        break;
 2071:             case QEMU_OPTION_set:
 2072:                 if (qemu_set_option(optarg) != 0)
 2073:                     exit(1);
 2074: 	        break;
 2075:             case QEMU_OPTION_global:
 2076:                 if (qemu_global_option(optarg) != 0)
 2077:                     exit(1);
 2078: 	        break;
 2079:             case QEMU_OPTION_mtdblock:
 2080:                 drive_add(IF_MTD, -1, optarg, MTD_OPTS);
 2081:                 break;
 2082:             case QEMU_OPTION_sd:
 2083:                 drive_add(IF_SD, 0, optarg, SD_OPTS);
 2084:                 break;
 2085:             case QEMU_OPTION_pflash:
 2086:                 drive_add(IF_PFLASH, -1, optarg, PFLASH_OPTS);
 2087:                 break;
 2088:             case QEMU_OPTION_snapshot:
 2089:                 snapshot = 1;
 2090:                 break;
 2091:             case QEMU_OPTION_hdachs:
 2092:                 {
 2093:                     const char *p;
 2094:                     p = optarg;
 2095:                     cyls = strtol(p, (char **)&p, 0);
 2096:                     if (cyls < 1 || cyls > 16383)
 2097:                         goto chs_fail;
 2098:                     if (*p != ',')
 2099:                         goto chs_fail;
 2100:                     p++;
 2101:                     heads = strtol(p, (char **)&p, 0);
 2102:                     if (heads < 1 || heads > 16)
 2103:                         goto chs_fail;
 2104:                     if (*p != ',')
 2105:                         goto chs_fail;
 2106:                     p++;
 2107:                     secs = strtol(p, (char **)&p, 0);
 2108:                     if (secs < 1 || secs > 63)
 2109:                         goto chs_fail;
 2110:                     if (*p == ',') {
 2111:                         p++;
 2112:                         if (!strcmp(p, "none"))
 2113:                             translation = BIOS_ATA_TRANSLATION_NONE;
 2114:                         else if (!strcmp(p, "lba"))
 2115:                             translation = BIOS_ATA_TRANSLATION_LBA;
 2116:                         else if (!strcmp(p, "auto"))
 2117:                             translation = BIOS_ATA_TRANSLATION_AUTO;
 2118:                         else
 2119:                             goto chs_fail;
 2120:                     } else if (*p != '\0') {
 2121:                     chs_fail:
 2122:                         fprintf(stderr, "qemu: invalid physical CHS format\n");
 2123:                         exit(1);
 2124:                     }
 2125: 		    if (hda_opts != NULL) {
 2126:                         char num[16];
 2127:                         snprintf(num, sizeof(num), "%d", cyls);
 2128:                         qemu_opt_set(hda_opts, "cyls", num);
 2129:                         snprintf(num, sizeof(num), "%d", heads);
 2130:                         qemu_opt_set(hda_opts, "heads", num);
 2131:                         snprintf(num, sizeof(num), "%d", secs);
 2132:                         qemu_opt_set(hda_opts, "secs", num);
 2133:                         if (translation == BIOS_ATA_TRANSLATION_LBA)
 2134:                             qemu_opt_set(hda_opts, "trans", "lba");
 2135:                         if (translation == BIOS_ATA_TRANSLATION_NONE)
 2136:                             qemu_opt_set(hda_opts, "trans", "none");
 2137:                     }
 2138:                 }
 2139:                 break;
 2140:             case QEMU_OPTION_numa:
 2141:                 if (nb_numa_nodes >= MAX_NODES) {
 2142:                     fprintf(stderr, "qemu: too many NUMA nodes\n");
 2143:                     exit(1);
 2144:                 }
 2145:                 numa_add(optarg);
 2146:                 break;
 2147:             case QEMU_OPTION_nographic:
 2148:                 display_type = DT_NOGRAPHIC;
 2149:                 break;
 2150: #ifdef CONFIG_CURSES
 2151:             case QEMU_OPTION_curses:
 2152:                 display_type = DT_CURSES;
 2153:                 break;
 2154: #endif
 2155:             case QEMU_OPTION_portrait:
 2156:                 graphic_rotate = 1;
 2157:                 break;
 2158:             case QEMU_OPTION_kernel:
 2159:                 kernel_filename = optarg;
 2160:                 break;
 2161:             case QEMU_OPTION_append:
 2162:                 kernel_cmdline = optarg;
 2163:                 break;
 2164:             case QEMU_OPTION_cdrom:
 2165:                 drive_add(IF_DEFAULT, 2, optarg, CDROM_OPTS);
 2166:                 break;
 2167:             case QEMU_OPTION_boot:
 2168:                 {
 2169:                     static const char * const params[] = {
 2170:                         "order", "once", "menu", NULL
 2171:                     };
 2172:                     char buf[sizeof(boot_devices)];
 2173:                     char *standard_boot_devices;
 2174:                     int legacy = 0;
 2175: 
 2176:                     if (!strchr(optarg, '=')) {
 2177:                         legacy = 1;
 2178:                         pstrcpy(buf, sizeof(buf), optarg);
 2179:                     } else if (check_params(buf, sizeof(buf), params, optarg) < 0) {
 2180:                         fprintf(stderr,
 2181:                                 "qemu: unknown boot parameter '%s' in '%s'\n",
 2182:                                 buf, optarg);
 2183:                         exit(1);
 2184:                     }
 2185: 
 2186:                     if (legacy ||
 2187:                         get_param_value(buf, sizeof(buf), "order", optarg)) {
 2188:                         validate_bootdevices(buf);
 2189:                         pstrcpy(boot_devices, sizeof(boot_devices), buf);
 2190:                     }
 2191:                     if (!legacy) {
 2192:                         if (get_param_value(buf, sizeof(buf),
 2193:                                             "once", optarg)) {
 2194:                             validate_bootdevices(buf);
 2195:                             standard_boot_devices = qemu_strdup(boot_devices);
 2196:                             pstrcpy(boot_devices, sizeof(boot_devices), buf);
 2197:                             qemu_register_reset(restore_boot_devices,
 2198:                                                 standard_boot_devices);
 2199:                         }
 2200:                         if (get_param_value(buf, sizeof(buf),
 2201:                                             "menu", optarg)) {
 2202:                             if (!strcmp(buf, "on")) {
 2203:                                 boot_menu = 1;
 2204:                             } else if (!strcmp(buf, "off")) {
 2205:                                 boot_menu = 0;
 2206:                             } else {
 2207:                                 fprintf(stderr,
 2208:                                         "qemu: invalid option value '%s'\n",
 2209:                                         buf);
 2210:                                 exit(1);
 2211:                             }
 2212:                         }
 2213:                     }
 2214:                 }
 2215:                 break;
 2216:             case QEMU_OPTION_fda:
 2217:             case QEMU_OPTION_fdb:
 2218:                 drive_add(IF_FLOPPY, popt->index - QEMU_OPTION_fda,
 2219:                           optarg, FD_OPTS);
 2220:                 break;
 2221:             case QEMU_OPTION_no_fd_bootchk:
 2222:                 fd_bootchk = 0;
 2223:                 break;
 2224:             case QEMU_OPTION_netdev:
 2225:                 if (net_client_parse(qemu_find_opts("netdev"), optarg) == -1) {
 2226:                     exit(1);
 2227:                 }
 2228:                 break;
 2229:             case QEMU_OPTION_net:
 2230:                 if (net_client_parse(qemu_find_opts("net"), optarg) == -1) {
 2231:                     exit(1);
 2232:                 }
 2233:                 break;
 2234: #ifdef CONFIG_SLIRP
 2235:             case QEMU_OPTION_tftp:
 2236:                 legacy_tftp_prefix = optarg;
 2237:                 break;
 2238:             case QEMU_OPTION_bootp:
 2239:                 legacy_bootp_filename = optarg;
 2240:                 break;
 2241:             case QEMU_OPTION_redir:
 2242:                 if (net_slirp_redir(optarg) < 0)
 2243:                     exit(1);
 2244:                 break;
 2245: #endif
 2246:             case QEMU_OPTION_bt:
 2247:                 add_device_config(DEV_BT, optarg);
 2248:                 break;
 2249:             case QEMU_OPTION_audio_help:
 2250:                 if (!(audio_available())) {
 2251:                     printf("Option %s not supported for this target\n", popt->name);
 2252:                     exit(1);
 2253:                 }
 2254:                 AUD_help ();
 2255:                 exit (0);
 2256:                 break;
 2257:             case QEMU_OPTION_soundhw:
 2258:                 if (!(audio_available())) {
 2259:                     printf("Option %s not supported for this target\n", popt->name);
 2260:                     exit(1);
 2261:                 }
 2262:                 select_soundhw (optarg);
 2263:                 break;
 2264:             case QEMU_OPTION_h:
 2265:                 help(0);
 2266:                 break;
 2267:             case QEMU_OPTION_version:
 2268:                 version();
 2269:                 exit(0);
 2270:                 break;
 2271:             case QEMU_OPTION_m: {
 2272:                 int64_t value;
 2273: 
 2274:                 value = strtosz(optarg, NULL);
 2275:                 if (value < 0) {
 2276:                     fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
 2277:                     exit(1);
 2278:                 }
 2279: 
 2280:                 /* On 32-bit hosts, QEMU is limited by virtual address space */
 2281:                 if (value > (2047 << 20) && HOST_LONG_BITS == 32) {
 2282:                     fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
 2283:                     exit(1);
 2284:                 }
 2285:                 if (value != (uint64_t)(ram_addr_t)value) {
 2286:                     fprintf(stderr, "qemu: ram size too large\n");
 2287:                     exit(1);
 2288:                 }
 2289:                 ram_size = value;
 2290:                 break;
 2291:             }
 2292:             case QEMU_OPTION_mempath:
 2293:                 mem_path = optarg;
 2294:                 break;
 2295: #ifdef MAP_POPULATE
 2296:             case QEMU_OPTION_mem_prealloc:
 2297:                 mem_prealloc = 1;
 2298:                 break;
 2299: #endif
 2300:             case QEMU_OPTION_d:
 2301:                 set_cpu_log(optarg);
 2302:                 break;
 2303:             case QEMU_OPTION_s:
 2304:                 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
 2305:                 break;
 2306:             case QEMU_OPTION_gdb:
 2307:                 gdbstub_dev = optarg;
 2308:                 break;
 2309:             case QEMU_OPTION_L:
 2310:                 data_dir = optarg;
 2311:                 break;
 2312:             case QEMU_OPTION_bios:
 2313:                 bios_name = optarg;
 2314:                 break;
 2315:             case QEMU_OPTION_singlestep:
 2316:                 singlestep = 1;
 2317:                 break;
 2318:             case QEMU_OPTION_S:
 2319:                 autostart = 0;
 2320:                 break;
 2321: 	    case QEMU_OPTION_k:
 2322: 		keyboard_layout = optarg;
 2323: 		break;
 2324:             case QEMU_OPTION_localtime:
 2325:                 rtc_utc = 0;
 2326:                 break;
 2327:             case QEMU_OPTION_vga:
 2328:                 select_vgahw (optarg);
 2329:                 break;
 2330:             case QEMU_OPTION_g:
 2331:                 {
 2332:                     const char *p;
 2333:                     int w, h, depth;
 2334:                     p = optarg;
 2335:                     w = strtol(p, (char **)&p, 10);
 2336:                     if (w <= 0) {
 2337:                     graphic_error:
 2338:                         fprintf(stderr, "qemu: invalid resolution or depth\n");
 2339:                         exit(1);
 2340:                     }
 2341:                     if (*p != 'x')
 2342:                         goto graphic_error;
 2343:                     p++;
 2344:                     h = strtol(p, (char **)&p, 10);
 2345:                     if (h <= 0)
 2346:                         goto graphic_error;
 2347:                     if (*p == 'x') {
 2348:                         p++;
 2349:                         depth = strtol(p, (char **)&p, 10);
 2350:                         if (depth != 8 && depth != 15 && depth != 16 &&
 2351:                             depth != 24 && depth != 32)
 2352:                             goto graphic_error;
 2353:                     } else if (*p == '\0') {
 2354:                         depth = graphic_depth;
 2355:                     } else {
 2356:                         goto graphic_error;
 2357:                     }
 2358: 
 2359:                     graphic_width = w;
 2360:                     graphic_height = h;
 2361:                     graphic_depth = depth;
 2362:                 }
 2363:                 break;
 2364:             case QEMU_OPTION_echr:
 2365:                 {
 2366:                     char *r;
 2367:                     term_escape_char = strtol(optarg, &r, 0);
 2368:                     if (r == optarg)
 2369:                         printf("Bad argument to echr\n");
 2370:                     break;
 2371:                 }
 2372:             case QEMU_OPTION_monitor:
 2373:                 monitor_parse(optarg, "readline");
 2374:                 default_monitor = 0;
 2375:                 break;
 2376:             case QEMU_OPTION_qmp:
 2377:                 monitor_parse(optarg, "control");
 2378:                 default_monitor = 0;
 2379:                 break;
 2380:             case QEMU_OPTION_mon:
 2381:                 opts = qemu_opts_parse(qemu_find_opts("mon"), optarg, 1);
 2382:                 if (!opts) {
 2383:                     exit(1);
 2384:                 }
 2385:                 default_monitor = 0;
 2386:                 break;
 2387:             case QEMU_OPTION_chardev:
 2388:                 opts = qemu_opts_parse(qemu_find_opts("chardev"), optarg, 1);
 2389:                 if (!opts) {
 2390:                     exit(1);
 2391:                 }
 2392:                 break;
 2393:             case QEMU_OPTION_fsdev:
 2394:                 olist = qemu_find_opts("fsdev");
 2395:                 if (!olist) {
 2396:                     fprintf(stderr, "fsdev is not supported by this qemu build.\n");
 2397:                     exit(1);
 2398:                 }
 2399:                 opts = qemu_opts_parse(olist, optarg, 1);
 2400:                 if (!opts) {
 2401:                     fprintf(stderr, "parse error: %s\n", optarg);
 2402:                     exit(1);
 2403:                 }
 2404:                 break;
 2405:             case QEMU_OPTION_virtfs: {
 2406:                 char *arg_fsdev = NULL;
 2407:                 char *arg_9p = NULL;
 2408:                 int len = 0;
 2409: 
 2410:                 olist = qemu_find_opts("virtfs");
 2411:                 if (!olist) {
 2412:                     fprintf(stderr, "virtfs is not supported by this qemu build.\n");
 2413:                     exit(1);
 2414:                 }
 2415:                 opts = qemu_opts_parse(olist, optarg, 1);
 2416:                 if (!opts) {
 2417:                     fprintf(stderr, "parse error: %s\n", optarg);
 2418:                     exit(1);
 2419:                 }
 2420: 
 2421:                 if (qemu_opt_get(opts, "fstype") == NULL ||
 2422:                         qemu_opt_get(opts, "mount_tag") == NULL ||
 2423:                         qemu_opt_get(opts, "path") == NULL ||
 2424:                         qemu_opt_get(opts, "security_model") == NULL) {
 2425:                     fprintf(stderr, "Usage: -virtfs fstype,path=/share_path/,"
 2426:                             "security_model=[mapped|passthrough|none],"
 2427:                             "mnt_tag=tag.\n");
 2428:                     exit(1);
 2429:                 }
 2430: 
 2431:                 len = strlen(",id=,path=,security_model=");
 2432:                 len += strlen(qemu_opt_get(opts, "fstype"));
 2433:                 len += strlen(qemu_opt_get(opts, "mount_tag"));
 2434:                 len += strlen(qemu_opt_get(opts, "path"));
 2435:                 len += strlen(qemu_opt_get(opts, "security_model"));
 2436:                 arg_fsdev = qemu_malloc((len + 1) * sizeof(*arg_fsdev));
 2437: 
 2438:                 snprintf(arg_fsdev, (len + 1) * sizeof(*arg_fsdev),
 2439:                          "%s,id=%s,path=%s,security_model=%s",
 2440:                          qemu_opt_get(opts, "fstype"),
 2441:                          qemu_opt_get(opts, "mount_tag"),
 2442:                          qemu_opt_get(opts, "path"),
 2443:                          qemu_opt_get(opts, "security_model"));
 2444: 
 2445:                 len = strlen("virtio-9p-pci,fsdev=,mount_tag=");
 2446:                 len += 2*strlen(qemu_opt_get(opts, "mount_tag"));
 2447:                 arg_9p = qemu_malloc((len + 1) * sizeof(*arg_9p));
 2448: 
 2449:                 snprintf(arg_9p, (len + 1) * sizeof(*arg_9p),
 2450:                          "virtio-9p-pci,fsdev=%s,mount_tag=%s",
 2451:                          qemu_opt_get(opts, "mount_tag"),
 2452:                          qemu_opt_get(opts, "mount_tag"));
 2453: 
 2454:                 if (!qemu_opts_parse(qemu_find_opts("fsdev"), arg_fsdev, 1)) {
 2455:                     fprintf(stderr, "parse error [fsdev]: %s\n", optarg);
 2456:                     exit(1);
 2457:                 }
 2458: 
 2459:                 if (!qemu_opts_parse(qemu_find_opts("device"), arg_9p, 1)) {
 2460:                     fprintf(stderr, "parse error [device]: %s\n", optarg);
 2461:                     exit(1);
 2462:                 }
 2463: 
 2464:                 qemu_free(arg_fsdev);
 2465:                 qemu_free(arg_9p);
 2466:                 break;
 2467:             }
 2468:             case QEMU_OPTION_serial:
 2469:                 add_device_config(DEV_SERIAL, optarg);
 2470:                 default_serial = 0;
 2471:                 if (strncmp(optarg, "mon:", 4) == 0) {
 2472:                     default_monitor = 0;
 2473:                 }
 2474:                 break;
 2475:             case QEMU_OPTION_watchdog:
 2476:                 if (watchdog) {
 2477:                     fprintf(stderr,
 2478:                             "qemu: only one watchdog option may be given\n");
 2479:                     return 1;
 2480:                 }
 2481:                 watchdog = optarg;
 2482:                 break;
 2483:             case QEMU_OPTION_watchdog_action:
 2484:                 if (select_watchdog_action(optarg) == -1) {
 2485:                     fprintf(stderr, "Unknown -watchdog-action parameter\n");
 2486:                     exit(1);
 2487:                 }
 2488:                 break;
 2489:             case QEMU_OPTION_virtiocon:
 2490:                 add_device_config(DEV_VIRTCON, optarg);
 2491:                 default_virtcon = 0;
 2492:                 if (strncmp(optarg, "mon:", 4) == 0) {
 2493:                     default_monitor = 0;
 2494:                 }
 2495:                 break;
 2496:             case QEMU_OPTION_parallel:
 2497:                 add_device_config(DEV_PARALLEL, optarg);
 2498:                 default_parallel = 0;
 2499:                 if (strncmp(optarg, "mon:", 4) == 0) {
 2500:                     default_monitor = 0;
 2501:                 }
 2502:                 break;
 2503:             case QEMU_OPTION_debugcon:
 2504:                 add_device_config(DEV_DEBUGCON, optarg);
 2505:                 break;
 2506: 	    case QEMU_OPTION_loadvm:
 2507: 		loadvm = optarg;
 2508: 		break;
 2509:             case QEMU_OPTION_full_screen:
 2510:                 full_screen = 1;
 2511:                 break;
 2512: #ifdef CONFIG_SDL
 2513:             case QEMU_OPTION_no_frame:
 2514:                 no_frame = 1;
 2515:                 break;
 2516:             case QEMU_OPTION_alt_grab:
 2517:                 alt_grab = 1;
 2518:                 break;
 2519:             case QEMU_OPTION_ctrl_grab:
 2520:                 ctrl_grab = 1;
 2521:                 break;
 2522:             case QEMU_OPTION_no_quit:
 2523:                 no_quit = 1;
 2524:                 break;
 2525:             case QEMU_OPTION_sdl:
 2526:                 display_type = DT_SDL;
 2527:                 break;
 2528: #endif
 2529:             case QEMU_OPTION_pidfile:
 2530:                 pid_file = optarg;
 2531:                 break;
 2532:             case QEMU_OPTION_win2k_hack:
 2533:                 win2k_install_hack = 1;
 2534:                 break;
 2535:             case QEMU_OPTION_rtc_td_hack:
 2536:                 rtc_td_hack = 1;
 2537:                 break;
 2538:             case QEMU_OPTION_acpitable:
 2539:                 do_acpitable_option(optarg);
 2540:                 break;
 2541:             case QEMU_OPTION_smbios:
 2542:                 do_smbios_option(optarg);
 2543:                 break;
 2544:             case QEMU_OPTION_enable_kvm:
 2545:                 kvm_allowed = 1;
 2546:                 break;
 2547:             case QEMU_OPTION_usb:
 2548:                 usb_enabled = 1;
 2549:                 break;
 2550:             case QEMU_OPTION_usbdevice:
 2551:                 usb_enabled = 1;
 2552:                 add_device_config(DEV_USB, optarg);
 2553:                 break;
 2554:             case QEMU_OPTION_device:
 2555:                 if (!qemu_opts_parse(qemu_find_opts("device"), optarg, 1)) {
 2556:                     exit(1);
 2557:                 }
 2558:                 break;
 2559:             case QEMU_OPTION_smp:
 2560:                 smp_parse(optarg);
 2561:                 if (smp_cpus < 1) {
 2562:                     fprintf(stderr, "Invalid number of CPUs\n");
 2563:                     exit(1);
 2564:                 }
 2565:                 if (max_cpus < smp_cpus) {
 2566:                     fprintf(stderr, "maxcpus must be equal to or greater than "
 2567:                             "smp\n");
 2568:                     exit(1);
 2569:                 }
 2570:                 if (max_cpus > 255) {
 2571:                     fprintf(stderr, "Unsupported number of maxcpus\n");
 2572:                     exit(1);
 2573:                 }
 2574:                 break;
 2575: 	    case QEMU_OPTION_vnc:
 2576:                 display_remote++;
 2577: 		vnc_display = optarg;
 2578: 		break;
 2579:             case QEMU_OPTION_no_acpi:
 2580:                 acpi_enabled = 0;
 2581:                 break;
 2582:             case QEMU_OPTION_no_hpet:
 2583:                 no_hpet = 1;
 2584:                 break;
 2585:             case QEMU_OPTION_balloon:
 2586:                 if (balloon_parse(optarg) < 0) {
 2587:                     fprintf(stderr, "Unknown -balloon argument %s\n", optarg);
 2588:                     exit(1);
 2589:                 }
 2590:                 break;
 2591:             case QEMU_OPTION_no_reboot:
 2592:                 no_reboot = 1;
 2593:                 break;
 2594:             case QEMU_OPTION_no_shutdown:
 2595:                 no_shutdown = 1;
 2596:                 break;
 2597:             case QEMU_OPTION_show_cursor:
 2598:                 cursor_hide = 0;
 2599:                 break;
 2600:             case QEMU_OPTION_uuid:
 2601:                 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
 2602:                     fprintf(stderr, "Fail to parse UUID string."
 2603:                             " Wrong format.\n");
 2604:                     exit(1);
 2605:                 }
 2606:                 break;
 2607: 	    case QEMU_OPTION_option_rom:
 2608: 		if (nb_option_roms >= MAX_OPTION_ROMS) {
 2609: 		    fprintf(stderr, "Too many option ROMs\n");
 2610: 		    exit(1);
 2611: 		}
 2612:                 opts = qemu_opts_parse(qemu_find_opts("option-rom"), optarg, 1);
 2613:                 option_rom[nb_option_roms].name = qemu_opt_get(opts, "romfile");
 2614:                 option_rom[nb_option_roms].bootindex =
 2615:                     qemu_opt_get_number(opts, "bootindex", -1);
 2616:                 if (!option_rom[nb_option_roms].name) {
 2617:                     fprintf(stderr, "Option ROM file is not specified\n");
 2618:                     exit(1);
 2619:                 }
 2620: 		nb_option_roms++;
 2621: 		break;
 2622:             case QEMU_OPTION_semihosting:
 2623:                 semihosting_enabled = 1;
 2624:                 break;
 2625:             case QEMU_OPTION_name:
 2626:                 qemu_name = qemu_strdup(optarg);
 2627: 		 {
 2628: 		     char *p = strchr(qemu_name, ',');
 2629: 		     if (p != NULL) {
 2630: 		        *p++ = 0;
 2631: 			if (strncmp(p, "process=", 8)) {
 2632: 			    fprintf(stderr, "Unknown subargument %s to -name\n", p);
 2633: 			    exit(1);
 2634: 			}
 2635: 			p += 8;
 2636: 			os_set_proc_name(p);
 2637: 		     }	
 2638: 		 }	
 2639:                 break;
 2640:             case QEMU_OPTION_prom_env:
 2641:                 if (nb_prom_envs >= MAX_PROM_ENVS) {
 2642:                     fprintf(stderr, "Too many prom variables\n");
 2643:                     exit(1);
 2644:                 }
 2645:                 prom_envs[nb_prom_envs] = optarg;
 2646:                 nb_prom_envs++;
 2647:                 break;
 2648:             case QEMU_OPTION_old_param:
 2649:                 old_param = 1;
 2650:                 break;
 2651:             case QEMU_OPTION_clock:
 2652:                 configure_alarms(optarg);
 2653:                 break;
 2654:             case QEMU_OPTION_startdate:
 2655:                 configure_rtc_date_offset(optarg, 1);
 2656:                 break;
 2657:             case QEMU_OPTION_rtc:
 2658:                 opts = qemu_opts_parse(qemu_find_opts("rtc"), optarg, 0);
 2659:                 if (!opts) {
 2660:                     exit(1);
 2661:                 }
 2662:                 configure_rtc(opts);
 2663:                 break;
 2664:             case QEMU_OPTION_tb_size:
 2665:                 tb_size = strtol(optarg, NULL, 0);
 2666:                 if (tb_size < 0)
 2667:                     tb_size = 0;
 2668:                 break;
 2669:             case QEMU_OPTION_icount:
 2670:                 icount_option = optarg;
 2671:                 break;
 2672:             case QEMU_OPTION_incoming:
 2673:                 incoming = optarg;
 2674:                 incoming_expected = true;
 2675:                 break;
 2676:             case QEMU_OPTION_nodefaults:
 2677:                 default_serial = 0;
 2678:                 default_parallel = 0;
 2679:                 default_virtcon = 0;
 2680:                 default_monitor = 0;
 2681:                 default_vga = 0;
 2682:                 default_net = 0;
 2683:                 default_floppy = 0;
 2684:                 default_cdrom = 0;
 2685:                 default_sdcard = 0;
 2686:                 break;
 2687:             case QEMU_OPTION_xen_domid:
 2688:                 if (!(xen_available())) {
 2689:                     printf("Option %s not supported for this target\n", popt->name);
 2690:                     exit(1);
 2691:                 }
 2692:                 xen_domid = atoi(optarg);
 2693:                 break;
 2694:             case QEMU_OPTION_xen_create:
 2695:                 if (!(xen_available())) {
 2696:                     printf("Option %s not supported for this target\n", popt->name);
 2697:                     exit(1);
 2698:                 }
 2699:                 xen_mode = XEN_CREATE;
 2700:                 break;
 2701:             case QEMU_OPTION_xen_attach:
 2702:                 if (!(xen_available())) {
 2703:                     printf("Option %s not supported for this target\n", popt->name);
 2704:                     exit(1);
 2705:                 }
 2706:                 xen_mode = XEN_ATTACH;
 2707:                 break;
 2708: #ifdef CONFIG_SIMPLE_TRACE
 2709:             case QEMU_OPTION_trace:
 2710:                 opts = qemu_opts_parse(qemu_find_opts("trace"), optarg, 0);
 2711:                 if (opts) {
 2712:                     trace_file = qemu_opt_get(opts, "file");
 2713:                 }
 2714:                 break;
 2715: #endif
 2716:             case QEMU_OPTION_readconfig:
 2717:                 {
 2718:                     int ret = qemu_read_config_file(optarg);
 2719:                     if (ret < 0) {
 2720:                         fprintf(stderr, "read config %s: %s\n", optarg,
 2721:                             strerror(-ret));
 2722:                         exit(1);
 2723:                     }
 2724:                     break;
 2725:                 }
 2726:             case QEMU_OPTION_spice:
 2727:                 olist = qemu_find_opts("spice");
 2728:                 if (!olist) {
 2729:                     fprintf(stderr, "spice is not supported by this qemu build.\n");
 2730:                     exit(1);
 2731:                 }
 2732:                 opts = qemu_opts_parse(olist, optarg, 0);
 2733:                 if (!opts) {
 2734:                     fprintf(stderr, "parse error: %s\n", optarg);
 2735:                     exit(1);
 2736:                 }
 2737:                 break;
 2738:             case QEMU_OPTION_writeconfig:
 2739:                 {
 2740:                     FILE *fp;
 2741:                     if (strcmp(optarg, "-") == 0) {
 2742:                         fp = stdout;
 2743:                     } else {
 2744:                         fp = fopen(optarg, "w");
 2745:                         if (fp == NULL) {
 2746:                             fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
 2747:                             exit(1);
 2748:                         }
 2749:                     }
 2750:                     qemu_config_write(fp);
 2751:                     fclose(fp);
 2752:                     break;
 2753:                 }
 2754:             default:
 2755:                 os_parse_cmd_args(popt->index, optarg);
 2756:             }
 2757:         }
 2758:     }
 2759:     loc_set_none();
 2760: 
 2761:     /* If no data_dir is specified then try to find it relative to the
 2762:        executable path.  */
 2763:     if (!data_dir) {
 2764:         data_dir = os_find_datadir(argv[0]);
 2765:     }
 2766:     /* If all else fails use the install patch specified when building.  */
 2767:     if (!data_dir) {
 2768:         data_dir = CONFIG_QEMU_DATADIR;
 2769:     }
 2770: 
 2771: #ifdef CONFIG_SIMPLE_TRACE
 2772:     /*
 2773:      * Set the trace file name, if specified.
 2774:      */
 2775:     st_set_trace_file(trace_file);
 2776: #endif
 2777:     /*
 2778:      * Default to max_cpus = smp_cpus, in case the user doesn't
 2779:      * specify a max_cpus value.
 2780:      */
 2781:     if (!max_cpus)
 2782:         max_cpus = smp_cpus;
 2783: 
 2784:     machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
 2785:     if (smp_cpus > machine->max_cpus) {
 2786:         fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
 2787:                 "supported by machine `%s' (%d)\n", smp_cpus,  machine->name,
 2788:                 machine->max_cpus);
 2789:         exit(1);
 2790:     }
 2791: 
 2792:     qemu_opts_foreach(qemu_find_opts("device"), default_driver_check, NULL, 0);
 2793:     qemu_opts_foreach(qemu_find_opts("global"), default_driver_check, NULL, 0);
 2794: 
 2795:     if (machine->no_serial) {
 2796:         default_serial = 0;
 2797:     }
 2798:     if (machine->no_parallel) {
 2799:         default_parallel = 0;
 2800:     }
 2801:     if (!machine->use_virtcon) {
 2802:         default_virtcon = 0;
 2803:     }
 2804:     if (machine->no_vga) {
 2805:         default_vga = 0;
 2806:     }
 2807:     if (machine->no_floppy) {
 2808:         default_floppy = 0;
 2809:     }
 2810:     if (machine->no_cdrom) {
 2811:         default_cdrom = 0;
 2812:     }
 2813:     if (machine->no_sdcard) {
 2814:         default_sdcard = 0;
 2815:     }
 2816: 
 2817:     if (display_type == DT_NOGRAPHIC) {
 2818:         if (default_parallel)
 2819:             add_device_config(DEV_PARALLEL, "null");
 2820:         if (default_serial && default_monitor) {
 2821:             add_device_config(DEV_SERIAL, "mon:stdio");
 2822:         } else if (default_virtcon && default_monitor) {
 2823:             add_device_config(DEV_VIRTCON, "mon:stdio");
 2824:         } else {
 2825:             if (default_serial)
 2826:                 add_device_config(DEV_SERIAL, "stdio");
 2827:             if (default_virtcon)
 2828:                 add_device_config(DEV_VIRTCON, "stdio");
 2829:             if (default_monitor)
 2830:                 monitor_parse("stdio", "readline");
 2831:         }
 2832:     } else {
 2833:         if (default_serial)
 2834:             add_device_config(DEV_SERIAL, "vc:80Cx24C");
 2835:         if (default_parallel)
 2836:             add_device_config(DEV_PARALLEL, "vc:80Cx24C");
 2837:         if (default_monitor)
 2838:             monitor_parse("vc:80Cx24C", "readline");
 2839:         if (default_virtcon)
 2840:             add_device_config(DEV_VIRTCON, "vc:80Cx24C");
 2841:     }
 2842:     if (default_vga)
 2843:         vga_interface_type = VGA_CIRRUS;
 2844: 
 2845:     socket_init();
 2846: 
 2847:     if (qemu_opts_foreach(qemu_find_opts("chardev"), chardev_init_func, NULL, 1) != 0)
 2848:         exit(1);
 2849: #ifdef CONFIG_VIRTFS
 2850:     if (qemu_opts_foreach(qemu_find_opts("fsdev"), fsdev_init_func, NULL, 1) != 0) {
 2851:         exit(1);
 2852:     }
 2853: #endif
 2854: 
 2855:     os_daemonize();
 2856: 
 2857:     if (pid_file && qemu_create_pidfile(pid_file) != 0) {
 2858:         os_pidfile_error();
 2859:         exit(1);
 2860:     }
 2861: 
 2862:     if (kvm_allowed) {
 2863:         int ret = kvm_init();
 2864:         if (ret < 0) {
 2865:             if (!kvm_available()) {
 2866:                 printf("KVM not supported for this target\n");
 2867:             } else {
 2868:                 fprintf(stderr, "failed to initialize KVM: %s\n", strerror(-ret));
 2869:             }
 2870:             exit(1);
 2871:         }
 2872:     }
 2873: 
 2874:     if (qemu_init_main_loop()) {
 2875:         fprintf(stderr, "qemu_init_main_loop failed\n");
 2876:         exit(1);
 2877:     }
 2878:     linux_boot = (kernel_filename != NULL);
 2879: 
 2880:     if (!linux_boot && *kernel_cmdline != '\0') {
 2881:         fprintf(stderr, "-append only allowed with -kernel option\n");
 2882:         exit(1);
 2883:     }
 2884: 
 2885:     if (!linux_boot && initrd_filename != NULL) {
 2886:         fprintf(stderr, "-initrd only allowed with -kernel option\n");
 2887:         exit(1);
 2888:     }
 2889: 
 2890:     os_set_line_buffering();
 2891: 
 2892:     if (init_timer_alarm() < 0) {
 2893:         fprintf(stderr, "could not initialize alarm timer\n");
 2894:         exit(1);
 2895:     }
 2896:     configure_icount(icount_option);
 2897: 
 2898:     if (net_init_clients() < 0) {
 2899:         exit(1);
 2900:     }
 2901: 
 2902:     /* init the bluetooth world */
 2903:     if (foreach_device_config(DEV_BT, bt_parse))
 2904:         exit(1);
 2905: 
 2906:     /* init the memory */
 2907:     if (ram_size == 0)
 2908:         ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
 2909: 
 2910:     /* init the dynamic translator */
 2911:     cpu_exec_init_all(tb_size * 1024 * 1024);
 2912: 
 2913:     bdrv_init_with_whitelist();
 2914: 
 2915:     blk_mig_init();
 2916: 
 2917:     /* open the virtual block devices */
 2918:     if (snapshot)
 2919:         qemu_opts_foreach(qemu_find_opts("drive"), drive_enable_snapshot, NULL, 0);
 2920:     if (qemu_opts_foreach(qemu_find_opts("drive"), drive_init_func, &machine->use_scsi, 1) != 0)
 2921:         exit(1);
 2922: 
 2923:     default_drive(default_cdrom, snapshot, machine->use_scsi,
 2924:                   IF_DEFAULT, 2, CDROM_OPTS);
 2925:     default_drive(default_floppy, snapshot, machine->use_scsi,
 2926:                   IF_FLOPPY, 0, FD_OPTS);
 2927:     default_drive(default_sdcard, snapshot, machine->use_scsi,
 2928:                   IF_SD, 0, SD_OPTS);
 2929: 
 2930:     register_savevm_live(NULL, "ram", 0, 4, NULL, ram_save_live, NULL,
 2931:                          ram_load, NULL);
 2932: 
 2933:     if (nb_numa_nodes > 0) {
 2934:         int i;
 2935: 
 2936:         if (nb_numa_nodes > smp_cpus) {
 2937:             nb_numa_nodes = smp_cpus;
 2938:         }
 2939: 
 2940:         /* If no memory size if given for any node, assume the default case
 2941:          * and distribute the available memory equally across all nodes
 2942:          */
 2943:         for (i = 0; i < nb_numa_nodes; i++) {
 2944:             if (node_mem[i] != 0)
 2945:                 break;
 2946:         }
 2947:         if (i == nb_numa_nodes) {
 2948:             uint64_t usedmem = 0;
 2949: 
 2950:             /* On Linux, the each node's border has to be 8MB aligned,
 2951:              * the final node gets the rest.
 2952:              */
 2953:             for (i = 0; i < nb_numa_nodes - 1; i++) {
 2954:                 node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1);
 2955:                 usedmem += node_mem[i];
 2956:             }
 2957:             node_mem[i] = ram_size - usedmem;
 2958:         }
 2959: 
 2960:         for (i = 0; i < nb_numa_nodes; i++) {
 2961:             if (node_cpumask[i] != 0)
 2962:                 break;
 2963:         }
 2964:         /* assigning the VCPUs round-robin is easier to implement, guest OSes
 2965:          * must cope with this anyway, because there are BIOSes out there in
 2966:          * real machines which also use this scheme.
 2967:          */
 2968:         if (i == nb_numa_nodes) {
 2969:             for (i = 0; i < smp_cpus; i++) {
 2970:                 node_cpumask[i % nb_numa_nodes] |= 1 << i;
 2971:             }
 2972:         }
 2973:     }
 2974: 
 2975:     if (qemu_opts_foreach(qemu_find_opts("mon"), mon_init_func, NULL, 1) != 0) {
 2976:         exit(1);
 2977:     }
 2978: 
 2979:     if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
 2980:         exit(1);
 2981:     if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
 2982:         exit(1);
 2983:     if (foreach_device_config(DEV_VIRTCON, virtcon_parse) < 0)
 2984:         exit(1);
 2985:     if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
 2986:         exit(1);
 2987: 
 2988:     module_call_init(MODULE_INIT_DEVICE);
 2989: 
 2990:     if (qemu_opts_foreach(qemu_find_opts("device"), device_help_func, NULL, 0) != 0)
 2991:         exit(0);
 2992: 
 2993:     if (watchdog) {
 2994:         i = select_watchdog(watchdog);
 2995:         if (i > 0)
 2996:             exit (i == 1 ? 1 : 0);
 2997:     }
 2998: 
 2999:     if (machine->compat_props) {
 3000:         qdev_prop_register_global_list(machine->compat_props);
 3001:     }
 3002:     qemu_add_globals();
 3003: 
 3004:     machine->init(ram_size, boot_devices,
 3005:                   kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
 3006: 
 3007:     cpu_synchronize_all_post_init();
 3008: 
 3009:     /* must be after terminal init, SDL library changes signal handlers */
 3010:     os_setup_signal_handling();
 3011: 
 3012:     set_numa_modes();
 3013: 
 3014:     current_machine = machine;
 3015: 
 3016:     /* init USB devices */
 3017:     if (usb_enabled) {
 3018:         if (foreach_device_config(DEV_USB, usb_parse) < 0)
 3019:             exit(1);
 3020:     }
 3021: 
 3022:     /* init generic devices */
 3023:     if (qemu_opts_foreach(qemu_find_opts("device"), device_init_func, NULL, 1) != 0)
 3024:         exit(1);
 3025: 
 3026:     net_check_clients();
 3027: 
 3028:     /* just use the first displaystate for the moment */
 3029:     ds = get_displaystate();
 3030: 
 3031:     if (using_spice)
 3032:         display_remote++;
 3033:     if (display_type == DT_DEFAULT && !display_remote) {
 3034: #if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
 3035:         display_type = DT_SDL;
 3036: #else
 3037:         vnc_display = "localhost:0,to=99";
 3038:         show_vnc_port = 1;
 3039: #endif
 3040:     }
 3041:         
 3042: 
 3043:     /* init local displays */
 3044:     switch (display_type) {
 3045:     case DT_NOGRAPHIC:
 3046:         break;
 3047: #if defined(CONFIG_CURSES)
 3048:     case DT_CURSES:
 3049:         curses_display_init(ds, full_screen);
 3050:         break;
 3051: #endif
 3052: #if defined(CONFIG_SDL)
 3053:     case DT_SDL:
 3054:         sdl_display_init(ds, full_screen, no_frame);
 3055:         break;
 3056: #elif defined(CONFIG_COCOA)
 3057:     case DT_SDL:
 3058:         cocoa_display_init(ds, full_screen);
 3059:         break;
 3060: #endif
 3061:     default:
 3062:         break;
 3063:     }
 3064: 
 3065:     /* init remote displays */
 3066:     if (vnc_display) {
 3067:         vnc_display_init(ds);
 3068:         if (vnc_display_open(ds, vnc_display) < 0)
 3069:             exit(1);
 3070: 
 3071:         if (show_vnc_port) {
 3072:             printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
 3073:         }
 3074:     }
 3075: #ifdef CONFIG_SPICE
 3076:     if (using_spice && !qxl_enabled) {
 3077:         qemu_spice_display_init(ds);
 3078:     }
 3079: #endif
 3080: 
 3081:     /* display setup */
 3082:     dpy_resize(ds);
 3083:     dcl = ds->listeners;
 3084:     while (dcl != NULL) {
 3085:         if (dcl->dpy_refresh != NULL) {
 3086:             ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
 3087:             qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
 3088:             break;
 3089:         }
 3090:         dcl = dcl->next;
 3091:     }
 3092:     if (ds->gui_timer == NULL) {
 3093:         nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
 3094:         qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
 3095:     }
 3096:     text_consoles_set_display(ds);
 3097: 
 3098:     if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
 3099:         fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
 3100:                 gdbstub_dev);
 3101:         exit(1);
 3102:     }
 3103: 
 3104:     qdev_machine_creation_done();
 3105: 
 3106:     if (rom_load_all() != 0) {
 3107:         fprintf(stderr, "rom loading failed\n");
 3108:         exit(1);
 3109:     }
 3110: 
 3111:     /* TODO: once all bus devices are qdevified, this should be done
 3112:      * when bus is created by qdev.c */
 3113:     qemu_register_reset(qbus_reset_all_fn, sysbus_get_default());
 3114:     qemu_run_machine_init_done_notifiers();
 3115: 
 3116:     qemu_system_reset();
 3117:     if (loadvm) {
 3118:         if (load_vmstate(loadvm) < 0) {
 3119:             autostart = 0;
 3120:         }
 3121:     }
 3122: 
 3123:     if (incoming) {
 3124:         int ret = qemu_start_incoming_migration(incoming);
 3125:         if (ret < 0) {
 3126:             fprintf(stderr, "Migration failed. Exit code %s(%d), exiting.\n",
 3127:                     incoming, ret);
 3128:             exit(ret);
 3129:         }
 3130:     } else if (autostart) {
 3131:         vm_start();
 3132:     }
 3133: 
 3134:     os_setup_post();
 3135: 
 3136:     main_loop();
 3137:     quit_timers();
 3138:     net_cleanup();
 3139: 
 3140:     return 0;
 3141: }

unix.superglobalmegacorp.com