qemu-kvm.c

   1 /*
   2  * qemu/kvm integration
   3  *
   4  * Copyright (C) 2006-2008 Qumranet Technologies
   5  *
   6  * Licensed under the terms of the GNU GPL version 2 or higher.
   7  */
   8 #include "config.h"
   9 #include "config-host.h"
  10
  11 int kvm_allowed = 1;
  12 int kvm_irqchip = 1;
  13 int kvm_pit = 1;
  14
  15 #include <string.h>
  16 #include "hw/hw.h"
  17 #include "sysemu.h"
  18 #include "qemu-common.h"
  19 #include "console.h"
  20 #include "block.h"
  21
  22 #include "qemu-kvm.h"
  23 #include <libkvm.h>
  24 #include <pthread.h>
  25 #include <sys/utsname.h>
  26 #include <sys/syscall.h>
  27
  28 extern void perror(const char *s);
  29
  30 kvm_context_t kvm_context;
  31
  32 extern int smp_cpus;
  33
  34 static int qemu_kvm_reset_requested;
  35
  36 pthread_mutex_t qemu_mutex = PTHREAD_MUTEX_INITIALIZER;
  37 pthread_cond_t qemu_aio_cond = PTHREAD_COND_INITIALIZER;
  38 pthread_cond_t qemu_vcpu_cond = PTHREAD_COND_INITIALIZER;
  39 pthread_cond_t qemu_system_cond = PTHREAD_COND_INITIALIZER;
  40 pthread_cond_t qemu_pause_cond = PTHREAD_COND_INITIALIZER;
  41 __thread struct vcpu_info *vcpu;
  42
  43 static int qemu_system_ready;
  44
  45 #define SIG_IPI (SIGRTMIN+4)
  46
  47 struct vcpu_info {
  48     CPUState *env;
  49     int sipi_needed;
  50     int init;
  51     pthread_t thread;
  52     int signalled;
  53     int stop;
  54     int stopped;
  55     int reload_regs;
  56     int created;
  57 } vcpu_info[256];
  58
  59 pthread_t io_thread;
  60 static int io_thread_fd = -1;
  61 static int io_thread_sigfd = -1;
  62
  63 static inline unsigned long kvm_get_thread_id(void)
  64 {
  65     return syscall(SYS_gettid);
  66 }
  67
  68 CPUState *qemu_kvm_cpu_env(int index)
  69 {
  70     return vcpu_info[index].env;
  71 }
  72
  73 static void sig_ipi_handler(int n)
  74 {
  75 }
  76
  77 void kvm_update_interrupt_request(CPUState *env)
  78 {
  79     int signal = 0;
  80
  81     if (env) {
  82         if (!vcpu)
  83             signal = 1;
  84         if (vcpu && env != vcpu->env && !vcpu_info[env->cpu_index].signalled)
  85             signal = 1;
  86
  87         if (signal) {
  88             vcpu_info[env->cpu_index].signalled = 1;
  89                 if (vcpu_info[env->cpu_index].thread)
  90                     pthread_kill(vcpu_info[env->cpu_index].thread, SIG_IPI);
  91         }
  92     }
  93 }
  94
  95 void kvm_update_after_sipi(CPUState *env)
  96 {
  97     vcpu_info[env->cpu_index].sipi_needed = 1;
  98     kvm_update_interrupt_request(env);
  99 }
 100
 101 void kvm_apic_init(CPUState *env)
 102 {
 103     if (env->cpu_index != 0)
 104         vcpu_info[env->cpu_index].init = 1;
 105     kvm_update_interrupt_request(env);
 106 }
 107
 108 #include <signal.h>
 109
 110 static int try_push_interrupts(void *opaque)
 111 {
 112     return kvm_arch_try_push_interrupts(opaque);
 113 }
 114
 115 static void post_kvm_run(void *opaque, int vcpu)
 116 {
 117
 118     pthread_mutex_lock(&qemu_mutex);
 119     kvm_arch_post_kvm_run(opaque, vcpu);
 120 }
 121
 122 static int pre_kvm_run(void *opaque, int vcpu)
 123 {
 124     CPUState *env = qemu_kvm_cpu_env(vcpu);
 125
 126     kvm_arch_pre_kvm_run(opaque, vcpu);
 127
 128     if (env->interrupt_request & CPU_INTERRUPT_EXIT)
 129         return 1;
 130     pthread_mutex_unlock(&qemu_mutex);
 131     return 0;
 132 }
 133
 134 void kvm_load_registers(CPUState *env)
 135 {
 136     if (kvm_enabled())
 137         kvm_arch_load_regs(env);
 138 }
 139
 140 void kvm_save_registers(CPUState *env)
 141 {
 142     if (kvm_enabled())
 143         kvm_arch_save_regs(env);
 144 }
 145
 146 int kvm_cpu_exec(CPUState *env)
 147 {
 148     int r;
 149
 150     r = kvm_run(kvm_context, env->cpu_index);
 151     if (r < 0) {
 152         printf("kvm_run returned %d\n", r);
 153         exit(1);
 154     }
 155
 156     return 0;
 157 }
 158
 159 extern int vm_running;
 160
 161 static int has_work(CPUState *env)
 162 {
 163     if (!vm_running || (env && vcpu_info[env->cpu_index].stopped))
 164         return 0;
 165     if (!(env->hflags & HF_HALTED_MASK))
 166         return 1;
 167     return kvm_arch_has_work(env);
 168 }
 169
 170 static int kvm_eat_signal(CPUState *env, int timeout)
 171 {
 172     struct timespec ts;
 173     int r, e, ret = 0;
 174     siginfo_t siginfo;
 175     sigset_t waitset;
 176
 177     ts.tv_sec = timeout / 1000;
 178     ts.tv_nsec = (timeout % 1000) * 1000000;
 179     sigemptyset(&waitset);
 180     sigaddset(&waitset, SIG_IPI);
 181
 182     r = sigtimedwait(&waitset, &siginfo, &ts);
 183     if (r == -1 && (errno == EAGAIN || errno == EINTR) && !timeout)
 184         return 0;
 185     e = errno;
 186
 187     pthread_mutex_lock(&qemu_mutex);
 188     if (env && vcpu)
 189         cpu_single_env = vcpu->env;
 190     if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
 191         printf("sigtimedwait: %s\n", strerror(e));
 192         exit(1);
 193     }
 194     if (r != -1)
 195         ret = 1;
 196
 197     if (env && vcpu_info[env->cpu_index].stop) {
 198         vcpu_info[env->cpu_index].stop = 0;
 199         vcpu_info[env->cpu_index].stopped = 1;
 200         pthread_cond_signal(&qemu_pause_cond);
 201     }
 202     pthread_mutex_unlock(&qemu_mutex);
 203
 204     return ret;
 205 }
 206
 207
 208 static void kvm_eat_signals(CPUState *env, int timeout)
 209 {
 210     int r = 0;
 211
 212     while (kvm_eat_signal(env, 0))
 213         r = 1;
 214     if (!r && timeout) {
 215         r = kvm_eat_signal(env, timeout);
 216         if (r)
 217             while (kvm_eat_signal(env, 0))
 218                 ;
 219     }
 220 }
 221
 222 static void kvm_main_loop_wait(CPUState *env, int timeout)
 223 {
 224     pthread_mutex_unlock(&qemu_mutex);
 225     kvm_eat_signals(env, timeout);
 226     pthread_mutex_lock(&qemu_mutex);
 227     cpu_single_env = env;
 228     vcpu_info[env->cpu_index].signalled = 0;
 229 }
 230
 231 static int all_threads_paused(void)
 232 {
 233     int i;
 234
 235     for (i = 0; i < smp_cpus; ++i)
 236         if (vcpu_info[i].stop)
 237             return 0;
 238     return 1;
 239 }
 240
 241 static void pause_all_threads(void)
 242 {
 243     int i;
 244
 245     for (i = 0; i < smp_cpus; ++i) {
 246         vcpu_info[i].stop = 1;
 247         pthread_kill(vcpu_info[i].thread, SIG_IPI);
 248     }
 249     while (!all_threads_paused()) {
 250         CPUState *env = cpu_single_env;
 251         pthread_cond_wait(&qemu_pause_cond, &qemu_mutex);
 252         cpu_single_env = env;
 253     }
 254 }
 255
 256 static void resume_all_threads(void)
 257 {
 258     int i;
 259
 260     for (i = 0; i < smp_cpus; ++i) {
 261         vcpu_info[i].stop = 0;
 262         vcpu_info[i].stopped = 0;
 263         pthread_kill(vcpu_info[i].thread, SIG_IPI);
 264     }
 265 }
 266
 267 static void kvm_vm_state_change_handler(void *context, int running)
 268 {
 269     if (running)
 270         resume_all_threads();
 271     else
 272         pause_all_threads();
 273 }
 274
 275 static void update_regs_for_sipi(CPUState *env)
 276 {
 277     kvm_arch_update_regs_for_sipi(env);
 278     vcpu_info[env->cpu_index].sipi_needed = 0;
 279     vcpu_info[env->cpu_index].init = 0;
 280 }
 281
 282 static void update_regs_for_init(CPUState *env)
 283 {
 284     cpu_reset(env);
 285     kvm_arch_load_regs(env);
 286 }
 287
 288 static void setup_kernel_sigmask(CPUState *env)
 289 {
 290     sigset_t set;
 291
 292     sigemptyset(&set);
 293     sigaddset(&set, SIGUSR2);
 294     sigaddset(&set, SIGIO);
 295     sigaddset(&set, SIGALRM);
 296     sigprocmask(SIG_BLOCK, &set, NULL);
 297
 298     sigprocmask(SIG_BLOCK, NULL, &set);
 299     sigdelset(&set, SIG_IPI);
 300
 301     kvm_set_signal_mask(kvm_context, env->cpu_index, &set);
 302 }
 303
 304 void qemu_kvm_system_reset_request(void)
 305 {
 306     int i;
 307
 308     for (i = 0; i < smp_cpus; ++i) {
 309         vcpu_info[i].reload_regs = 1;
 310         pthread_kill(vcpu_info[i].thread, SIG_IPI);
 311     }
 312     qemu_system_reset();
 313 }
 314
 315 static int kvm_main_loop_cpu(CPUState *env)
 316 {
 317     struct vcpu_info *info = &vcpu_info[env->cpu_index];
 318
 319     setup_kernel_sigmask(env);
 320
 321     pthread_mutex_lock(&qemu_mutex);
 322     if (kvm_irqchip_in_kernel(kvm_context))
 323         env->hflags &= ~HF_HALTED_MASK;
 324
 325     kvm_qemu_init_env(env);
 326     env->ready_for_interrupt_injection = 1;
 327 #ifdef TARGET_I386
 328     kvm_tpr_vcpu_start(env);
 329 #endif
 330
 331     cpu_single_env = env;
 332     while (1) {
 333         while (!has_work(env))
 334             kvm_main_loop_wait(env, 1000);
 335         if (env->interrupt_request & CPU_INTERRUPT_HARD)
 336             env->hflags &= ~HF_HALTED_MASK;
 337         if (!kvm_irqchip_in_kernel(kvm_context) && info->sipi_needed)
 338             update_regs_for_sipi(env);
 339         if (!kvm_irqchip_in_kernel(kvm_context) && info->init)
 340             update_regs_for_init(env);
 341         if (!(env->hflags & HF_HALTED_MASK) && !info->init)
 342             kvm_cpu_exec(env);
 343         env->interrupt_request &= ~CPU_INTERRUPT_EXIT;
 344         kvm_main_loop_wait(env, 0);
 345         if (info->reload_regs) {
 346             info->reload_regs = 0;
 347             if (env->cpu_index == 0) /* ap needs to be placed in INIT */
 348                 kvm_arch_load_regs(env);
 349         }
 350     }
 351     pthread_mutex_unlock(&qemu_mutex);
 352     return 0;
 353 }
 354
 355 static void *ap_main_loop(void *_env)
 356 {
 357     CPUState *env = _env;
 358     sigset_t signals;
 359
 360     vcpu = &vcpu_info[env->cpu_index];
 361     vcpu->env = env;
 362     vcpu->env->thread_id = kvm_get_thread_id();
 363     sigfillset(&signals);
 364     sigprocmask(SIG_BLOCK, &signals, NULL);
 365     kvm_create_vcpu(kvm_context, env->cpu_index);
 366     kvm_qemu_init_env(env);
 367
 368     /* signal VCPU creation */
 369     pthread_mutex_lock(&qemu_mutex);
 370     vcpu->created = 1;
 371     pthread_cond_signal(&qemu_vcpu_cond);
 372
 373     /* and wait for machine initialization */
 374     while (!qemu_system_ready)
 375         pthread_cond_wait(&qemu_system_cond, &qemu_mutex);
 376     pthread_mutex_unlock(&qemu_mutex);
 377
 378     kvm_main_loop_cpu(env);
 379     return NULL;
 380 }
 381
 382 void kvm_init_new_ap(int cpu, CPUState *env)
 383 {
 384     pthread_create(&vcpu_info[cpu].thread, NULL, ap_main_loop, env);
 385
 386     while (vcpu_info[cpu].created == 0)
 387         pthread_cond_wait(&qemu_vcpu_cond, &qemu_mutex);
 388 }
 389
 390 int kvm_init_ap(void)
 391 {
 392 #ifdef TARGET_I386
 393     kvm_tpr_opt_setup();
 394 #endif
 395     qemu_add_vm_change_state_handler(kvm_vm_state_change_handler, NULL);
 396
 397     signal(SIG_IPI, sig_ipi_handler);
 398     return 0;
 399 }
 400
 401 void qemu_kvm_notify_work(void)
 402 {
 403     uint64_t value = 1;
 404     char buffer[8];
 405     size_t offset = 0;
 406
 407     if (io_thread_fd == -1)
 408         return;
 409
 410     memcpy(buffer, &value, sizeof(value));
 411
 412     while (offset < 8) {
 413         ssize_t len;
 414
 415         len = write(io_thread_fd, buffer + offset, 8 - offset);
 416         if (len == -1 && errno == EINTR)
 417             continue;
 418
 419         if (len <= 0)
 420             break;
 421
 422         offset += len;
 423     }
 424
 425     if (offset != 8)
 426         fprintf(stderr, "failed to notify io thread\n");
 427 }
 428
 429 /* If we have signalfd, we mask out the signals we want to handle and then
 430  * use signalfd to listen for them.  We rely on whatever the current signal
 431  * handler is to dispatch the signals when we receive them.
 432  */
 433
 434 static void sigfd_handler(void *opaque)
 435 {
 436     int fd = (unsigned long)opaque;
 437     struct signalfd_siginfo info;
 438     struct sigaction action;
 439     ssize_t len;
 440
 441     while (1) {
 442         do {
 443             len = read(fd, &info, sizeof(info));
 444         } while (len == -1 && errno == EINTR);
 445
 446         if (len == -1 && errno == EAGAIN)
 447             break;
 448
 449         if (len != sizeof(info)) {
 450             printf("read from sigfd returned %ld: %m\n", len);
 451             return;
 452         }
 453
 454         sigaction(info.ssi_signo, NULL, &action);
 455         if (action.sa_handler)
 456             action.sa_handler(info.ssi_signo);
 457
 458         if (info.ssi_signo == SIGUSR2) {
 459             pthread_cond_signal(&qemu_aio_cond);
 460         }
 461     }
 462 }
 463
 464 /* Used to break IO thread out of select */
 465 static void io_thread_wakeup(void *opaque)
 466 {
 467     int fd = (unsigned long)opaque;
 468     char buffer[8];
 469     size_t offset = 0;
 470
 471     while (offset < 8) {
 472         ssize_t len;
 473
 474         len = read(fd, buffer + offset, 8 - offset);
 475         if (len == -1 && errno == EINTR)
 476             continue;
 477
 478         if (len <= 0)
 479             break;
 480
 481         offset += len;
 482     }
 483 }
 484
 485 int kvm_main_loop(void)
 486 {
 487     int fds[2];
 488     sigset_t mask;
 489     int sigfd;
 490
 491     io_thread = pthread_self();
 492     qemu_system_ready = 1;
 493
 494     if (kvm_eventfd(fds) == -1) {
 495         fprintf(stderr, "failed to create eventfd\n");
 496         return -errno;
 497     }
 498
 499     qemu_set_fd_handler2(fds[0], NULL, io_thread_wakeup, NULL,
 500                          (void *)(unsigned long)fds[0]);
 501
 502     io_thread_fd = fds[1];
 503
 504     sigemptyset(&mask);
 505     sigaddset(&mask, SIGIO);
 506     sigaddset(&mask, SIGALRM);
 507     sigaddset(&mask, SIGUSR2);
 508     sigprocmask(SIG_BLOCK, &mask, NULL);
 509
 510     sigfd = kvm_signalfd(&mask);
 511     if (sigfd == -1) {
 512         fprintf(stderr, "failed to create signalfd\n");
 513         return -errno;
 514     }
 515
 516     fcntl(sigfd, F_SETFL, O_NONBLOCK);
 517
 518     qemu_set_fd_handler2(sigfd, NULL, sigfd_handler, NULL,
 519                          (void *)(unsigned long)sigfd);
 520
 521     pthread_cond_broadcast(&qemu_system_cond);
 522
 523     io_thread_sigfd = sigfd;
 524     cpu_single_env = NULL;
 525
 526     while (1) {
 527         main_loop_wait(1000);
 528         if (qemu_shutdown_requested())
 529             break;
 530         else if (qemu_powerdown_requested())
 531             qemu_system_powerdown();
 532         else if (qemu_reset_requested()) {
 533             pthread_kill(vcpu_info[0].thread, SIG_IPI);
 534             qemu_kvm_reset_requested = 1;
 535         }
 536     }
 537
 538     pause_all_threads();
 539     pthread_mutex_unlock(&qemu_mutex);
 540
 541     return 0;
 542 }
 543
 544 static int kvm_debug(void *opaque, int vcpu)
 545 {
 546     CPUState *env = cpu_single_env;
 547
 548     env->exception_index = EXCP_DEBUG;
 549     return 1;
 550 }
 551
 552 static int kvm_inb(void *opaque, uint16_t addr, uint8_t *data)
 553 {
 554     *data = cpu_inb(0, addr);
 555     return 0;
 556 }
 557
 558 static int kvm_inw(void *opaque, uint16_t addr, uint16_t *data)
 559 {
 560     *data = cpu_inw(0, addr);
 561     return 0;
 562 }
 563
 564 static int kvm_inl(void *opaque, uint16_t addr, uint32_t *data)
 565 {
 566     *data = cpu_inl(0, addr);
 567     return 0;
 568 }
 569
 570 #define PM_IO_BASE 0xb000
 571
 572 static int kvm_outb(void *opaque, uint16_t addr, uint8_t data)
 573 {
 574     if (addr == 0xb2) {
 575         switch (data) {
 576         case 0: {
 577             cpu_outb(0, 0xb3, 0);
 578             break;
 579         }
 580         case 0xf0: {
 581             unsigned x;
 582
 583             /* enable acpi */
 584             x = cpu_inw(0, PM_IO_BASE + 4);
 585             x &= ~1;
 586             cpu_outw(0, PM_IO_BASE + 4, x);
 587             break;
 588         }
 589         case 0xf1: {
 590             unsigned x;
 591
 592             /* enable acpi */
 593             x = cpu_inw(0, PM_IO_BASE + 4);
 594             x |= 1;
 595             cpu_outw(0, PM_IO_BASE + 4, x);
 596             break;
 597         }
 598         default:
 599             break;
 600         }
 601         return 0;
 602     }
 603     cpu_outb(0, addr, data);
 604     return 0;
 605 }
 606
 607 static int kvm_outw(void *opaque, uint16_t addr, uint16_t data)
 608 {
 609     cpu_outw(0, addr, data);
 610     return 0;
 611 }
 612
 613 static int kvm_outl(void *opaque, uint16_t addr, uint32_t data)
 614 {
 615     cpu_outl(0, addr, data);
 616     return 0;
 617 }
 618
 619 static int kvm_mmio_read(void *opaque, uint64_t addr, uint8_t *data, int len)
 620 {
 621         cpu_physical_memory_rw(addr, data, len, 0);
 622         return 0;
 623 }
 624
 625 static int kvm_mmio_write(void *opaque, uint64_t addr, uint8_t *data, int len)
 626 {
 627         cpu_physical_memory_rw(addr, data, len, 1);
 628         return 0;
 629 }
 630
 631 static int kvm_io_window(void *opaque)
 632 {
 633     return 1;
 634 }
 635
 636
 637 static int kvm_halt(void *opaque, int vcpu)
 638 {
 639     return kvm_arch_halt(opaque, vcpu);
 640 }
 641
 642 static int kvm_shutdown(void *opaque, int vcpu)
 643 {
 644     qemu_system_reset_request();
 645     return 1;
 646 }
 647
 648 static struct kvm_callbacks qemu_kvm_ops = {
 649     .debug = kvm_debug,
 650     .inb   = kvm_inb,
 651     .inw   = kvm_inw,
 652     .inl   = kvm_inl,
 653     .outb  = kvm_outb,
 654     .outw  = kvm_outw,
 655     .outl  = kvm_outl,
 656     .mmio_read = kvm_mmio_read,
 657     .mmio_write = kvm_mmio_write,
 658     .halt  = kvm_halt,
 659     .shutdown = kvm_shutdown,
 660     .io_window = kvm_io_window,
 661     .try_push_interrupts = try_push_interrupts,
 662     .post_kvm_run = post_kvm_run,
 663     .pre_kvm_run = pre_kvm_run,
 664 #ifdef TARGET_I386
 665     .tpr_access = handle_tpr_access,
 666 #endif
 667 #ifdef TARGET_PPC
 668     .powerpc_dcr_read = handle_powerpc_dcr_read,
 669     .powerpc_dcr_write = handle_powerpc_dcr_write,
 670 #endif
 671 };
 672
 673 int kvm_qemu_init()
 674 {
 675     /* Try to initialize kvm */
 676     kvm_context = kvm_init(&qemu_kvm_ops, cpu_single_env);
 677     if (!kvm_context) {
 678         return -1;
 679     }
 680     pthread_mutex_lock(&qemu_mutex);
 681
 682     return 0;
 683 }
 684
 685 int kvm_qemu_create_context(void)
 686 {
 687     int r;
 688     if (!kvm_irqchip) {
 689         kvm_disable_irqchip_creation(kvm_context);
 690     }
 691     if (!kvm_pit) {
 692         kvm_disable_pit_creation(kvm_context);
 693     }
 694     if (kvm_create(kvm_context, phys_ram_size, (void**)&phys_ram_base) < 0) {
 695         kvm_qemu_destroy();
 696         return -1;
 697     }
 698     r = kvm_arch_qemu_create_context();
 699     if(r <0)
 700         kvm_qemu_destroy();
 701     return 0;
 702 }
 703
 704 void kvm_qemu_destroy(void)
 705 {
 706     kvm_finalize(kvm_context);
 707 }
 708
 709 void kvm_cpu_register_physical_memory(target_phys_addr_t start_addr,
 710                                       unsigned long size,
 711                                       unsigned long phys_offset)
 712 {
 713 #ifdef KVM_CAP_USER_MEMORY
 714     int r = 0;
 715
 716     r = kvm_check_extension(kvm_context, KVM_CAP_USER_MEMORY);
 717     if (r) {
 718         if (!(phys_offset & ~TARGET_PAGE_MASK)) {
 719                 r = kvm_is_allocated_mem(kvm_context, start_addr, size);
 720             if (r)
 721                 return;
 722             r = kvm_is_intersecting_mem(kvm_context, start_addr);
 723             if (r)
 724                 kvm_create_mem_hole(kvm_context, start_addr, size);
 725             r = kvm_register_userspace_phys_mem(kvm_context, start_addr,
 726                                                 phys_ram_base + phys_offset,
 727                                                 size, 0);
 728         }
 729         if (phys_offset & IO_MEM_ROM) {
 730             phys_offset &= ~IO_MEM_ROM;
 731             r = kvm_is_intersecting_mem(kvm_context, start_addr);
 732             if (r)
 733                 kvm_create_mem_hole(kvm_context, start_addr, size);
 734             r = kvm_register_userspace_phys_mem(kvm_context, start_addr,
 735                                                 phys_ram_base + phys_offset,
 736                                                 size, 0);
 737         }
 738         if (r < 0) {
 739             printf("kvm_cpu_register_physical_memory: failed\n");
 740             exit(1);
 741         }
 742         return;
 743     }
 744 #endif
 745     if (phys_offset & IO_MEM_ROM) {
 746         phys_offset &= ~IO_MEM_ROM;
 747         memcpy(phys_ram_base + start_addr, phys_ram_base + phys_offset, size);
 748     }
 749 }
 750
 751 int kvm_qemu_check_extension(int ext)
 752 {
 753     return kvm_check_extension(kvm_context, ext);
 754 }
 755
 756 int kvm_qemu_init_env(CPUState *cenv)
 757 {
 758     return kvm_arch_qemu_init_env(cenv);
 759 }
 760
 761 int kvm_update_debugger(CPUState *env)
 762 {
 763     struct kvm_debug_guest dbg;
 764     int i;
 765
 766     dbg.enabled = 0;
 767     if (env->nb_breakpoints || env->singlestep_enabled) {
 768         dbg.enabled = 1;
 769         for (i = 0; i < 4 && i < env->nb_breakpoints; ++i) {
 770             dbg.breakpoints[i].enabled = 1;
 771             dbg.breakpoints[i].address = env->breakpoints[i];
 772         }
 773         dbg.singlestep = env->singlestep_enabled;
 774     }
 775     return kvm_guest_debug(kvm_context, env->cpu_index, &dbg);
 776 }
 777
 778
 779 /*
 780  * dirty pages logging
 781  */
 782 /* FIXME: use unsigned long pointer instead of unsigned char */
 783 unsigned char *kvm_dirty_bitmap = NULL;
 784 int kvm_physical_memory_set_dirty_tracking(int enable)
 785 {
 786     int r = 0;
 787
 788     if (!kvm_enabled())
 789         return 0;
 790
 791     if (enable) {
 792         if (!kvm_dirty_bitmap) {
 793             unsigned bitmap_size = BITMAP_SIZE(phys_ram_size);
 794             kvm_dirty_bitmap = qemu_malloc(bitmap_size);
 795             if (kvm_dirty_bitmap == NULL) {
 796                 perror("Failed to allocate dirty pages bitmap");
 797                 r=-1;
 798             }
 799             else {
 800                 r = kvm_dirty_pages_log_enable_all(kvm_context);
 801             }
 802         }
 803     }
 804     else {
 805         if (kvm_dirty_bitmap) {
 806             r = kvm_dirty_pages_log_reset(kvm_context);
 807             qemu_free(kvm_dirty_bitmap);
 808             kvm_dirty_bitmap = NULL;
 809         }
 810     }
 811     return r;
 812 }
 813
 814 /* get kvm's dirty pages bitmap and update qemu's */
 815 int kvm_get_dirty_pages_log_range(unsigned long start_addr,
 816                                   unsigned char *bitmap,
 817                                   unsigned int offset,
 818                                   unsigned long mem_size)
 819 {
 820     unsigned int i, j, n=0;
 821     unsigned char c;
 822     unsigned page_number, addr, addr1;
 823     unsigned int len = ((mem_size/TARGET_PAGE_SIZE) + 7) / 8;
 824
 825     /*
 826      * bitmap-traveling is faster than memory-traveling (for addr...)
 827      * especially when most of the memory is not dirty.
 828      */
 829     for (i=0; i<len; i++) {
 830         c = bitmap[i];
 831         while (c>0) {
 832             j = ffsl(c) - 1;
 833             c &= ~(1u<<j);
 834             page_number = i * 8 + j;
 835             addr1 = page_number * TARGET_PAGE_SIZE;
 836             addr  = offset + addr1;
 837             cpu_physical_memory_set_dirty(addr);
 838             n++;
 839         }
 840     }
 841     return 0;
 842 }
 843 int kvm_get_dirty_bitmap_cb(unsigned long start, unsigned long len,
 844                             void *bitmap, void *opaque)
 845 {
 846     return kvm_get_dirty_pages_log_range(start, bitmap, start, len);
 847 }
 848
 849 /*
 850  * get kvm's dirty pages bitmap and update qemu's
 851  * we only care about physical ram, which resides in slots 0 and 3
 852  */
 853 int kvm_update_dirty_pages_log(void)
 854 {
 855     int r = 0;
 856
 857
 858     r = kvm_get_dirty_pages_range(kvm_context, 0, phys_ram_size,
 859                                   kvm_dirty_bitmap, NULL,
 860                                   kvm_get_dirty_bitmap_cb);
 861     return r;
 862 }
 863
 864 int kvm_get_phys_ram_page_bitmap(unsigned char *bitmap)
 865 {
 866     unsigned int bsize  = BITMAP_SIZE(phys_ram_size);
 867     unsigned int brsize = BITMAP_SIZE(ram_size);
 868     unsigned int extra_pages = (phys_ram_size - ram_size) / TARGET_PAGE_SIZE;
 869     unsigned int extra_bytes = (extra_pages +7)/8;
 870     unsigned int hole_start = BITMAP_SIZE(0xa0000);
 871     unsigned int hole_end   = BITMAP_SIZE(0xc0000);
 872
 873     memset(bitmap, 0xFF, brsize + extra_bytes);
 874     memset(bitmap + hole_start, 0, hole_end - hole_start);
 875     memset(bitmap + brsize + extra_bytes, 0, bsize - brsize - extra_bytes);
 876
 877     return 0;
 878 }
 879
 880 #ifdef KVM_CAP_IRQCHIP
 881
 882 int kvm_set_irq(int irq, int level)
 883 {
 884     return kvm_set_irq_level(kvm_context, irq, level);
 885 }
 886
 887 #endif
 888
 889 void qemu_kvm_aio_wait_start(void)
 890 {
 891 }
 892
 893 void qemu_kvm_aio_wait(void)
 894 {
 895     CPUState *cpu_single = cpu_single_env;
 896
 897     if (!cpu_single_env) {
 898         if (io_thread_sigfd != -1) {
 899             fd_set rfds;
 900             int ret;
 901
 902             FD_ZERO(&rfds);
 903             FD_SET(io_thread_sigfd, &rfds);
 904
 905             /* this is a rare case where we do want to hold qemu_mutex
 906              * while sleeping.  We cannot allow anything else to run
 907              * right now. */
 908             ret = select(io_thread_sigfd + 1, &rfds, NULL, NULL, NULL);
 909             if (ret > 0 && FD_ISSET(io_thread_sigfd, &rfds))
 910                 sigfd_handler((void *)(unsigned long)io_thread_sigfd);
 911         }
 912         qemu_aio_poll();
 913     } else {
 914         pthread_cond_wait(&qemu_aio_cond, &qemu_mutex);
 915         cpu_single_env = cpu_single;
 916     }
 917 }
 918
 919 void qemu_kvm_aio_wait_end(void)
 920 {
 921 }
 922
 923 int qemu_kvm_get_dirty_pages(unsigned long phys_addr, void *buf)
 924 {
 925     return kvm_get_dirty_pages(kvm_context, phys_addr, buf);
 926 }
 927
 928 void *kvm_cpu_create_phys_mem(target_phys_addr_t start_addr,
 929                               unsigned long size, int log, int writable)
 930 {
 931     return kvm_create_phys_mem(kvm_context, start_addr, size, log, writable);
 932 }
 933
 934 void kvm_cpu_destroy_phys_mem(target_phys_addr_t start_addr,
 935                               unsigned long size)
 936 {
 937     kvm_destroy_phys_mem(kvm_context, start_addr, size);
 938 }
 939
 940 void kvm_mutex_unlock(void)
 941 {
 942     pthread_mutex_unlock(&qemu_mutex);
 943 }
 944
 945 void kvm_mutex_lock(void)
 946 {
 947     pthread_mutex_lock(&qemu_mutex);
 948     cpu_single_env = NULL;
 949 }