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