1ece09f8fSPekka Enberg #include "kvm/builtin-run.h" 2ece09f8fSPekka Enberg 3c8675741SSasha Levin #include "kvm/builtin-setup.h" 4ece09f8fSPekka Enberg #include "kvm/virtio-balloon.h" 5ece09f8fSPekka Enberg #include "kvm/virtio-console.h" 6ece09f8fSPekka Enberg #include "kvm/parse-options.h" 7ece09f8fSPekka Enberg #include "kvm/8250-serial.h" 8ece09f8fSPekka Enberg #include "kvm/framebuffer.h" 9ece09f8fSPekka Enberg #include "kvm/disk-image.h" 10ece09f8fSPekka Enberg #include "kvm/threadpool.h" 11ece09f8fSPekka Enberg #include "kvm/virtio-blk.h" 12ece09f8fSPekka Enberg #include "kvm/virtio-net.h" 13ece09f8fSPekka Enberg #include "kvm/virtio-rng.h" 14ece09f8fSPekka Enberg #include "kvm/ioeventfd.h" 15ece09f8fSPekka Enberg #include "kvm/virtio-9p.h" 16ece09f8fSPekka Enberg #include "kvm/barrier.h" 17ece09f8fSPekka Enberg #include "kvm/kvm-cpu.h" 18ece09f8fSPekka Enberg #include "kvm/ioport.h" 19ece09f8fSPekka Enberg #include "kvm/symbol.h" 20ece09f8fSPekka Enberg #include "kvm/i8042.h" 21ece09f8fSPekka Enberg #include "kvm/mutex.h" 22ece09f8fSPekka Enberg #include "kvm/term.h" 23ece09f8fSPekka Enberg #include "kvm/util.h" 24ece09f8fSPekka Enberg #include "kvm/vesa.h" 25ece09f8fSPekka Enberg #include "kvm/irq.h" 26ece09f8fSPekka Enberg #include "kvm/kvm.h" 27ece09f8fSPekka Enberg #include "kvm/pci.h" 28ece09f8fSPekka Enberg #include "kvm/rtc.h" 29ece09f8fSPekka Enberg #include "kvm/sdl.h" 30ece09f8fSPekka Enberg #include "kvm/vnc.h" 31e6694207SSasha Levin #include "kvm/guest_compat.h" 3295d13a52SSasha Levin #include "kvm/pci-shmem.h" 33ece09f8fSPekka Enberg 34ece09f8fSPekka Enberg #include <linux/types.h> 35ece09f8fSPekka Enberg 368329f30bSPekka Enberg #include <sys/utsname.h> 378329f30bSPekka Enberg #include <sys/types.h> 388329f30bSPekka Enberg #include <sys/stat.h> 39ece09f8fSPekka Enberg #include <termios.h> 40ece09f8fSPekka Enberg #include <signal.h> 41ece09f8fSPekka Enberg #include <stdlib.h> 42ece09f8fSPekka Enberg #include <string.h> 43ece09f8fSPekka Enberg #include <unistd.h> 4426c853e4SPrasad Joshi #include <ctype.h> 45ece09f8fSPekka Enberg #include <stdio.h> 46f967c427SPrasad Joshi 47f967c427SPrasad Joshi #define DEFAULT_KVM_DEV "/dev/kvm" 489aa4a0ebSAsias He #define DEFAULT_CONSOLE "serial" 49bd30e200SAsias He #define DEFAULT_NETWORK "user" 50745c7231SAsias He #define DEFAULT_HOST_ADDR "192.168.33.1" 51bb8ffd2fSAsias He #define DEFAULT_GUEST_ADDR "192.168.33.15" 527c88c87eSSasha Levin #define DEFAULT_GUEST_MAC "02:15:15:15:15:15" 537c88c87eSSasha Levin #define DEFAULT_HOST_MAC "02:01:01:01:01:01" 5473b7d038SAmos Kong #define DEFAULT_SCRIPT "none" 55f967c427SPrasad Joshi 56f967c427SPrasad Joshi #define MB_SHIFT (20) 5795d13a52SSasha Levin #define KB_SHIFT (10) 5895d13a52SSasha Levin #define GB_SHIFT (30) 59a2a002f9SIngo Molnar #define MIN_RAM_SIZE_MB (64ULL) 60f967c427SPrasad Joshi #define MIN_RAM_SIZE_BYTE (MIN_RAM_SIZE_MB << MB_SHIFT) 61f967c427SPrasad Joshi 624298ddadSSasha Levin struct kvm *kvm; 634298ddadSSasha Levin struct kvm_cpu *kvm_cpus[KVM_NR_CPUS]; 64656be1b8SSasha Levin __thread struct kvm_cpu *current_kvm_cpu; 65f967c427SPrasad Joshi 66fd834defSPekka Enberg static u64 ram_size; 67a33979d8SSasha Levin static u8 image_count; 68cf55d6aeSLiming Wang static bool virtio_rng; 69f967c427SPrasad Joshi static const char *kernel_cmdline; 70f967c427SPrasad Joshi static const char *kernel_filename; 71b0b42ba0SPekka Enberg static const char *vmlinux_filename; 72f967c427SPrasad Joshi static const char *initrd_filename; 73a33979d8SSasha Levin static const char *image_filename[MAX_DISK_IMAGES]; 749aa4a0ebSAsias He static const char *console; 755929637bSAsias He static const char *dev; 764f56d42cSAsias He static const char *network; 77e80ddf6aSAsias He static const char *host_ip; 78bb8ffd2fSAsias He static const char *guest_ip; 79a4e724ddSSasha Levin static const char *guest_mac; 80d7098b9bSAsias He static const char *host_mac; 8173b7d038SAmos Kong static const char *script; 825358b0e6SSasha Levin static const char *guest_name; 830ea58e5bSPekka Enberg static bool single_step; 84a33979d8SSasha Levin static bool readonly_image[MAX_DISK_IMAGES]; 855ffd4178SJohn Floren static bool vnc; 863f838fecSPekka Enberg static bool sdl; 8782d2f21eSSasha Levin static bool balloon; 8859aa2d30SSasha Levin static bool using_rootfs; 8982d65b5eSSasha Levin static bool custom_rootfs; 90f967c427SPrasad Joshi extern bool ioport_debug; 91f967c427SPrasad Joshi extern int active_console; 92aa400b00SPrasad Joshi extern int debug_iodelay; 93f967c427SPrasad Joshi 94ed036f03SCyrill Gorcunov bool do_debug_print = false; 95ed036f03SCyrill Gorcunov 96cfd63bbbSSasha Levin static int nrcpus; 97890364f8SCyrill Gorcunov static int vidmode = -1; 98d77a9efaSCyrill Gorcunov 99f967c427SPrasad Joshi static const char * const run_usage[] = { 1008329f30bSPekka Enberg "kvm run [<options>] [<kernel image>]", 101f967c427SPrasad Joshi NULL 102f967c427SPrasad Joshi }; 103f967c427SPrasad Joshi 104a33979d8SSasha Levin static int img_name_parser(const struct option *opt, const char *arg, int unset) 105a33979d8SSasha Levin { 106a33979d8SSasha Levin char *sep; 10759aa2d30SSasha Levin struct stat st; 10882d65b5eSSasha Levin char path[PATH_MAX]; 10959aa2d30SSasha Levin 11059aa2d30SSasha Levin if (stat(arg, &st) == 0 && 11159aa2d30SSasha Levin S_ISDIR(st.st_mode)) { 11259aa2d30SSasha Levin char tmp[PATH_MAX]; 11359aa2d30SSasha Levin 11459aa2d30SSasha Levin if (realpath(arg, tmp) == 0 || 115c7838fbdSSasha Levin virtio_9p__register(kvm, tmp, "/dev/root") < 0) 11659aa2d30SSasha Levin die("Unable to initialize virtio 9p"); 11759aa2d30SSasha Levin using_rootfs = 1; 11859aa2d30SSasha Levin return 0; 11959aa2d30SSasha Levin } 120a33979d8SSasha Levin 12182d65b5eSSasha Levin snprintf(path, PATH_MAX, "%s%s%s", HOME_DIR, KVM_PID_FILE_PATH, arg); 12282d65b5eSSasha Levin 12382d65b5eSSasha Levin if (stat(path, &st) == 0 && 12482d65b5eSSasha Levin S_ISDIR(st.st_mode)) { 12582d65b5eSSasha Levin char tmp[PATH_MAX]; 12682d65b5eSSasha Levin 12782d65b5eSSasha Levin if (realpath(path, tmp) == 0 || 12882d65b5eSSasha Levin virtio_9p__register(kvm, tmp, "/dev/root") < 0) 12982d65b5eSSasha Levin die("Unable to initialize virtio 9p"); 13082d65b5eSSasha Levin if (virtio_9p__register(kvm, "/", "hostfs") < 0) 13182d65b5eSSasha Levin die("Unable to initialize virtio 9p"); 13282d65b5eSSasha Levin using_rootfs = custom_rootfs = 1; 13382d65b5eSSasha Levin return 0; 13482d65b5eSSasha Levin } 13582d65b5eSSasha Levin 136a33979d8SSasha Levin if (image_count >= MAX_DISK_IMAGES) 137a33979d8SSasha Levin die("Currently only 4 images are supported"); 138a33979d8SSasha Levin 139a33979d8SSasha Levin image_filename[image_count] = arg; 140a33979d8SSasha Levin sep = strstr(arg, ","); 141a33979d8SSasha Levin if (sep) { 142a33979d8SSasha Levin if (strcmp(sep + 1, "ro") == 0) 143a33979d8SSasha Levin readonly_image[image_count] = 1; 144a33979d8SSasha Levin *sep = 0; 145a33979d8SSasha Levin } 146a33979d8SSasha Levin 147a33979d8SSasha Levin image_count++; 148a33979d8SSasha Levin 149a33979d8SSasha Levin return 0; 150a33979d8SSasha Levin } 151a33979d8SSasha Levin 152b4422bf3SAneesh Kumar K.V static int virtio_9p_rootdir_parser(const struct option *opt, const char *arg, int unset) 153b4422bf3SAneesh Kumar K.V { 154b4422bf3SAneesh Kumar K.V char *tag_name; 155b4422bf3SAneesh Kumar K.V char tmp[PATH_MAX]; 156b4422bf3SAneesh Kumar K.V 157b4422bf3SAneesh Kumar K.V /* 158b4422bf3SAneesh Kumar K.V * 9p dir can be of the form dirname,tag_name or 159b4422bf3SAneesh Kumar K.V * just dirname. In the later case we use the 160b4422bf3SAneesh Kumar K.V * default tag name 161b4422bf3SAneesh Kumar K.V */ 162b4422bf3SAneesh Kumar K.V tag_name = strstr(arg, ","); 163b4422bf3SAneesh Kumar K.V if (tag_name) { 164b4422bf3SAneesh Kumar K.V *tag_name = '\0'; 165b4422bf3SAneesh Kumar K.V tag_name++; 166b4422bf3SAneesh Kumar K.V } 16754f6802dSPekka Enberg if (realpath(arg, tmp)) { 168c7838fbdSSasha Levin if (virtio_9p__register(kvm, tmp, tag_name) < 0) 16954f6802dSPekka Enberg die("Unable to initialize virtio 9p"); 17054f6802dSPekka Enberg } else 171b4422bf3SAneesh Kumar K.V die("Failed resolving 9p path"); 172b4422bf3SAneesh Kumar K.V return 0; 173b4422bf3SAneesh Kumar K.V } 174b4422bf3SAneesh Kumar K.V 175*1add4b76SSasha Levin static int tty_parser(const struct option *opt, const char *arg, int unset) 176*1add4b76SSasha Levin { 177*1add4b76SSasha Levin int tty = atoi(arg); 178*1add4b76SSasha Levin 179*1add4b76SSasha Levin term_set_tty(tty); 180*1add4b76SSasha Levin 181*1add4b76SSasha Levin return 0; 182*1add4b76SSasha Levin } 183*1add4b76SSasha Levin 18495d13a52SSasha Levin static int shmem_parser(const struct option *opt, const char *arg, int unset) 18595d13a52SSasha Levin { 18672f1ad6dSSasha Levin const u64 default_size = SHMEM_DEFAULT_SIZE; 18772f1ad6dSSasha Levin const u64 default_phys_addr = SHMEM_DEFAULT_ADDR; 18895d13a52SSasha Levin const char *default_handle = SHMEM_DEFAULT_HANDLE; 18995d13a52SSasha Levin struct shmem_info *si = malloc(sizeof(struct shmem_info)); 19072f1ad6dSSasha Levin u64 phys_addr; 19172f1ad6dSSasha Levin u64 size; 19295d13a52SSasha Levin char *handle = NULL; 19395d13a52SSasha Levin int create = 0; 19495d13a52SSasha Levin const char *p = arg; 19595d13a52SSasha Levin char *next; 19695d13a52SSasha Levin int base = 10; 19795d13a52SSasha Levin int verbose = 0; 19895d13a52SSasha Levin 19995d13a52SSasha Levin const int skip_pci = strlen("pci:"); 20095d13a52SSasha Levin if (verbose) 20195d13a52SSasha Levin pr_info("shmem_parser(%p,%s,%d)", opt, arg, unset); 20295d13a52SSasha Levin /* parse out optional addr family */ 20395d13a52SSasha Levin if (strcasestr(p, "pci:")) { 20495d13a52SSasha Levin p += skip_pci; 20595d13a52SSasha Levin } else if (strcasestr(p, "mem:")) { 20695d13a52SSasha Levin die("I can't add to E820 map yet.\n"); 20795d13a52SSasha Levin } 20895d13a52SSasha Levin /* parse out physical addr */ 20995d13a52SSasha Levin base = 10; 21095d13a52SSasha Levin if (strcasestr(p, "0x")) 21195d13a52SSasha Levin base = 16; 21295d13a52SSasha Levin phys_addr = strtoll(p, &next, base); 21395d13a52SSasha Levin if (next == p && phys_addr == 0) { 21495d13a52SSasha Levin pr_info("shmem: no physical addr specified, using default."); 21595d13a52SSasha Levin phys_addr = default_phys_addr; 21695d13a52SSasha Levin } 21795d13a52SSasha Levin if (*next != ':' && *next != '\0') 21895d13a52SSasha Levin die("shmem: unexpected chars after phys addr.\n"); 21995d13a52SSasha Levin if (*next == '\0') 22095d13a52SSasha Levin p = next; 22195d13a52SSasha Levin else 22295d13a52SSasha Levin p = next + 1; 22395d13a52SSasha Levin /* parse out size */ 22495d13a52SSasha Levin base = 10; 22595d13a52SSasha Levin if (strcasestr(p, "0x")) 22695d13a52SSasha Levin base = 16; 22795d13a52SSasha Levin size = strtoll(p, &next, base); 22895d13a52SSasha Levin if (next == p && size == 0) { 22995d13a52SSasha Levin pr_info("shmem: no size specified, using default."); 23095d13a52SSasha Levin size = default_size; 23195d13a52SSasha Levin } 23295d13a52SSasha Levin /* look for [KMGkmg][Bb]* uses base 2. */ 23395d13a52SSasha Levin int skip_B = 0; 23495d13a52SSasha Levin if (strspn(next, "KMGkmg")) { /* might have a prefix */ 23595d13a52SSasha Levin if (*(next + 1) == 'B' || *(next + 1) == 'b') 23695d13a52SSasha Levin skip_B = 1; 23795d13a52SSasha Levin switch (*next) { 23895d13a52SSasha Levin case 'K': 23995d13a52SSasha Levin case 'k': 24095d13a52SSasha Levin size = size << KB_SHIFT; 24195d13a52SSasha Levin break; 24295d13a52SSasha Levin case 'M': 24395d13a52SSasha Levin case 'm': 24495d13a52SSasha Levin size = size << MB_SHIFT; 24595d13a52SSasha Levin break; 24695d13a52SSasha Levin case 'G': 24795d13a52SSasha Levin case 'g': 24895d13a52SSasha Levin size = size << GB_SHIFT; 24995d13a52SSasha Levin break; 25095d13a52SSasha Levin default: 25195d13a52SSasha Levin die("shmem: bug in detecting size prefix."); 25295d13a52SSasha Levin break; 25395d13a52SSasha Levin } 25495d13a52SSasha Levin next += 1 + skip_B; 25595d13a52SSasha Levin } 25695d13a52SSasha Levin if (*next != ':' && *next != '\0') { 25795d13a52SSasha Levin die("shmem: unexpected chars after phys size. <%c><%c>\n", 25895d13a52SSasha Levin *next, *p); 25995d13a52SSasha Levin } 26095d13a52SSasha Levin if (*next == '\0') 26195d13a52SSasha Levin p = next; 26295d13a52SSasha Levin else 26395d13a52SSasha Levin p = next + 1; 26495d13a52SSasha Levin /* parse out optional shmem handle */ 26595d13a52SSasha Levin const int skip_handle = strlen("handle="); 26695d13a52SSasha Levin next = strcasestr(p, "handle="); 26795d13a52SSasha Levin if (*p && next) { 26895d13a52SSasha Levin if (p != next) 26995d13a52SSasha Levin die("unexpected chars before handle\n"); 27095d13a52SSasha Levin p += skip_handle; 27195d13a52SSasha Levin next = strchrnul(p, ':'); 27295d13a52SSasha Levin if (next - p) { 27395d13a52SSasha Levin handle = malloc(next - p + 1); 27495d13a52SSasha Levin strncpy(handle, p, next - p); 27595d13a52SSasha Levin handle[next - p] = '\0'; /* just in case. */ 27695d13a52SSasha Levin } 27795d13a52SSasha Levin if (*next == '\0') 27895d13a52SSasha Levin p = next; 27995d13a52SSasha Levin else 28095d13a52SSasha Levin p = next + 1; 28195d13a52SSasha Levin } 28295d13a52SSasha Levin /* parse optional create flag to see if we should create shm seg. */ 28395d13a52SSasha Levin if (*p && strcasestr(p, "create")) { 28495d13a52SSasha Levin create = 1; 28595d13a52SSasha Levin p += strlen("create"); 28695d13a52SSasha Levin } 28795d13a52SSasha Levin if (*p != '\0') 28895d13a52SSasha Levin die("shmem: unexpected trailing chars\n"); 28995d13a52SSasha Levin if (handle == NULL) { 29095d13a52SSasha Levin handle = malloc(strlen(default_handle) + 1); 29195d13a52SSasha Levin strcpy(handle, default_handle); 29295d13a52SSasha Levin } 29395d13a52SSasha Levin if (verbose) { 29472f1ad6dSSasha Levin pr_info("shmem: phys_addr = %llx", phys_addr); 29572f1ad6dSSasha Levin pr_info("shmem: size = %llx", size); 29695d13a52SSasha Levin pr_info("shmem: handle = %s", handle); 29795d13a52SSasha Levin pr_info("shmem: create = %d", create); 29895d13a52SSasha Levin } 29995d13a52SSasha Levin 30095d13a52SSasha Levin si->phys_addr = phys_addr; 30195d13a52SSasha Levin si->size = size; 30295d13a52SSasha Levin si->handle = handle; 30395d13a52SSasha Levin si->create = create; 30495d13a52SSasha Levin pci_shmem__register_mem(si); /* ownership of si, etc. passed on. */ 30595d13a52SSasha Levin return 0; 30695d13a52SSasha Levin } 307b4422bf3SAneesh Kumar K.V 308f967c427SPrasad Joshi static const struct option options[] = { 3095e3af62dSSasha Levin OPT_GROUP("Basic options:"), 3105358b0e6SSasha Levin OPT_STRING('\0', "name", &guest_name, "guest name", 3115358b0e6SSasha Levin "A name for the guest"), 31280b1f72fSPekka Enberg OPT_INTEGER('c', "cpus", &nrcpus, "Number of CPUs"), 313f967c427SPrasad Joshi OPT_U64('m', "mem", &ram_size, "Virtual machine memory size in MiB."), 31495d13a52SSasha Levin OPT_CALLBACK('\0', "shmem", NULL, 31595d13a52SSasha Levin "[pci:]<addr>:<size>[:handle=<handle>][:create]", 31695d13a52SSasha Levin "Share host shmem with guest via pci device", 31795d13a52SSasha Levin shmem_parser), 318cadb9ab7SAsias He OPT_CALLBACK('d', "disk", NULL, "image or rootfs_dir", "Disk image or rootfs directory", img_name_parser), 31982d2f21eSSasha Levin OPT_BOOLEAN('\0', "balloon", &balloon, "Enable virtio balloon"), 3205ffd4178SJohn Floren OPT_BOOLEAN('\0', "vnc", &vnc, "Enable VNC framebuffer"), 3213f838fecSPekka Enberg OPT_BOOLEAN('\0', "sdl", &sdl, "Enable SDL framebuffer"), 322cf55d6aeSLiming Wang OPT_BOOLEAN('\0', "rng", &virtio_rng, "Enable virtio Random Number Generator"), 3238b7565e8SAsias He OPT_CALLBACK('\0', "9p", NULL, "dir_to_share,tag_name", 3248b7565e8SAsias He "Enable virtio 9p to share files between host and guest", virtio_9p_rootdir_parser), 3258b7565e8SAsias He OPT_STRING('\0', "console", &console, "serial or virtio", 3268b7565e8SAsias He "Console to use"), 3278b7565e8SAsias He OPT_STRING('\0', "dev", &dev, "device_file", "KVM device file"), 328*1add4b76SSasha Levin OPT_CALLBACK('\0', "tty", NULL, "tty id", 329*1add4b76SSasha Levin "Remap guest TTY into a pty on the host", 330*1add4b76SSasha Levin tty_parser), 3315e3af62dSSasha Levin 3325e3af62dSSasha Levin OPT_GROUP("Kernel options:"), 3335e3af62dSSasha Levin OPT_STRING('k', "kernel", &kernel_filename, "kernel", 3345e3af62dSSasha Levin "Kernel to boot in virtual machine"), 335d6c19027SAsias He OPT_STRING('i', "initrd", &initrd_filename, "initrd", 3365e3af62dSSasha Levin "Initial RAM disk image"), 3375e3af62dSSasha Levin OPT_STRING('p', "params", &kernel_cmdline, "params", 3385e3af62dSSasha Levin "Kernel command line arguments"), 3395e3af62dSSasha Levin 3404d67c820SSasha Levin OPT_GROUP("Networking options:"), 341ec7674d7SAsias He OPT_STRING('n', "network", &network, "user, tap, none", 3424d67c820SSasha Levin "Network to use"), 343e80ddf6aSAsias He OPT_STRING('\0', "host-ip", &host_ip, "a.b.c.d", 3444d67c820SSasha Levin "Assign this address to the host side networking"), 345bb8ffd2fSAsias He OPT_STRING('\0', "guest-ip", &guest_ip, "a.b.c.d", 346bb8ffd2fSAsias He "Assign this address to the guest side networking"), 347d7098b9bSAsias He OPT_STRING('\0', "host-mac", &host_mac, "aa:bb:cc:dd:ee:ff", 348d7098b9bSAsias He "Assign this address to the host side NIC"), 349a4e724ddSSasha Levin OPT_STRING('\0', "guest-mac", &guest_mac, "aa:bb:cc:dd:ee:ff", 350a4e724ddSSasha Levin "Assign this address to the guest side NIC"), 35173b7d038SAmos Kong OPT_STRING('\0', "tapscript", &script, "Script path", 35273b7d038SAmos Kong "Assign a script to process created tap device"), 353d6c19027SAsias He 354890364f8SCyrill Gorcunov OPT_GROUP("BIOS options:"), 355890364f8SCyrill Gorcunov OPT_INTEGER('\0', "vidmode", &vidmode, 356890364f8SCyrill Gorcunov "Video mode"), 357890364f8SCyrill Gorcunov 3585e3af62dSSasha Levin OPT_GROUP("Debug options:"), 359ed036f03SCyrill Gorcunov OPT_BOOLEAN('\0', "debug", &do_debug_print, 360ed036f03SCyrill Gorcunov "Enable debug messages"), 361d6c19027SAsias He OPT_BOOLEAN('\0', "debug-single-step", &single_step, 362d6c19027SAsias He "Enable single stepping"), 363001690a4SSasha Levin OPT_BOOLEAN('\0', "debug-ioport", &ioport_debug, 364d6c19027SAsias He "Enable ioport debugging"), 365001690a4SSasha Levin OPT_INTEGER('\0', "debug-iodelay", &debug_iodelay, 366aa400b00SPrasad Joshi "Delay IO by millisecond"), 367f967c427SPrasad Joshi OPT_END() 368f967c427SPrasad Joshi }; 369f967c427SPrasad Joshi 370b5b501ccSIngo Molnar /* 371b5b501ccSIngo Molnar * Serialize debug printout so that the output of multiple vcpus does not 372b5b501ccSIngo Molnar * get mixed up: 373b5b501ccSIngo Molnar */ 374cffeab25SIngo Molnar static int printout_done; 375b5b501ccSIngo Molnar 37643119af7SPekka Enberg static void handle_sigusr1(int sig) 37743119af7SPekka Enberg { 37843119af7SPekka Enberg struct kvm_cpu *cpu = current_kvm_cpu; 37943119af7SPekka Enberg 38043119af7SPekka Enberg if (!cpu) 38143119af7SPekka Enberg return; 38243119af7SPekka Enberg 383b5b501ccSIngo Molnar printf("\n #\n # vCPU #%ld's dump:\n #\n", cpu->cpu_id); 38443119af7SPekka Enberg kvm_cpu__show_registers(cpu); 38543119af7SPekka Enberg kvm_cpu__show_code(cpu); 38643119af7SPekka Enberg kvm_cpu__show_page_tables(cpu); 387b5b501ccSIngo Molnar fflush(stdout); 388cffeab25SIngo Molnar printout_done = 1; 389cffeab25SIngo Molnar mb(); 39043119af7SPekka Enberg } 39143119af7SPekka Enberg 392d94e22b9SSasha Levin /* Pause/resume the guest using SIGUSR2 */ 393d94e22b9SSasha Levin static int is_paused; 394d94e22b9SSasha Levin 395d94e22b9SSasha Levin static void handle_sigusr2(int sig) 396d94e22b9SSasha Levin { 39702317b74SSasha Levin if (sig == SIGKVMRESUME && is_paused) 398d94e22b9SSasha Levin kvm__continue(); 39902317b74SSasha Levin else if (sig == SIGUSR2 && !is_paused) 400d94e22b9SSasha Levin kvm__pause(); 40102317b74SSasha Levin else 40202317b74SSasha Levin return; 403d94e22b9SSasha Levin 404d94e22b9SSasha Levin is_paused = !is_paused; 405d94e22b9SSasha Levin pr_info("Guest %s\n", is_paused ? "paused" : "resumed"); 406d94e22b9SSasha Levin } 407d94e22b9SSasha Levin 4089e854d1aSPekka Enberg static void handle_sigquit(int sig) 4099e854d1aSPekka Enberg { 4109e854d1aSPekka Enberg int i; 4119e854d1aSPekka Enberg 4129e854d1aSPekka Enberg for (i = 0; i < nrcpus; i++) { 4139e854d1aSPekka Enberg struct kvm_cpu *cpu = kvm_cpus[i]; 4149e854d1aSPekka Enberg 41543119af7SPekka Enberg if (!cpu) 41643119af7SPekka Enberg continue; 41743119af7SPekka Enberg 418cffeab25SIngo Molnar printout_done = 0; 41943119af7SPekka Enberg pthread_kill(cpu->thread, SIGUSR1); 420cffeab25SIngo Molnar /* 421cffeab25SIngo Molnar * Wait for the vCPU to dump state before signalling 422cffeab25SIngo Molnar * the next thread. Since this is debug code it does 423cffeab25SIngo Molnar * not matter that we are burning CPU time a bit: 424cffeab25SIngo Molnar */ 425cffeab25SIngo Molnar while (!printout_done) 426cffeab25SIngo Molnar mb(); 4279e854d1aSPekka Enberg } 4289e854d1aSPekka Enberg 4299e854d1aSPekka Enberg serial8250__inject_sysrq(kvm); 4309e854d1aSPekka Enberg } 4319e854d1aSPekka Enberg 4329e854d1aSPekka Enberg static void handle_sigalrm(int sig) 4339e854d1aSPekka Enberg { 4349e854d1aSPekka Enberg serial8250__inject_interrupt(kvm); 4359e854d1aSPekka Enberg virtio_console__inject_interrupt(kvm); 4369e854d1aSPekka Enberg } 4379e854d1aSPekka Enberg 438daf4cb5aSSasha Levin static void handle_sigstop(int sig) 439daf4cb5aSSasha Levin { 440daf4cb5aSSasha Levin kvm_cpu__reboot(); 441daf4cb5aSSasha Levin } 442daf4cb5aSSasha Levin 4435ee154d1SPekka Enberg static void *kvm_cpu_thread(void *arg) 4445ee154d1SPekka Enberg { 445d77a9efaSCyrill Gorcunov current_kvm_cpu = arg; 4465ee154d1SPekka Enberg 447d77a9efaSCyrill Gorcunov if (kvm_cpu__start(current_kvm_cpu)) 4485ee154d1SPekka Enberg goto panic_kvm; 4495ee154d1SPekka Enberg 450d77a9efaSCyrill Gorcunov kvm_cpu__delete(current_kvm_cpu); 4515ee154d1SPekka Enberg 4525ee154d1SPekka Enberg return (void *) (intptr_t) 0; 4535ee154d1SPekka Enberg 4545ee154d1SPekka Enberg panic_kvm: 4553fdf659dSSasha Levin fprintf(stderr, "KVM exit reason: %u (\"%s\")\n", 456d77a9efaSCyrill Gorcunov current_kvm_cpu->kvm_run->exit_reason, 457d77a9efaSCyrill Gorcunov kvm_exit_reasons[current_kvm_cpu->kvm_run->exit_reason]); 458d77a9efaSCyrill Gorcunov if (current_kvm_cpu->kvm_run->exit_reason == KVM_EXIT_UNKNOWN) 4595ee154d1SPekka Enberg fprintf(stderr, "KVM exit code: 0x%Lu\n", 460d77a9efaSCyrill Gorcunov current_kvm_cpu->kvm_run->hw.hardware_exit_reason); 4618e5accedSPekka Enberg 462d77a9efaSCyrill Gorcunov kvm_cpu__show_registers(current_kvm_cpu); 463d77a9efaSCyrill Gorcunov kvm_cpu__show_code(current_kvm_cpu); 464d77a9efaSCyrill Gorcunov kvm_cpu__show_page_tables(current_kvm_cpu); 4655ee154d1SPekka Enberg 466d77a9efaSCyrill Gorcunov kvm_cpu__delete(current_kvm_cpu); 4675ee154d1SPekka Enberg 4685ee154d1SPekka Enberg return (void *) (intptr_t) 1; 4695ee154d1SPekka Enberg } 4705ee154d1SPekka Enberg 471e08c0896SPrasad Joshi static char kernel[PATH_MAX]; 472b0b42ba0SPekka Enberg 473b0b42ba0SPekka Enberg static const char *host_kernels[] = { 474e08c0896SPrasad Joshi "/boot/vmlinuz", 475e08c0896SPrasad Joshi "/boot/bzImage", 476e08c0896SPrasad Joshi NULL 477e08c0896SPrasad Joshi }; 478b0b42ba0SPekka Enberg 479b0b42ba0SPekka Enberg static const char *default_kernels[] = { 480e08c0896SPrasad Joshi "./bzImage", 481e08c0896SPrasad Joshi "../../arch/x86/boot/bzImage", 482e08c0896SPrasad Joshi NULL 483e08c0896SPrasad Joshi }; 4848329f30bSPekka Enberg 485b0b42ba0SPekka Enberg static const char *default_vmlinux[] = { 486b0b42ba0SPekka Enberg "../../../vmlinux", 487b0b42ba0SPekka Enberg "../../vmlinux", 488b0b42ba0SPekka Enberg NULL 489b0b42ba0SPekka Enberg }; 490b0b42ba0SPekka Enberg 491e08c0896SPrasad Joshi static void kernel_usage_with_options(void) 4928329f30bSPekka Enberg { 493e08c0896SPrasad Joshi const char **k; 4948329f30bSPekka Enberg struct utsname uts; 495e08c0896SPrasad Joshi 496e08c0896SPrasad Joshi fprintf(stderr, "Fatal: could not find default kernel image in:\n"); 49765182f37SPrasad Joshi k = &default_kernels[0]; 498e08c0896SPrasad Joshi while (*k) { 499e08c0896SPrasad Joshi fprintf(stderr, "\t%s\n", *k); 500e08c0896SPrasad Joshi k++; 501e08c0896SPrasad Joshi } 502e08c0896SPrasad Joshi 503e08c0896SPrasad Joshi if (uname(&uts) < 0) 504e08c0896SPrasad Joshi return; 505e08c0896SPrasad Joshi 506e08c0896SPrasad Joshi k = &host_kernels[0]; 507e08c0896SPrasad Joshi while (*k) { 508e08c0896SPrasad Joshi if (snprintf(kernel, PATH_MAX, "%s-%s", *k, uts.release) < 0) 509e08c0896SPrasad Joshi return; 510e08c0896SPrasad Joshi fprintf(stderr, "\t%s\n", kernel); 511e08c0896SPrasad Joshi k++; 512e08c0896SPrasad Joshi } 513a33389d8SPrasad Joshi fprintf(stderr, "\nPlease see 'kvm run --help' for more options.\n\n"); 514e08c0896SPrasad Joshi } 515e08c0896SPrasad Joshi 51660ded003SPekka Enberg static u64 host_ram_size(void) 51760ded003SPekka Enberg { 51860ded003SPekka Enberg long page_size; 51960ded003SPekka Enberg long nr_pages; 52060ded003SPekka Enberg 52160ded003SPekka Enberg nr_pages = sysconf(_SC_PHYS_PAGES); 522d63c5ce6SPekka Enberg if (nr_pages < 0) { 5234542f276SCyrill Gorcunov pr_warning("sysconf(_SC_PHYS_PAGES) failed"); 524d63c5ce6SPekka Enberg return 0; 525d63c5ce6SPekka Enberg } 52660ded003SPekka Enberg 52760ded003SPekka Enberg page_size = sysconf(_SC_PAGE_SIZE); 528d63c5ce6SPekka Enberg if (page_size < 0) { 5294542f276SCyrill Gorcunov pr_warning("sysconf(_SC_PAGE_SIZE) failed"); 530d63c5ce6SPekka Enberg return 0; 531d63c5ce6SPekka Enberg } 53260ded003SPekka Enberg 53360ded003SPekka Enberg return (nr_pages * page_size) >> MB_SHIFT; 53460ded003SPekka Enberg } 53560ded003SPekka Enberg 53618bd8c3bSPekka Enberg /* 53718bd8c3bSPekka Enberg * If user didn't specify how much memory it wants to allocate for the guest, 53818bd8c3bSPekka Enberg * avoid filling the whole host RAM. 53918bd8c3bSPekka Enberg */ 54018bd8c3bSPekka Enberg #define RAM_SIZE_RATIO 0.8 54118bd8c3bSPekka Enberg 542fd834defSPekka Enberg static u64 get_ram_size(int nr_cpus) 543fd834defSPekka Enberg { 54406761c76SPekka Enberg u64 available; 54506761c76SPekka Enberg u64 ram_size; 546fd834defSPekka Enberg 547fd834defSPekka Enberg ram_size = 64 * (nr_cpus + 3); 548fd834defSPekka Enberg 54960ded003SPekka Enberg available = host_ram_size() * RAM_SIZE_RATIO; 550d63c5ce6SPekka Enberg if (!available) 551d63c5ce6SPekka Enberg available = MIN_RAM_SIZE_MB; 552fd834defSPekka Enberg 553fd834defSPekka Enberg if (ram_size > available) 554fd834defSPekka Enberg ram_size = available; 555fd834defSPekka Enberg 556fd834defSPekka Enberg return ram_size; 557fd834defSPekka Enberg } 558fd834defSPekka Enberg 559e08c0896SPrasad Joshi static const char *find_kernel(void) 560e08c0896SPrasad Joshi { 561e08c0896SPrasad Joshi const char **k; 5628329f30bSPekka Enberg struct stat st; 563e08c0896SPrasad Joshi struct utsname uts; 564e08c0896SPrasad Joshi 56565182f37SPrasad Joshi k = &default_kernels[0]; 566e08c0896SPrasad Joshi while (*k) { 567e08c0896SPrasad Joshi if (stat(*k, &st) < 0 || !S_ISREG(st.st_mode)) { 568e08c0896SPrasad Joshi k++; 569e08c0896SPrasad Joshi continue; 570e08c0896SPrasad Joshi } 571e08c0896SPrasad Joshi strncpy(kernel, *k, PATH_MAX); 572e08c0896SPrasad Joshi return kernel; 573e08c0896SPrasad Joshi } 5748329f30bSPekka Enberg 5758329f30bSPekka Enberg if (uname(&uts) < 0) 5768329f30bSPekka Enberg return NULL; 5778329f30bSPekka Enberg 578e08c0896SPrasad Joshi k = &host_kernels[0]; 579e08c0896SPrasad Joshi while (*k) { 580e08c0896SPrasad Joshi if (snprintf(kernel, PATH_MAX, "%s-%s", *k, uts.release) < 0) 5818329f30bSPekka Enberg return NULL; 5828329f30bSPekka Enberg 583e08c0896SPrasad Joshi if (stat(kernel, &st) < 0 || !S_ISREG(st.st_mode)) { 584e08c0896SPrasad Joshi k++; 585e08c0896SPrasad Joshi continue; 586e08c0896SPrasad Joshi } 587e08c0896SPrasad Joshi return kernel; 5888329f30bSPekka Enberg 589e08c0896SPrasad Joshi } 5908329f30bSPekka Enberg return NULL; 5918329f30bSPekka Enberg } 5928329f30bSPekka Enberg 593b0b42ba0SPekka Enberg static const char *find_vmlinux(void) 594b0b42ba0SPekka Enberg { 595b0b42ba0SPekka Enberg const char **vmlinux; 596b0b42ba0SPekka Enberg 597b0b42ba0SPekka Enberg vmlinux = &default_vmlinux[0]; 598b0b42ba0SPekka Enberg while (*vmlinux) { 599b0b42ba0SPekka Enberg struct stat st; 600b0b42ba0SPekka Enberg 601b0b42ba0SPekka Enberg if (stat(*vmlinux, &st) < 0 || !S_ISREG(st.st_mode)) { 602b0b42ba0SPekka Enberg vmlinux++; 603b0b42ba0SPekka Enberg continue; 604b0b42ba0SPekka Enberg } 605b0b42ba0SPekka Enberg return *vmlinux; 606b0b42ba0SPekka Enberg } 607b0b42ba0SPekka Enberg return NULL; 608b0b42ba0SPekka Enberg } 609b0b42ba0SPekka Enberg 610f6677a1dSAmerigo Wang void kvm_run_help(void) 611f6677a1dSAmerigo Wang { 612f6677a1dSAmerigo Wang usage_with_options(run_usage, options); 613f6677a1dSAmerigo Wang } 614f6677a1dSAmerigo Wang 615f967c427SPrasad Joshi int kvm_cmd_run(int argc, const char **argv, const char *prefix) 616f967c427SPrasad Joshi { 617b0b42ba0SPekka Enberg struct virtio_net_parameters net_params; 6182d96f6b6SSasha Levin static char real_cmdline[2048], default_name[20]; 619aba1efa5SPekka Enberg struct framebuffer *fb = NULL; 620384922b3SPekka Enberg unsigned int nr_online_cpus; 6215ee154d1SPekka Enberg int exit_code = 0; 6228259b8ccSSasha Levin int max_cpus, recommended_cpus; 623b0b42ba0SPekka Enberg int i; 62449e5227dSSasha Levin void *ret; 625f967c427SPrasad Joshi 6265ee154d1SPekka Enberg signal(SIGALRM, handle_sigalrm); 627f967c427SPrasad Joshi signal(SIGQUIT, handle_sigquit); 62843119af7SPekka Enberg signal(SIGUSR1, handle_sigusr1); 629d94e22b9SSasha Levin signal(SIGUSR2, handle_sigusr2); 630daf4cb5aSSasha Levin signal(SIGKVMSTOP, handle_sigstop); 63102317b74SSasha Levin signal(SIGKVMRESUME, handle_sigusr2); 63254a4c4a6SLiming Wang /* ignore balloon signal by default if not enable balloon optiion */ 63354a4c4a6SLiming Wang signal(SIGKVMADDMEM, SIG_IGN); 63454a4c4a6SLiming Wang signal(SIGKVMDELMEM, SIG_IGN); 635f967c427SPrasad Joshi 636cfd63bbbSSasha Levin nr_online_cpus = sysconf(_SC_NPROCESSORS_ONLN); 637cfd63bbbSSasha Levin 638f967c427SPrasad Joshi while (argc != 0) { 639f967c427SPrasad Joshi argc = parse_options(argc, argv, options, run_usage, 640f967c427SPrasad Joshi PARSE_OPT_STOP_AT_NON_OPTION); 641f967c427SPrasad Joshi if (argc != 0) { 642f967c427SPrasad Joshi if (kernel_filename) { 643f967c427SPrasad Joshi fprintf(stderr, "Cannot handle parameter: " 644f967c427SPrasad Joshi "%s\n", argv[0]); 645f967c427SPrasad Joshi usage_with_options(run_usage, options); 646f967c427SPrasad Joshi return EINVAL; 647f967c427SPrasad Joshi } 648f967c427SPrasad Joshi /* first unhandled parameter is treated as a kernel 649f967c427SPrasad Joshi image 650f967c427SPrasad Joshi */ 651f967c427SPrasad Joshi kernel_filename = argv[0]; 652f967c427SPrasad Joshi argv++; 653f967c427SPrasad Joshi argc--; 654f967c427SPrasad Joshi } 655f967c427SPrasad Joshi 656f967c427SPrasad Joshi } 657f967c427SPrasad Joshi 65845bc2f02SPekka Enberg if (!kernel_filename) 659e08c0896SPrasad Joshi kernel_filename = find_kernel(); 6608329f30bSPekka Enberg 6618329f30bSPekka Enberg if (!kernel_filename) { 662e08c0896SPrasad Joshi kernel_usage_with_options(); 6638329f30bSPekka Enberg return EINVAL; 6648329f30bSPekka Enberg } 6658329f30bSPekka Enberg 666b0b42ba0SPekka Enberg vmlinux_filename = find_vmlinux(); 667b0b42ba0SPekka Enberg 668cfd63bbbSSasha Levin if (nrcpus == 0) 669cfd63bbbSSasha Levin nrcpus = nr_online_cpus; 670cfd63bbbSSasha Levin else if (nrcpus < 1 || nrcpus > KVM_NR_CPUS) 671d77a9efaSCyrill Gorcunov die("Number of CPUs %d is out of [1;%d] range", nrcpus, KVM_NR_CPUS); 672d77a9efaSCyrill Gorcunov 673fd834defSPekka Enberg if (!ram_size) 674fd834defSPekka Enberg ram_size = get_ram_size(nrcpus); 675fd834defSPekka Enberg 676a2a002f9SIngo Molnar if (ram_size < MIN_RAM_SIZE_MB) 677a2a002f9SIngo Molnar die("Not enough memory specified: %lluMB (min %lluMB)", ram_size, MIN_RAM_SIZE_MB); 678a2a002f9SIngo Molnar 67960ded003SPekka Enberg if (ram_size > host_ram_size()) 6804542f276SCyrill Gorcunov pr_warning("Guest memory size %lluMB exceeds host physical RAM size %lluMB", ram_size, host_ram_size()); 68160ded003SPekka Enberg 682f967c427SPrasad Joshi ram_size <<= MB_SHIFT; 683f967c427SPrasad Joshi 6845929637bSAsias He if (!dev) 6855929637bSAsias He dev = DEFAULT_KVM_DEV; 686f967c427SPrasad Joshi 6879aa4a0ebSAsias He if (!console) 6889aa4a0ebSAsias He console = DEFAULT_CONSOLE; 6899aa4a0ebSAsias He 6909aa4a0ebSAsias He if (!strncmp(console, "virtio", 6)) 691f967c427SPrasad Joshi active_console = CONSOLE_VIRTIO; 6929aa4a0ebSAsias He else 6939aa4a0ebSAsias He active_console = CONSOLE_8250; 694f967c427SPrasad Joshi 695e80ddf6aSAsias He if (!host_ip) 696e80ddf6aSAsias He host_ip = DEFAULT_HOST_ADDR; 6974d67c820SSasha Levin 698bb8ffd2fSAsias He if (!guest_ip) 699bb8ffd2fSAsias He guest_ip = DEFAULT_GUEST_ADDR; 700bb8ffd2fSAsias He 701a4e724ddSSasha Levin if (!guest_mac) 702a4e724ddSSasha Levin guest_mac = DEFAULT_GUEST_MAC; 703a4e724ddSSasha Levin 704d7098b9bSAsias He if (!host_mac) 705d7098b9bSAsias He host_mac = DEFAULT_HOST_MAC; 706d7098b9bSAsias He 70773b7d038SAmos Kong if (!script) 70873b7d038SAmos Kong script = DEFAULT_SCRIPT; 70973b7d038SAmos Kong 710b0b42ba0SPekka Enberg symbol__init(vmlinux_filename); 711b0b42ba0SPekka Enberg 712f967c427SPrasad Joshi term_init(); 713f967c427SPrasad Joshi 7142d96f6b6SSasha Levin if (!guest_name) { 7152d96f6b6SSasha Levin sprintf(default_name, "guest-%u", getpid()); 7162d96f6b6SSasha Levin guest_name = default_name; 7172d96f6b6SSasha Levin } 7182d96f6b6SSasha Levin 7195929637bSAsias He kvm = kvm__init(dev, ram_size, guest_name); 720f967c427SPrasad Joshi 7215f0a22b7SSasha Levin irq__init(kvm); 7225f0a22b7SSasha Levin 7236d6a4d41SPekka Enberg kvm->single_step = single_step; 7246d6a4d41SPekka Enberg 72537f3d50eSSasha Levin ioeventfd__init(); 72637f3d50eSSasha Levin 727384922b3SPekka Enberg max_cpus = kvm__max_cpus(kvm); 7288259b8ccSSasha Levin recommended_cpus = kvm__recommended_cpus(kvm); 729384922b3SPekka Enberg 730384922b3SPekka Enberg if (nrcpus > max_cpus) { 731384922b3SPekka Enberg printf(" # Limit the number of CPUs to %d\n", max_cpus); 732384922b3SPekka Enberg kvm->nrcpus = max_cpus; 7338259b8ccSSasha Levin } else if (nrcpus > recommended_cpus) { 7348259b8ccSSasha Levin printf(" # Warning: The maximum recommended amount of VCPUs" 7358259b8ccSSasha Levin " is %d\n", recommended_cpus); 736384922b3SPekka Enberg } 737384922b3SPekka Enberg 7380c7c14a7SCyrill Gorcunov kvm->nrcpus = nrcpus; 7390c7c14a7SCyrill Gorcunov 740890364f8SCyrill Gorcunov /* 741890364f8SCyrill Gorcunov * vidmode should be either specified 742890364f8SCyrill Gorcunov * either set by default 743890364f8SCyrill Gorcunov */ 744890364f8SCyrill Gorcunov if (vnc || sdl) { 745890364f8SCyrill Gorcunov if (vidmode == -1) 746890364f8SCyrill Gorcunov vidmode = 0x312; 747890364f8SCyrill Gorcunov } else 748890364f8SCyrill Gorcunov vidmode = 0; 749890364f8SCyrill Gorcunov 75026c853e4SPrasad Joshi memset(real_cmdline, 0, sizeof(real_cmdline)); 751d1f3131dSSasha Levin strcpy(real_cmdline, "notsc noapic noacpi pci=conf1 reboot=k panic=1 i8042.direct=1 " 752d1f3131dSSasha Levin "i8042.dumbkbd=1 i8042.nopnp=1"); 7533f838fecSPekka Enberg if (vnc || sdl) { 7545ffd4178SJohn Floren strcat(real_cmdline, " video=vesafb console=tty0"); 755890364f8SCyrill Gorcunov } else 756d1f3131dSSasha Levin strcat(real_cmdline, " console=ttyS0 earlyprintk=serial i8042.noaux=1"); 757d74181ccSSasha Levin strcat(real_cmdline, " "); 75826c853e4SPrasad Joshi if (kernel_cmdline) 75926c853e4SPrasad Joshi strlcat(real_cmdline, kernel_cmdline, sizeof(real_cmdline)); 76026c853e4SPrasad Joshi 76159aa2d30SSasha Levin if (!using_rootfs && !image_filename[0]) { 762c8675741SSasha Levin char tmp[PATH_MAX]; 7636df1471eSPekka Enberg 764c8675741SSasha Levin kvm_setup_create_new("default"); 765c8675741SSasha Levin 766c8675741SSasha Levin snprintf(tmp, PATH_MAX, "%s%s%s", HOME_DIR, KVM_PID_FILE_PATH, "default"); 767c8675741SSasha Levin if (virtio_9p__register(kvm, tmp, "/dev/root") < 0) 768c8675741SSasha Levin die("Unable to initialize virtio 9p"); 769c8675741SSasha Levin if (virtio_9p__register(kvm, "/", "hostfs") < 0) 770c8675741SSasha Levin die("Unable to initialize virtio 9p"); 771c8675741SSasha Levin using_rootfs = custom_rootfs = 1; 7726df1471eSPekka Enberg 7736df1471eSPekka Enberg if (!strstr(real_cmdline, "init=")) 7745fd5abefSPekka Enberg strlcat(real_cmdline, " init=/bin/sh ", sizeof(real_cmdline)); 77526c853e4SPrasad Joshi } 77626c853e4SPrasad Joshi 77782d65b5eSSasha Levin if (using_rootfs) { 778ff42603fSSasha Levin strcat(real_cmdline, " root=/dev/root rw rootflags=rw,trans=virtio,version=9p2000.L rootfstype=9p"); 77982d65b5eSSasha Levin if (custom_rootfs) 780575a9e3fSSasha Levin strcat(real_cmdline, " init=/virt/init ip=dhcp"); 78182d65b5eSSasha Levin } else if (!strstr(real_cmdline, "root=")) { 782ff42603fSSasha Levin strlcat(real_cmdline, " root=/dev/vda rw ", sizeof(real_cmdline)); 78382d65b5eSSasha Levin } 78459aa2d30SSasha Levin 785c1ed214eSPrasad Joshi if (image_count) { 786bcb6aacaSPrasad Joshi kvm->nr_disks = image_count; 787c1ed214eSPrasad Joshi kvm->disks = disk_image__open_all(image_filename, readonly_image, image_count); 788c1ed214eSPrasad Joshi if (!kvm->disks) 789c1ed214eSPrasad Joshi die("Unable to load all disk images."); 79038605e1cSSasha Levin 791bcb6aacaSPrasad Joshi virtio_blk__init_all(kvm); 792f967c427SPrasad Joshi } 793c1ed214eSPrasad Joshi 7942d96f6b6SSasha Levin printf(" # kvm run -k %s -m %Lu -c %d --name %s\n", kernel_filename, ram_size / 1024 / 1024, nrcpus, guest_name); 795471c6facSPekka Enberg 796f967c427SPrasad Joshi if (!kvm__load_kernel(kvm, kernel_filename, initrd_filename, 7975ffd4178SJohn Floren real_cmdline, vidmode)) 798f967c427SPrasad Joshi die("unable to load kernel %s", kernel_filename); 799f967c427SPrasad Joshi 800b0b42ba0SPekka Enberg kvm->vmlinux = vmlinux_filename; 801b0b42ba0SPekka Enberg 802ac38f433SPekka Enberg ioport__setup_legacy(); 803ac38f433SPekka Enberg 80464136c1cSPekka Enberg rtc__init(); 80564136c1cSPekka Enberg 806f967c427SPrasad Joshi serial8250__init(kvm); 807f967c427SPrasad Joshi 808f967c427SPrasad Joshi pci__init(); 809f967c427SPrasad Joshi 8101621292eSSasha Levin if (active_console == CONSOLE_VIRTIO) 811f967c427SPrasad Joshi virtio_console__init(kvm); 812f967c427SPrasad Joshi 81353eca082SSasha Levin if (virtio_rng) 81453eca082SSasha Levin virtio_rng__init(kvm); 81553eca082SSasha Levin 81682d2f21eSSasha Levin if (balloon) 81782d2f21eSSasha Levin virtio_bln__init(kvm); 81882d2f21eSSasha Levin 8194f56d42cSAsias He if (!network) 8204f56d42cSAsias He network = DEFAULT_NETWORK; 8214f56d42cSAsias He 822c7838fbdSSasha Levin virtio_9p__init(kvm); 823c7838fbdSSasha Levin 824ec7674d7SAsias He if (strncmp(network, "none", 4)) { 825bb8ffd2fSAsias He net_params.guest_ip = guest_ip; 826e80ddf6aSAsias He net_params.host_ip = host_ip; 827ec7674d7SAsias He net_params.kvm = kvm; 828ec7674d7SAsias He net_params.script = script; 829a4e724ddSSasha Levin sscanf(guest_mac, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", 830a4e724ddSSasha Levin net_params.guest_mac, 831a4e724ddSSasha Levin net_params.guest_mac+1, 832a4e724ddSSasha Levin net_params.guest_mac+2, 833a4e724ddSSasha Levin net_params.guest_mac+3, 834a4e724ddSSasha Levin net_params.guest_mac+4, 835a4e724ddSSasha Levin net_params.guest_mac+5); 836d7098b9bSAsias He sscanf(host_mac, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", 837d7098b9bSAsias He net_params.host_mac, 838d7098b9bSAsias He net_params.host_mac+1, 839d7098b9bSAsias He net_params.host_mac+2, 840d7098b9bSAsias He net_params.host_mac+3, 841d7098b9bSAsias He net_params.host_mac+4, 842d7098b9bSAsias He net_params.host_mac+5); 843a4e724ddSSasha Levin 844ec7674d7SAsias He if (!strncmp(network, "user", 4)) 845ec7674d7SAsias He net_params.mode = NET_MODE_USER; 846ec7674d7SAsias He else if (!strncmp(network, "tap", 3)) 847ec7674d7SAsias He net_params.mode = NET_MODE_TAP; 848ec7674d7SAsias He else 849ec7674d7SAsias He die("Unkown network mode %s, please use -network user, tap, none", network); 850bdfcfca6SSasha Levin virtio_net__init(&net_params); 851bdfcfca6SSasha Levin } 8524f56d42cSAsias He 853f967c427SPrasad Joshi kvm__start_timer(kvm); 854f967c427SPrasad Joshi 8558ec7e042SSasha Levin kvm__setup_bios(kvm); 8568ec7e042SSasha Levin 857d77a9efaSCyrill Gorcunov for (i = 0; i < nrcpus; i++) { 858d77a9efaSCyrill Gorcunov kvm_cpus[i] = kvm_cpu__init(kvm, i); 859d77a9efaSCyrill Gorcunov if (!kvm_cpus[i]) 8605ee154d1SPekka Enberg die("unable to initialize KVM VCPU"); 861839051d9SSasha Levin } 8625ee154d1SPekka Enberg 863839051d9SSasha Levin kvm__init_ram(kvm); 864839051d9SSasha Levin 865714e5b7fSSasha Levin kbd__init(kvm); 866714e5b7fSSasha Levin 86795d13a52SSasha Levin pci_shmem__init(kvm); 86895d13a52SSasha Levin 8693f838fecSPekka Enberg if (vnc || sdl) 8703f838fecSPekka Enberg fb = vesa__init(kvm); 8713f838fecSPekka Enberg 872e342083cSJohn Floren if (vnc) { 873aba1efa5SPekka Enberg if (fb) 874aba1efa5SPekka Enberg vnc__init(fb); 8753f838fecSPekka Enberg } 8763f838fecSPekka Enberg 8773f838fecSPekka Enberg if (sdl) { 8783f838fecSPekka Enberg if (fb) 8793f838fecSPekka Enberg sdl__init(fb); 8803f838fecSPekka Enberg } 881aba1efa5SPekka Enberg 882aba1efa5SPekka Enberg fb__start(); 883aba1efa5SPekka Enberg 884d60bafe5SSasha Levin thread_pool__init(nr_online_cpus); 88537f3d50eSSasha Levin ioeventfd__start(); 886d60bafe5SSasha Levin 887839051d9SSasha Levin for (i = 0; i < nrcpus; i++) { 888d77a9efaSCyrill Gorcunov if (pthread_create(&kvm_cpus[i]->thread, NULL, kvm_cpu_thread, kvm_cpus[i]) != 0) 8895ee154d1SPekka Enberg die("unable to create KVM VCPU thread"); 8905ee154d1SPekka Enberg } 8915ee154d1SPekka Enberg 89249e5227dSSasha Levin /* Only VCPU #0 is going to exit by itself when shutting down */ 89349e5227dSSasha Levin if (pthread_join(kvm_cpus[0]->thread, &ret) != 0) 89449e5227dSSasha Levin exit_code = 1; 8955ee154d1SPekka Enberg 89649e5227dSSasha Levin for (i = 1; i < nrcpus; i++) { 897c23d9748SSasha Levin if (kvm_cpus[i]->is_running) { 89849e5227dSSasha Levin pthread_kill(kvm_cpus[i]->thread, SIGKVMEXIT); 899d77a9efaSCyrill Gorcunov if (pthread_join(kvm_cpus[i]->thread, &ret) != 0) 9005ee154d1SPekka Enberg die("pthread_join"); 901c23d9748SSasha Levin } 9025ee154d1SPekka Enberg if (ret != NULL) 9035ee154d1SPekka Enberg exit_code = 1; 9045ee154d1SPekka Enberg } 905f967c427SPrasad Joshi 906e6694207SSasha Levin compat__print_all_messages(); 907e6694207SSasha Levin 908aba1efa5SPekka Enberg fb__stop(); 909aba1efa5SPekka Enberg 910a0a1e3c2SPrasad Joshi virtio_blk__delete_all(kvm); 91180ac1d05SSasha Levin virtio_rng__delete_all(kvm); 912a0a1e3c2SPrasad Joshi 9139df47d00SPrasad Joshi disk_image__close_all(kvm->disks, image_count); 914f967c427SPrasad Joshi kvm__delete(kvm); 915f967c427SPrasad Joshi 9165ee154d1SPekka Enberg if (!exit_code) 917f967c427SPrasad Joshi printf("\n # KVM session ended normally.\n"); 918f967c427SPrasad Joshi 9195ee154d1SPekka Enberg return exit_code; 920f967c427SPrasad Joshi } 921