1f967c427SPrasad Joshi #include <stdio.h> 2f967c427SPrasad Joshi #include <string.h> 3f967c427SPrasad Joshi #include <signal.h> 4f967c427SPrasad Joshi #include <unistd.h> 5f967c427SPrasad Joshi #include <stdlib.h> 6f967c427SPrasad Joshi #include <termios.h> 78329f30bSPekka Enberg #include <sys/utsname.h> 88329f30bSPekka Enberg #include <sys/types.h> 98329f30bSPekka Enberg #include <sys/stat.h> 1026c853e4SPrasad Joshi #include <ctype.h> 11f967c427SPrasad Joshi 12f967c427SPrasad Joshi /* user defined header files */ 13f967c427SPrasad Joshi #include <linux/types.h> 14f967c427SPrasad Joshi #include <kvm/kvm.h> 155c3d55faSPekka Enberg #include <kvm/kvm-cpu.h> 16f967c427SPrasad Joshi #include <kvm/8250-serial.h> 17f967c427SPrasad Joshi #include <kvm/virtio-blk.h> 184f56d42cSAsias He #include <kvm/virtio-net.h> 19f967c427SPrasad Joshi #include <kvm/virtio-console.h> 2053eca082SSasha Levin #include <kvm/virtio-rng.h> 21f967c427SPrasad Joshi #include <kvm/disk-image.h> 22f967c427SPrasad Joshi #include <kvm/util.h> 23f967c427SPrasad Joshi #include <kvm/pci.h> 2464136c1cSPekka Enberg #include <kvm/rtc.h> 25f967c427SPrasad Joshi #include <kvm/term.h> 26ac38f433SPekka Enberg #include <kvm/ioport.h> 27d60bafe5SSasha Levin #include <kvm/threadpool.h> 28cffeab25SIngo Molnar #include <kvm/barrier.h> 29b0b42ba0SPekka Enberg #include <kvm/symbol.h> 30*1c7850f9SSasha Levin #include <kvm/virtio-9p.h> 31f967c427SPrasad Joshi 32f967c427SPrasad Joshi /* header files for gitish interface */ 33f967c427SPrasad Joshi #include <kvm/kvm-run.h> 34f967c427SPrasad Joshi #include <kvm/parse-options.h> 35b5b501ccSIngo Molnar #include <kvm/mutex.h> 36f967c427SPrasad Joshi 37f967c427SPrasad Joshi #define DEFAULT_KVM_DEV "/dev/kvm" 389aa4a0ebSAsias He #define DEFAULT_CONSOLE "serial" 393b02f580SSasha Levin #define DEFAULT_NETWORK "virtio" 404d67c820SSasha Levin #define DEFAULT_HOST_ADDR "192.168.33.2" 41a4e724ddSSasha Levin #define DEFAULT_GUEST_MAC "00:11:22:33:44:55" 4273b7d038SAmos Kong #define DEFAULT_SCRIPT "none" 43f967c427SPrasad Joshi 44f967c427SPrasad Joshi #define MB_SHIFT (20) 45a2a002f9SIngo Molnar #define MIN_RAM_SIZE_MB (64ULL) 46f967c427SPrasad Joshi #define MIN_RAM_SIZE_BYTE (MIN_RAM_SIZE_MB << MB_SHIFT) 47a33979d8SSasha Levin #define MAX_DISK_IMAGES 4 48f967c427SPrasad Joshi 49f967c427SPrasad Joshi static struct kvm *kvm; 50d77a9efaSCyrill Gorcunov static struct kvm_cpu *kvm_cpus[KVM_NR_CPUS]; 51d77a9efaSCyrill Gorcunov static __thread struct kvm_cpu *current_kvm_cpu; 52f967c427SPrasad Joshi 53fd834defSPekka Enberg static u64 ram_size; 54a33979d8SSasha Levin static u8 image_count; 55f967c427SPrasad Joshi static const char *kernel_cmdline; 56f967c427SPrasad Joshi static const char *kernel_filename; 57b0b42ba0SPekka Enberg static const char *vmlinux_filename; 58f967c427SPrasad Joshi static const char *initrd_filename; 59a33979d8SSasha Levin static const char *image_filename[MAX_DISK_IMAGES]; 609aa4a0ebSAsias He static const char *console; 61f967c427SPrasad Joshi static const char *kvm_dev; 624f56d42cSAsias He static const char *network; 634d67c820SSasha Levin static const char *host_ip_addr; 64a4e724ddSSasha Levin static const char *guest_mac; 6573b7d038SAmos Kong static const char *script; 66*1c7850f9SSasha Levin static const char *virtio_9p_dir; 670ea58e5bSPekka Enberg static bool single_step; 68a33979d8SSasha Levin static bool readonly_image[MAX_DISK_IMAGES]; 6953eca082SSasha Levin static bool virtio_rng; 70f967c427SPrasad Joshi extern bool ioport_debug; 71f967c427SPrasad Joshi extern int active_console; 72f967c427SPrasad Joshi 73ed036f03SCyrill Gorcunov bool do_debug_print = false; 74ed036f03SCyrill Gorcunov 75cfd63bbbSSasha Levin static int nrcpus; 76d77a9efaSCyrill Gorcunov 77f967c427SPrasad Joshi static const char * const run_usage[] = { 788329f30bSPekka Enberg "kvm run [<options>] [<kernel image>]", 79f967c427SPrasad Joshi NULL 80f967c427SPrasad Joshi }; 81f967c427SPrasad Joshi 82a33979d8SSasha Levin static int img_name_parser(const struct option *opt, const char *arg, int unset) 83a33979d8SSasha Levin { 84a33979d8SSasha Levin char *sep; 85a33979d8SSasha Levin 86a33979d8SSasha Levin if (image_count >= MAX_DISK_IMAGES) 87a33979d8SSasha Levin die("Currently only 4 images are supported"); 88a33979d8SSasha Levin 89a33979d8SSasha Levin image_filename[image_count] = arg; 90a33979d8SSasha Levin sep = strstr(arg, ","); 91a33979d8SSasha Levin if (sep) { 92a33979d8SSasha Levin if (strcmp(sep + 1, "ro") == 0) 93a33979d8SSasha Levin readonly_image[image_count] = 1; 94a33979d8SSasha Levin *sep = 0; 95a33979d8SSasha Levin } 96a33979d8SSasha Levin 97a33979d8SSasha Levin image_count++; 98a33979d8SSasha Levin 99a33979d8SSasha Levin return 0; 100a33979d8SSasha Levin } 101a33979d8SSasha Levin 102f967c427SPrasad Joshi static const struct option options[] = { 1035e3af62dSSasha Levin OPT_GROUP("Basic options:"), 10480b1f72fSPekka Enberg OPT_INTEGER('c', "cpus", &nrcpus, "Number of CPUs"), 105f967c427SPrasad Joshi OPT_U64('m', "mem", &ram_size, "Virtual machine memory size in MiB."), 106d6c19027SAsias He OPT_CALLBACK('d', "disk", NULL, "image", "Disk image", img_name_parser), 10780b1f72fSPekka Enberg OPT_STRING('\0', "console", &console, "serial or virtio", 1085e3af62dSSasha Levin "Console to use"), 109d6c19027SAsias He OPT_BOOLEAN('\0', "rng", &virtio_rng, 11053eca082SSasha Levin "Enable virtio Random Number Generator"), 111d6c19027SAsias He OPT_STRING('\0', "kvm-dev", &kvm_dev, "kvm-dev", "KVM device file"), 112*1c7850f9SSasha Levin OPT_STRING('\0', "virtio-9p", &virtio_9p_dir, "root dir", 113*1c7850f9SSasha Levin "Enable 9p over virtio"), 1145e3af62dSSasha Levin 1155e3af62dSSasha Levin OPT_GROUP("Kernel options:"), 1165e3af62dSSasha Levin OPT_STRING('k', "kernel", &kernel_filename, "kernel", 1175e3af62dSSasha Levin "Kernel to boot in virtual machine"), 118d6c19027SAsias He OPT_STRING('i', "initrd", &initrd_filename, "initrd", 1195e3af62dSSasha Levin "Initial RAM disk image"), 1205e3af62dSSasha Levin OPT_STRING('p', "params", &kernel_cmdline, "params", 1215e3af62dSSasha Levin "Kernel command line arguments"), 1225e3af62dSSasha Levin 1234d67c820SSasha Levin OPT_GROUP("Networking options:"), 1244d67c820SSasha Levin OPT_STRING('n', "network", &network, "virtio", 1254d67c820SSasha Levin "Network to use"), 1264d67c820SSasha Levin OPT_STRING('\0', "host-ip-addr", &host_ip_addr, "a.b.c.d", 1274d67c820SSasha Levin "Assign this address to the host side networking"), 128a4e724ddSSasha Levin OPT_STRING('\0', "guest-mac", &guest_mac, "aa:bb:cc:dd:ee:ff", 129a4e724ddSSasha Levin "Assign this address to the guest side NIC"), 13073b7d038SAmos Kong OPT_STRING('\0', "tapscript", &script, "Script path", 13173b7d038SAmos Kong "Assign a script to process created tap device"), 132d6c19027SAsias He 1335e3af62dSSasha Levin OPT_GROUP("Debug options:"), 134ed036f03SCyrill Gorcunov OPT_BOOLEAN('\0', "debug", &do_debug_print, 135ed036f03SCyrill Gorcunov "Enable debug messages"), 136d6c19027SAsias He OPT_BOOLEAN('\0', "debug-single-step", &single_step, 137d6c19027SAsias He "Enable single stepping"), 138d6c19027SAsias He OPT_BOOLEAN('\0', "debug-ioport-debug", &ioport_debug, 139d6c19027SAsias He "Enable ioport debugging"), 140f967c427SPrasad Joshi OPT_END() 141f967c427SPrasad Joshi }; 142f967c427SPrasad Joshi 143b5b501ccSIngo Molnar /* 144b5b501ccSIngo Molnar * Serialize debug printout so that the output of multiple vcpus does not 145b5b501ccSIngo Molnar * get mixed up: 146b5b501ccSIngo Molnar */ 147cffeab25SIngo Molnar static int printout_done; 148b5b501ccSIngo Molnar 14943119af7SPekka Enberg static void handle_sigusr1(int sig) 15043119af7SPekka Enberg { 15143119af7SPekka Enberg struct kvm_cpu *cpu = current_kvm_cpu; 15243119af7SPekka Enberg 15343119af7SPekka Enberg if (!cpu) 15443119af7SPekka Enberg return; 15543119af7SPekka Enberg 156b5b501ccSIngo Molnar printf("\n #\n # vCPU #%ld's dump:\n #\n", cpu->cpu_id); 15743119af7SPekka Enberg kvm_cpu__show_registers(cpu); 15843119af7SPekka Enberg kvm_cpu__show_code(cpu); 15943119af7SPekka Enberg kvm_cpu__show_page_tables(cpu); 160b5b501ccSIngo Molnar fflush(stdout); 161cffeab25SIngo Molnar printout_done = 1; 162cffeab25SIngo Molnar mb(); 16343119af7SPekka Enberg } 16443119af7SPekka Enberg 1659e854d1aSPekka Enberg static void handle_sigquit(int sig) 1669e854d1aSPekka Enberg { 1679e854d1aSPekka Enberg int i; 1689e854d1aSPekka Enberg 1699e854d1aSPekka Enberg for (i = 0; i < nrcpus; i++) { 1709e854d1aSPekka Enberg struct kvm_cpu *cpu = kvm_cpus[i]; 1719e854d1aSPekka Enberg 17243119af7SPekka Enberg if (!cpu) 17343119af7SPekka Enberg continue; 17443119af7SPekka Enberg 175cffeab25SIngo Molnar printout_done = 0; 17643119af7SPekka Enberg pthread_kill(cpu->thread, SIGUSR1); 177cffeab25SIngo Molnar /* 178cffeab25SIngo Molnar * Wait for the vCPU to dump state before signalling 179cffeab25SIngo Molnar * the next thread. Since this is debug code it does 180cffeab25SIngo Molnar * not matter that we are burning CPU time a bit: 181cffeab25SIngo Molnar */ 182cffeab25SIngo Molnar while (!printout_done) 183cffeab25SIngo Molnar mb(); 1849e854d1aSPekka Enberg } 1859e854d1aSPekka Enberg 1869e854d1aSPekka Enberg serial8250__inject_sysrq(kvm); 1879e854d1aSPekka Enberg } 1889e854d1aSPekka Enberg 1899e854d1aSPekka Enberg static void handle_sigalrm(int sig) 1909e854d1aSPekka Enberg { 1919e854d1aSPekka Enberg serial8250__inject_interrupt(kvm); 1929e854d1aSPekka Enberg virtio_console__inject_interrupt(kvm); 1939e854d1aSPekka Enberg } 1949e854d1aSPekka Enberg 1955ee154d1SPekka Enberg static void *kvm_cpu_thread(void *arg) 1965ee154d1SPekka Enberg { 197d77a9efaSCyrill Gorcunov current_kvm_cpu = arg; 1985ee154d1SPekka Enberg 199d77a9efaSCyrill Gorcunov if (kvm_cpu__start(current_kvm_cpu)) 2005ee154d1SPekka Enberg goto panic_kvm; 2015ee154d1SPekka Enberg 202d77a9efaSCyrill Gorcunov kvm_cpu__delete(current_kvm_cpu); 2035ee154d1SPekka Enberg 2045ee154d1SPekka Enberg return (void *) (intptr_t) 0; 2055ee154d1SPekka Enberg 2065ee154d1SPekka Enberg panic_kvm: 2073fdf659dSSasha Levin fprintf(stderr, "KVM exit reason: %u (\"%s\")\n", 208d77a9efaSCyrill Gorcunov current_kvm_cpu->kvm_run->exit_reason, 209d77a9efaSCyrill Gorcunov kvm_exit_reasons[current_kvm_cpu->kvm_run->exit_reason]); 210d77a9efaSCyrill Gorcunov if (current_kvm_cpu->kvm_run->exit_reason == KVM_EXIT_UNKNOWN) 2115ee154d1SPekka Enberg fprintf(stderr, "KVM exit code: 0x%Lu\n", 212d77a9efaSCyrill Gorcunov current_kvm_cpu->kvm_run->hw.hardware_exit_reason); 2138e5accedSPekka Enberg 214d77a9efaSCyrill Gorcunov kvm_cpu__show_registers(current_kvm_cpu); 215d77a9efaSCyrill Gorcunov kvm_cpu__show_code(current_kvm_cpu); 216d77a9efaSCyrill Gorcunov kvm_cpu__show_page_tables(current_kvm_cpu); 2175ee154d1SPekka Enberg 218d77a9efaSCyrill Gorcunov kvm_cpu__delete(current_kvm_cpu); 2195ee154d1SPekka Enberg 2205ee154d1SPekka Enberg return (void *) (intptr_t) 1; 2215ee154d1SPekka Enberg } 2225ee154d1SPekka Enberg 223e08c0896SPrasad Joshi static char kernel[PATH_MAX]; 224b0b42ba0SPekka Enberg 225b0b42ba0SPekka Enberg static const char *host_kernels[] = { 226e08c0896SPrasad Joshi "/boot/vmlinuz", 227e08c0896SPrasad Joshi "/boot/bzImage", 228e08c0896SPrasad Joshi NULL 229e08c0896SPrasad Joshi }; 230b0b42ba0SPekka Enberg 231b0b42ba0SPekka Enberg static const char *default_kernels[] = { 232e08c0896SPrasad Joshi "./bzImage", 233e08c0896SPrasad Joshi "../../arch/x86/boot/bzImage", 234e08c0896SPrasad Joshi NULL 235e08c0896SPrasad Joshi }; 2368329f30bSPekka Enberg 237b0b42ba0SPekka Enberg static const char *default_vmlinux[] = { 238b0b42ba0SPekka Enberg "../../../vmlinux", 239b0b42ba0SPekka Enberg "../../vmlinux", 240b0b42ba0SPekka Enberg NULL 241b0b42ba0SPekka Enberg }; 242b0b42ba0SPekka Enberg 243e08c0896SPrasad Joshi static void kernel_usage_with_options(void) 2448329f30bSPekka Enberg { 245e08c0896SPrasad Joshi const char **k; 2468329f30bSPekka Enberg struct utsname uts; 247e08c0896SPrasad Joshi 248e08c0896SPrasad Joshi fprintf(stderr, "Fatal: could not find default kernel image in:\n"); 24965182f37SPrasad Joshi k = &default_kernels[0]; 250e08c0896SPrasad Joshi while (*k) { 251e08c0896SPrasad Joshi fprintf(stderr, "\t%s\n", *k); 252e08c0896SPrasad Joshi k++; 253e08c0896SPrasad Joshi } 254e08c0896SPrasad Joshi 255e08c0896SPrasad Joshi if (uname(&uts) < 0) 256e08c0896SPrasad Joshi return; 257e08c0896SPrasad Joshi 258e08c0896SPrasad Joshi k = &host_kernels[0]; 259e08c0896SPrasad Joshi while (*k) { 260e08c0896SPrasad Joshi if (snprintf(kernel, PATH_MAX, "%s-%s", *k, uts.release) < 0) 261e08c0896SPrasad Joshi return; 262e08c0896SPrasad Joshi fprintf(stderr, "\t%s\n", kernel); 263e08c0896SPrasad Joshi k++; 264e08c0896SPrasad Joshi } 265a33389d8SPrasad Joshi fprintf(stderr, "\nPlease see 'kvm run --help' for more options.\n\n"); 266e08c0896SPrasad Joshi } 267e08c0896SPrasad Joshi 26860ded003SPekka Enberg static u64 host_ram_size(void) 26960ded003SPekka Enberg { 27060ded003SPekka Enberg long page_size; 27160ded003SPekka Enberg long nr_pages; 27260ded003SPekka Enberg 27360ded003SPekka Enberg nr_pages = sysconf(_SC_PHYS_PAGES); 274d63c5ce6SPekka Enberg if (nr_pages < 0) { 2754542f276SCyrill Gorcunov pr_warning("sysconf(_SC_PHYS_PAGES) failed"); 276d63c5ce6SPekka Enberg return 0; 277d63c5ce6SPekka Enberg } 27860ded003SPekka Enberg 27960ded003SPekka Enberg page_size = sysconf(_SC_PAGE_SIZE); 280d63c5ce6SPekka Enberg if (page_size < 0) { 2814542f276SCyrill Gorcunov pr_warning("sysconf(_SC_PAGE_SIZE) failed"); 282d63c5ce6SPekka Enberg return 0; 283d63c5ce6SPekka Enberg } 28460ded003SPekka Enberg 28560ded003SPekka Enberg return (nr_pages * page_size) >> MB_SHIFT; 28660ded003SPekka Enberg } 28760ded003SPekka Enberg 28818bd8c3bSPekka Enberg /* 28918bd8c3bSPekka Enberg * If user didn't specify how much memory it wants to allocate for the guest, 29018bd8c3bSPekka Enberg * avoid filling the whole host RAM. 29118bd8c3bSPekka Enberg */ 29218bd8c3bSPekka Enberg #define RAM_SIZE_RATIO 0.8 29318bd8c3bSPekka Enberg 294fd834defSPekka Enberg static u64 get_ram_size(int nr_cpus) 295fd834defSPekka Enberg { 296fd834defSPekka Enberg long available; 297fd834defSPekka Enberg long ram_size; 298fd834defSPekka Enberg 299fd834defSPekka Enberg ram_size = 64 * (nr_cpus + 3); 300fd834defSPekka Enberg 30160ded003SPekka Enberg available = host_ram_size() * RAM_SIZE_RATIO; 302d63c5ce6SPekka Enberg if (!available) 303d63c5ce6SPekka Enberg available = MIN_RAM_SIZE_MB; 304fd834defSPekka Enberg 305fd834defSPekka Enberg if (ram_size > available) 306fd834defSPekka Enberg ram_size = available; 307fd834defSPekka Enberg 308fd834defSPekka Enberg return ram_size; 309fd834defSPekka Enberg } 310fd834defSPekka Enberg 311e08c0896SPrasad Joshi static const char *find_kernel(void) 312e08c0896SPrasad Joshi { 313e08c0896SPrasad Joshi const char **k; 3148329f30bSPekka Enberg struct stat st; 315e08c0896SPrasad Joshi struct utsname uts; 316e08c0896SPrasad Joshi 31765182f37SPrasad Joshi k = &default_kernels[0]; 318e08c0896SPrasad Joshi while (*k) { 319e08c0896SPrasad Joshi if (stat(*k, &st) < 0 || !S_ISREG(st.st_mode)) { 320e08c0896SPrasad Joshi k++; 321e08c0896SPrasad Joshi continue; 322e08c0896SPrasad Joshi } 323e08c0896SPrasad Joshi strncpy(kernel, *k, PATH_MAX); 324e08c0896SPrasad Joshi return kernel; 325e08c0896SPrasad Joshi } 3268329f30bSPekka Enberg 3278329f30bSPekka Enberg if (uname(&uts) < 0) 3288329f30bSPekka Enberg return NULL; 3298329f30bSPekka Enberg 330e08c0896SPrasad Joshi k = &host_kernels[0]; 331e08c0896SPrasad Joshi while (*k) { 332e08c0896SPrasad Joshi if (snprintf(kernel, PATH_MAX, "%s-%s", *k, uts.release) < 0) 3338329f30bSPekka Enberg return NULL; 3348329f30bSPekka Enberg 335e08c0896SPrasad Joshi if (stat(kernel, &st) < 0 || !S_ISREG(st.st_mode)) { 336e08c0896SPrasad Joshi k++; 337e08c0896SPrasad Joshi continue; 338e08c0896SPrasad Joshi } 339e08c0896SPrasad Joshi return kernel; 3408329f30bSPekka Enberg 341e08c0896SPrasad Joshi } 3428329f30bSPekka Enberg return NULL; 3438329f30bSPekka Enberg } 3448329f30bSPekka Enberg 345b0b42ba0SPekka Enberg static const char *find_vmlinux(void) 346b0b42ba0SPekka Enberg { 347b0b42ba0SPekka Enberg const char **vmlinux; 348b0b42ba0SPekka Enberg 349b0b42ba0SPekka Enberg vmlinux = &default_vmlinux[0]; 350b0b42ba0SPekka Enberg while (*vmlinux) { 351b0b42ba0SPekka Enberg struct stat st; 352b0b42ba0SPekka Enberg 353b0b42ba0SPekka Enberg if (stat(*vmlinux, &st) < 0 || !S_ISREG(st.st_mode)) { 354b0b42ba0SPekka Enberg vmlinux++; 355b0b42ba0SPekka Enberg continue; 356b0b42ba0SPekka Enberg } 357b0b42ba0SPekka Enberg return *vmlinux; 358b0b42ba0SPekka Enberg } 359b0b42ba0SPekka Enberg return NULL; 360b0b42ba0SPekka Enberg } 361b0b42ba0SPekka Enberg 36226c853e4SPrasad Joshi static int root_device(char *dev, long *part) 36326c853e4SPrasad Joshi { 36426c853e4SPrasad Joshi struct stat st; 36526c853e4SPrasad Joshi 36605088d56SSasha Levin if (stat("/", &st) < 0) 36726c853e4SPrasad Joshi return -1; 36826c853e4SPrasad Joshi 36905088d56SSasha Levin *part = minor(st.st_dev); 37026c853e4SPrasad Joshi 37105088d56SSasha Levin sprintf(dev, "/dev/block/%u:0", major(st.st_dev)); 372afa0f6c1SPrasad Joshi if (access(dev, R_OK) < 0) 373afa0f6c1SPrasad Joshi return -1; 374afa0f6c1SPrasad Joshi 37526c853e4SPrasad Joshi return 0; 37626c853e4SPrasad Joshi } 37726c853e4SPrasad Joshi 37826c853e4SPrasad Joshi static char *host_image(char *cmd_line, size_t size) 37926c853e4SPrasad Joshi { 38026c853e4SPrasad Joshi char *t; 38126c853e4SPrasad Joshi char device[PATH_MAX]; 38226c853e4SPrasad Joshi long part = 0; 38326c853e4SPrasad Joshi 38426c853e4SPrasad Joshi t = malloc(PATH_MAX); 38526c853e4SPrasad Joshi if (!t) 38626c853e4SPrasad Joshi return NULL; 38726c853e4SPrasad Joshi 38826c853e4SPrasad Joshi /* check for the root file system */ 38926c853e4SPrasad Joshi if (root_device(device, &part) < 0) { 39026c853e4SPrasad Joshi free(t); 39126c853e4SPrasad Joshi return NULL; 39226c853e4SPrasad Joshi } 39326c853e4SPrasad Joshi strncpy(t, device, PATH_MAX); 39426c853e4SPrasad Joshi if (!strstr(cmd_line, "root=")) { 39526c853e4SPrasad Joshi char tmp[PATH_MAX]; 39626c853e4SPrasad Joshi snprintf(tmp, sizeof(tmp), "root=/dev/vda%ld rw ", part); 39726c853e4SPrasad Joshi strlcat(cmd_line, tmp, size); 39826c853e4SPrasad Joshi } 39926c853e4SPrasad Joshi return t; 40026c853e4SPrasad Joshi } 40126c853e4SPrasad Joshi 402f6677a1dSAmerigo Wang void kvm_run_help(void) 403f6677a1dSAmerigo Wang { 404f6677a1dSAmerigo Wang usage_with_options(run_usage, options); 405f6677a1dSAmerigo Wang } 406f6677a1dSAmerigo Wang 407f967c427SPrasad Joshi int kvm_cmd_run(int argc, const char **argv, const char *prefix) 408f967c427SPrasad Joshi { 409b0b42ba0SPekka Enberg struct virtio_net_parameters net_params; 410f967c427SPrasad Joshi static char real_cmdline[2048]; 411384922b3SPekka Enberg unsigned int nr_online_cpus; 4125ee154d1SPekka Enberg int exit_code = 0; 413b0b42ba0SPekka Enberg int max_cpus; 41426c853e4SPrasad Joshi char *hi; 415b0b42ba0SPekka Enberg int i; 41649e5227dSSasha Levin void *ret; 417f967c427SPrasad Joshi 4185ee154d1SPekka Enberg signal(SIGALRM, handle_sigalrm); 419f967c427SPrasad Joshi signal(SIGQUIT, handle_sigquit); 42043119af7SPekka Enberg signal(SIGUSR1, handle_sigusr1); 421f967c427SPrasad Joshi 422cfd63bbbSSasha Levin nr_online_cpus = sysconf(_SC_NPROCESSORS_ONLN); 423cfd63bbbSSasha Levin 424f967c427SPrasad Joshi while (argc != 0) { 425f967c427SPrasad Joshi argc = parse_options(argc, argv, options, run_usage, 426f967c427SPrasad Joshi PARSE_OPT_STOP_AT_NON_OPTION); 427f967c427SPrasad Joshi if (argc != 0) { 428f967c427SPrasad Joshi if (kernel_filename) { 429f967c427SPrasad Joshi fprintf(stderr, "Cannot handle parameter: " 430f967c427SPrasad Joshi "%s\n", argv[0]); 431f967c427SPrasad Joshi usage_with_options(run_usage, options); 432f967c427SPrasad Joshi return EINVAL; 433f967c427SPrasad Joshi } 434f967c427SPrasad Joshi /* first unhandled parameter is treated as a kernel 435f967c427SPrasad Joshi image 436f967c427SPrasad Joshi */ 437f967c427SPrasad Joshi kernel_filename = argv[0]; 438f967c427SPrasad Joshi argv++; 439f967c427SPrasad Joshi argc--; 440f967c427SPrasad Joshi } 441f967c427SPrasad Joshi 442f967c427SPrasad Joshi } 443f967c427SPrasad Joshi 44445bc2f02SPekka Enberg if (!kernel_filename) 445e08c0896SPrasad Joshi kernel_filename = find_kernel(); 4468329f30bSPekka Enberg 4478329f30bSPekka Enberg if (!kernel_filename) { 448e08c0896SPrasad Joshi kernel_usage_with_options(); 4498329f30bSPekka Enberg return EINVAL; 4508329f30bSPekka Enberg } 4518329f30bSPekka Enberg 452b0b42ba0SPekka Enberg vmlinux_filename = find_vmlinux(); 453b0b42ba0SPekka Enberg 454cfd63bbbSSasha Levin if (nrcpus == 0) 455cfd63bbbSSasha Levin nrcpus = nr_online_cpus; 456cfd63bbbSSasha Levin else if (nrcpus < 1 || nrcpus > KVM_NR_CPUS) 457d77a9efaSCyrill Gorcunov die("Number of CPUs %d is out of [1;%d] range", nrcpus, KVM_NR_CPUS); 458d77a9efaSCyrill Gorcunov 459fd834defSPekka Enberg if (!ram_size) 460fd834defSPekka Enberg ram_size = get_ram_size(nrcpus); 461fd834defSPekka Enberg 462a2a002f9SIngo Molnar if (ram_size < MIN_RAM_SIZE_MB) 463a2a002f9SIngo Molnar die("Not enough memory specified: %lluMB (min %lluMB)", ram_size, MIN_RAM_SIZE_MB); 464a2a002f9SIngo Molnar 46560ded003SPekka Enberg if (ram_size > host_ram_size()) 4664542f276SCyrill Gorcunov pr_warning("Guest memory size %lluMB exceeds host physical RAM size %lluMB", ram_size, host_ram_size()); 46760ded003SPekka Enberg 468f967c427SPrasad Joshi ram_size <<= MB_SHIFT; 469f967c427SPrasad Joshi 470f967c427SPrasad Joshi if (!kvm_dev) 471f967c427SPrasad Joshi kvm_dev = DEFAULT_KVM_DEV; 472f967c427SPrasad Joshi 4739aa4a0ebSAsias He if (!console) 4749aa4a0ebSAsias He console = DEFAULT_CONSOLE; 4759aa4a0ebSAsias He 4769aa4a0ebSAsias He if (!strncmp(console, "virtio", 6)) 477f967c427SPrasad Joshi active_console = CONSOLE_VIRTIO; 4789aa4a0ebSAsias He else 4799aa4a0ebSAsias He active_console = CONSOLE_8250; 480f967c427SPrasad Joshi 4814d67c820SSasha Levin if (!host_ip_addr) 4824d67c820SSasha Levin host_ip_addr = DEFAULT_HOST_ADDR; 4834d67c820SSasha Levin 484a4e724ddSSasha Levin if (!guest_mac) 485a4e724ddSSasha Levin guest_mac = DEFAULT_GUEST_MAC; 486a4e724ddSSasha Levin 48773b7d038SAmos Kong if (!script) 48873b7d038SAmos Kong script = DEFAULT_SCRIPT; 48973b7d038SAmos Kong 490*1c7850f9SSasha Levin if (virtio_9p_dir) { 491*1c7850f9SSasha Levin char tmp[PATH_MAX]; 492*1c7850f9SSasha Levin 493*1c7850f9SSasha Levin if (realpath(virtio_9p_dir, tmp)) 494*1c7850f9SSasha Levin virtio_9p__init(kvm, tmp); 495*1c7850f9SSasha Levin else 496*1c7850f9SSasha Levin die("Failed resolving 9p path"); 497*1c7850f9SSasha Levin } 498*1c7850f9SSasha Levin 499b0b42ba0SPekka Enberg symbol__init(vmlinux_filename); 500b0b42ba0SPekka Enberg 501f967c427SPrasad Joshi term_init(); 502f967c427SPrasad Joshi 503f967c427SPrasad Joshi kvm = kvm__init(kvm_dev, ram_size); 504f967c427SPrasad Joshi 505384922b3SPekka Enberg max_cpus = kvm__max_cpus(kvm); 506384922b3SPekka Enberg 507384922b3SPekka Enberg if (nrcpus > max_cpus) { 508384922b3SPekka Enberg printf(" # Limit the number of CPUs to %d\n", max_cpus); 509384922b3SPekka Enberg kvm->nrcpus = max_cpus; 510384922b3SPekka Enberg } 511384922b3SPekka Enberg 5120c7c14a7SCyrill Gorcunov kvm->nrcpus = nrcpus; 5130c7c14a7SCyrill Gorcunov 51426c853e4SPrasad Joshi memset(real_cmdline, 0, sizeof(real_cmdline)); 5156a5e9cf4SIngo Molnar strcpy(real_cmdline, "notsc noapic noacpi pci=conf1 console=ttyS0 earlyprintk=serial"); 516d74181ccSSasha Levin strcat(real_cmdline, " "); 51726c853e4SPrasad Joshi if (kernel_cmdline) 51826c853e4SPrasad Joshi strlcat(real_cmdline, kernel_cmdline, sizeof(real_cmdline)); 51926c853e4SPrasad Joshi 52026c853e4SPrasad Joshi hi = NULL; 521a33979d8SSasha Levin if (!image_filename[0]) { 52226c853e4SPrasad Joshi hi = host_image(real_cmdline, sizeof(real_cmdline)); 52326c853e4SPrasad Joshi if (hi) { 524a33979d8SSasha Levin image_filename[0] = hi; 525a33979d8SSasha Levin readonly_image[0] = true; 52625bf86f6SSasha Levin image_count++; 52726c853e4SPrasad Joshi } 52826c853e4SPrasad Joshi } 52926c853e4SPrasad Joshi 53026c853e4SPrasad Joshi if (!strstr(real_cmdline, "root=")) 53126c853e4SPrasad Joshi strlcat(real_cmdline, " root=/dev/vda rw ", sizeof(real_cmdline)); 53226c853e4SPrasad Joshi 533a33979d8SSasha Levin for (i = 0; i < image_count; i++) { 534a33979d8SSasha Levin if (image_filename[i]) { 535a33979d8SSasha Levin struct disk_image *disk = disk_image__open(image_filename[i], readonly_image[i]); 53638605e1cSSasha Levin if (!disk) 537a33979d8SSasha Levin die("unable to load disk image %s", image_filename[i]); 53838605e1cSSasha Levin 53938605e1cSSasha Levin virtio_blk__init(kvm, disk); 540f967c427SPrasad Joshi } 541a33979d8SSasha Levin } 54226c853e4SPrasad Joshi free(hi); 543f967c427SPrasad Joshi 5443780b3d5SPekka Enberg printf(" # kvm run -k %s -m %Lu -c %d\n", kernel_filename, ram_size / 1024 / 1024, nrcpus); 545471c6facSPekka Enberg 546f967c427SPrasad Joshi if (!kvm__load_kernel(kvm, kernel_filename, initrd_filename, 547f967c427SPrasad Joshi real_cmdline)) 548f967c427SPrasad Joshi die("unable to load kernel %s", kernel_filename); 549f967c427SPrasad Joshi 550b0b42ba0SPekka Enberg kvm->vmlinux = vmlinux_filename; 551b0b42ba0SPekka Enberg 552ac38f433SPekka Enberg ioport__setup_legacy(); 553ac38f433SPekka Enberg 55464136c1cSPekka Enberg rtc__init(); 55564136c1cSPekka Enberg 556f967c427SPrasad Joshi serial8250__init(kvm); 557f967c427SPrasad Joshi 558f967c427SPrasad Joshi pci__init(); 559f967c427SPrasad Joshi 5601621292eSSasha Levin if (active_console == CONSOLE_VIRTIO) 561f967c427SPrasad Joshi virtio_console__init(kvm); 562f967c427SPrasad Joshi 56353eca082SSasha Levin if (virtio_rng) 56453eca082SSasha Levin virtio_rng__init(kvm); 56553eca082SSasha Levin 5664f56d42cSAsias He if (!network) 5674f56d42cSAsias He network = DEFAULT_NETWORK; 5684f56d42cSAsias He 569bdfcfca6SSasha Levin if (!strncmp(network, "virtio", 6)) { 570bdfcfca6SSasha Levin net_params = (struct virtio_net_parameters) { 571bdfcfca6SSasha Levin .host_ip = host_ip_addr, 57243835ac9SSasha Levin .kvm = kvm, 57373b7d038SAmos Kong .script = script 574bdfcfca6SSasha Levin }; 575a4e724ddSSasha Levin sscanf(guest_mac, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", 576a4e724ddSSasha Levin net_params.guest_mac, 577a4e724ddSSasha Levin net_params.guest_mac+1, 578a4e724ddSSasha Levin net_params.guest_mac+2, 579a4e724ddSSasha Levin net_params.guest_mac+3, 580a4e724ddSSasha Levin net_params.guest_mac+4, 581a4e724ddSSasha Levin net_params.guest_mac+5); 582a4e724ddSSasha Levin 583bdfcfca6SSasha Levin virtio_net__init(&net_params); 584bdfcfca6SSasha Levin } 5854f56d42cSAsias He 586f967c427SPrasad Joshi kvm__start_timer(kvm); 587f967c427SPrasad Joshi 5888ec7e042SSasha Levin kvm__setup_bios(kvm); 5898ec7e042SSasha Levin 590d77a9efaSCyrill Gorcunov for (i = 0; i < nrcpus; i++) { 591d77a9efaSCyrill Gorcunov kvm_cpus[i] = kvm_cpu__init(kvm, i); 592d77a9efaSCyrill Gorcunov if (!kvm_cpus[i]) 5935ee154d1SPekka Enberg die("unable to initialize KVM VCPU"); 5945d1a249cSPekka Enberg 5955ee154d1SPekka Enberg if (single_step) 596d77a9efaSCyrill Gorcunov kvm_cpu__enable_singlestep(kvm_cpus[i]); 597839051d9SSasha Levin } 5985ee154d1SPekka Enberg 599839051d9SSasha Levin kvm__init_ram(kvm); 600839051d9SSasha Levin 601d60bafe5SSasha Levin thread_pool__init(nr_online_cpus); 602d60bafe5SSasha Levin 603839051d9SSasha Levin for (i = 0; i < nrcpus; i++) { 604d77a9efaSCyrill Gorcunov if (pthread_create(&kvm_cpus[i]->thread, NULL, kvm_cpu_thread, kvm_cpus[i]) != 0) 6055ee154d1SPekka Enberg die("unable to create KVM VCPU thread"); 6065ee154d1SPekka Enberg } 6075ee154d1SPekka Enberg 60849e5227dSSasha Levin /* Only VCPU #0 is going to exit by itself when shutting down */ 60949e5227dSSasha Levin if (pthread_join(kvm_cpus[0]->thread, &ret) != 0) 61049e5227dSSasha Levin exit_code = 1; 6115ee154d1SPekka Enberg 61249e5227dSSasha Levin for (i = 1; i < nrcpus; i++) { 61349e5227dSSasha Levin pthread_kill(kvm_cpus[i]->thread, SIGKVMEXIT); 614d77a9efaSCyrill Gorcunov if (pthread_join(kvm_cpus[i]->thread, &ret) != 0) 6155ee154d1SPekka Enberg die("pthread_join"); 6165ee154d1SPekka Enberg 6175ee154d1SPekka Enberg if (ret != NULL) 6185ee154d1SPekka Enberg exit_code = 1; 6195ee154d1SPekka Enberg } 620f967c427SPrasad Joshi 621f967c427SPrasad Joshi kvm__delete(kvm); 622f967c427SPrasad Joshi 6235ee154d1SPekka Enberg if (!exit_code) 624f967c427SPrasad Joshi printf("\n # KVM session ended normally.\n"); 625f967c427SPrasad Joshi 6265ee154d1SPekka Enberg return exit_code; 627f967c427SPrasad Joshi } 628