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