migration.c

   1 /*
   2  * QEMU migration support
   3  *
   4  * Copyright (C) 2007 Anthony Liguori <anthony@codemonkey.ws>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "hw/hw.h"
  26 #include "sysemu.h"
  27 #include "block.h"
  28 #include "console.h"
  29 #include "qemu-timer.h"
  30 #include "migration.h"
  31 #include "qemu_socket.h"
  32 #ifdef USE_KVM
  33 #include "qemu-kvm.h"
  34 #endif
  35
  36 #include <sys/wait.h>
  37
  38 #define MIN_FINALIZE_SIZE       (200 << 10)
  39 #define MAX_ITERATIONS           30
  40 #define MAX_RAPID_WRITES          5
  41
  42 typedef struct MigrationState
  43 {
  44     int fd;
  45     int throttle_count;
  46     int bps;
  47     int updated_pages;
  48     int last_updated_pages;
  49     int iteration;
  50     int n_buffer; /* number of bytes in @buffer already sent */
  51     int l_buffer; /* number of bytes in @buffer to send */
  52     int throttled;
  53     int *has_error;
  54     char buffer[TARGET_PAGE_SIZE + 4 + 4];
  55     target_ulong addr;
  56     QEMUTimer *timer;
  57     void *opaque;
  58     int detach;
  59     int (*release)(void *opaque);
  60     int rapid_writes;
  61 } MigrationState;
  62
  63 static uint32_t max_throttle = (32 << 20);
  64 static MigrationState *current_migration;
  65 static int wait_for_message_timeout = 3000; /* 3 seconds */
  66 static int status; /* last migration status */
  67
  68 enum { /* migration status values */
  69     MIG_STAT_SUCCESS           = 0,
  70
  71     /* src error codes */
  72     MIG_STAT_INVALID_PARAMS    = 1,
  73     MIG_STAT_INVALID_ADDR      = 2,
  74     MIG_STAT_SOCKET_FAILED     = 3,
  75     MIG_STAT_SOCKOPT_FAILED    = 4,
  76     MIG_STAT_BIND_FAILED       = 5,
  77     MIG_STAT_LISTEN_FAILED     = 6,
  78     MIG_STAT_ACCEPT_FAILED     = 7,
  79     MIG_STAT_CONNECT_FAILED    = 8,
  80     MIG_STAT_WRITE_FAILED      = 9,
  81     MIG_STAT_READ_FAILED       = 10,
  82     MIG_STAT_CONNECTION_CLOSED = 11,
  83     MIG_STAT_SELECT_FAILED     = 12,
  84     MIG_STAT_SELECT_TIMEOUT    = 13,
  85     MIG_STAT_SELECT_FD_NOT_SET = 14,
  86
  87     MIG_STAT_SAVEVM_FAILED     = 15,
  88     MIG_STAT_NO_MEM            = 16,
  89
  90     MIG_STAT_MIGRATION_CANCEL  = 20,
  91
  92     /* kvm error codes (on src) */
  93     MIG_STAT_KVM_UPDATE_DIRTY_PAGES_LOG_FAILED  = 101,
  94     MIG_STAT_KVM_SET_DIRTY_TRACKING_FAILED      = 102,
  95     MIG_STAT_KVM_GET_PAGE_BITMAP                = 103,
  96
  97     /* dst error codes */
  98     MIG_STAT_DST_INVALID_PARAMS    = 200 + MIG_STAT_INVALID_PARAMS,
  99     MIG_STAT_DST_INVALID_ADDR      = 200 + MIG_STAT_INVALID_ADDR,
 100     MIG_STAT_DST_SOCKET_FAILED     = 200 + MIG_STAT_SOCKET_FAILED,
 101     MIG_STAT_DST_SOCKOPT_FAILED    = 200 + MIG_STAT_SOCKOPT_FAILED,
 102     MIG_STAT_DST_BIND_FAILED       = 200 + MIG_STAT_BIND_FAILED,
 103     MIG_STAT_DST_LISTEN_FAILED     = 200 + MIG_STAT_LISTEN_FAILED,
 104     MIG_STAT_DST_ACCEPT_FAILED     = 200 + MIG_STAT_ACCEPT_FAILED,
 105     MIG_STAT_DST_CONNECT_FAILED    = 200 + MIG_STAT_CONNECT_FAILED,
 106     MIG_STAT_DST_WRITE_FAILED      = 200 + MIG_STAT_WRITE_FAILED,
 107     MIG_STAT_DST_READ_FAILED       = 200 + MIG_STAT_READ_FAILED,
 108
 109     MIG_STAT_DST_CONNECTION_CLOSED = 200 + MIG_STAT_CONNECTION_CLOSED,
 110     MIG_STAT_DST_SELECT_FAILED     = 200 + MIG_STAT_SELECT_FAILED,
 111     MIG_STAT_DST_SELECT_TIMEOUT    = 200 + MIG_STAT_SELECT_TIMEOUT,
 112     MIG_STAT_DST_SELECT_FD_NOT_SET = 200 + MIG_STAT_SELECT_FD_NOT_SET,
 113
 114     MIG_STAT_DST_LOADVM_FAILED     = 200 + MIG_STAT_SAVEVM_FAILED,
 115     MIG_STAT_DST_NO_MEM            = 200 + MIG_STAT_NO_MEM,
 116
 117     MIG_STAT_DST_GET_PAGE_FAILED       = 230,
 118     MIG_STAT_DST_GET_PAGE_UNKNOWN_TYPE = 231,
 119     MIG_STAT_DST_MEM_SIZE_MISMATCH     = 232,
 120     MIG_STAT_DST_MEM_OUT_OF_RANGE      = 233,
 121 };
 122
 123 //#define MIGRATION_VERIFY
 124 #ifdef MIGRATION_VERIFY
 125 static int save_verify_memory(QEMUFile *f, void *opaque);
 126 static int load_verify_memory(QEMUFile *f, void *opaque, int version_id);
 127 #endif /* MIGRATION_VERIFY */
 128
 129 /* QEMUFile migration implementation */
 130
 131 static void migrate_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, int size)
 132 {
 133     MigrationState *s = opaque;
 134     int offset = 0;
 135
 136     if (*s->has_error)
 137         return;
 138
 139     while (offset < size) {
 140         ssize_t len;
 141
 142         len = write(s->fd, buf + offset, size - offset);
 143         if (len == -1) {
 144             if (errno == EAGAIN || errno == EINTR)
 145                 continue;
 146             term_printf("migration: write failed (%s)\n", strerror(errno));
 147             *s->has_error = MIG_STAT_WRITE_FAILED;
 148             break;
 149         } else if (len == 0) {
 150             term_printf("migration: other side closed connection\n");
 151             *s->has_error = MIG_STAT_CONNECTION_CLOSED;
 152             break;
 153         }
 154
 155         offset += len;
 156     }
 157 }
 158
 159 static void migrate_close(void *opaque)
 160 {
 161     MigrationState *s = opaque;
 162
 163     if (s->release)
 164         s->release(s->opaque);
 165
 166     qemu_free(s);
 167     current_migration = NULL;
 168 }
 169
 170 /* Outgoing migration routines */
 171 static void migrate_finish(MigrationState *s)
 172 {
 173     QEMUFile *f;
 174     int ret = 0;
 175     int *has_error = s->has_error;
 176     int saved_vm_running = vm_running;
 177     int detach = s->detach;
 178
 179     fcntl(s->fd, F_SETFL, 0);
 180
 181     if (! *has_error) {
 182         vm_stop(0);
 183         f = qemu_fopen(s, migrate_put_buffer, NULL, migrate_close);
 184         do {
 185             qemu_aio_flush();
 186         } while (qemu_bh_poll());
 187         bdrv_flush_all();
 188 #ifdef USE_KVM
 189         if (kvm_allowed && !*s->has_error && kvm_update_dirty_pages_log())
 190             *s->has_error = MIG_STAT_KVM_UPDATE_DIRTY_PAGES_LOG_FAILED;
 191 #endif
 192         qemu_put_be32(f, 1);
 193         ret = qemu_live_savevm_state(f);
 194 #ifdef MIGRATION_VERIFY
 195         save_verify_memory(f, NULL);
 196 #endif /* MIGRATION_VERIFY */
 197         qemu_fclose(f);
 198     } else {
 199             migrate_close(s);
 200     }
 201     status = *has_error;
 202     if (ret && !status)
 203         status = MIG_STAT_SAVEVM_FAILED;
 204     if (status) {
 205         term_printf("Migration failed! ret=%d error=%d\n", ret, *has_error);
 206         if (saved_vm_running)
 207             vm_start();
 208     }
 209     if (!detach)
 210         monitor_resume();
 211     qemu_free(has_error);
 212     cpu_physical_memory_set_dirty_tracking(0);
 213 }
 214
 215 static int migrate_write_buffer(MigrationState *s)
 216 {
 217     if (*s->has_error)
 218         return 0;
 219
 220     if (s->n_buffer < s->l_buffer) {
 221         ssize_t len;
 222     again:
 223         len = write(s->fd, s->buffer + s->n_buffer, s->l_buffer - s->n_buffer);
 224         if (len == -1) {
 225             if (errno == EINTR)
 226                 goto again;
 227             if (errno == EAGAIN)
 228                 return 1;
 229             *s->has_error = MIG_STAT_WRITE_FAILED;
 230             return 0;
 231         }
 232         if (len == 0) {
 233             *s->has_error = MIG_STAT_CONNECTION_CLOSED;
 234             return 0;
 235         }
 236
 237         s->throttle_count += len;
 238         s->n_buffer += len;
 239         if (s->n_buffer < s->l_buffer)
 240             goto again;
 241     }
 242
 243     if (s->throttle_count > max_throttle) {
 244         s->throttled = 1;
 245         qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
 246         return 1;
 247     }
 248
 249     return 0;
 250 }
 251
 252 static int migrate_check_convergence(MigrationState *s)
 253 {
 254     target_ulong addr;
 255     int dirty_count = 0;
 256
 257     if ((s->iteration >= MAX_ITERATIONS) ||
 258         (s->rapid_writes >= MAX_RAPID_WRITES) ) {
 259         return 1;
 260     }
 261
 262     for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
 263 #ifdef USE_KVM
 264         if (kvm_allowed && (addr>=0xa0000) && (addr<0xc0000)) /* do not access video-addresses */
 265             continue;
 266 #endif
 267         if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
 268             dirty_count++;
 269     }
 270
 271     return ((dirty_count * TARGET_PAGE_SIZE) < MIN_FINALIZE_SIZE);
 272 }
 273
 274 static int ram_page_is_homogeneous(uint32_t addr)
 275 {
 276     int i, n;
 277     uint32_t *p, v;
 278
 279     n = TARGET_PAGE_SIZE / sizeof(v);
 280     p = (uint32 *)(phys_ram_base + addr);
 281
 282     v = p[0];
 283     for (i=1; i<n; i++)
 284         if (p[i] != v)
 285             return 0;
 286     return 1;
 287 }
 288
 289 static void migrate_prepare_page(MigrationState *s)
 290 {
 291     uint32_t value;
 292     char type;
 293     const char *buff;
 294     int bufflen;
 295
 296     value = cpu_to_be32(s->addr);
 297     memcpy(s->buffer, &value, 4);
 298
 299     if (ram_page_is_homogeneous(s->addr)) {
 300         type = 1; /* keeping ram_get_page() values */
 301         bufflen = 4;
 302     }
 303     else {
 304         type = 0;
 305         bufflen = TARGET_PAGE_SIZE;
 306     }
 307
 308     buff = phys_ram_base + s->addr;
 309     s->buffer[4] = type;
 310     memcpy(s->buffer + 4 + 1, phys_ram_base + s->addr, bufflen);
 311     s->n_buffer = 0;
 312     s->l_buffer = 4 + 1 + bufflen;
 313 }
 314
 315 static void migrate_write(void *opaque)
 316 {
 317     MigrationState *s = opaque;
 318
 319     if (migrate_write_buffer(s))
 320         return;
 321
 322 #ifdef USE_KVM
 323     if (kvm_allowed && !*s->has_error && kvm_update_dirty_pages_log())
 324         *s->has_error = MIG_STAT_KVM_UPDATE_DIRTY_PAGES_LOG_FAILED;
 325 #endif
 326
 327     if (migrate_check_convergence(s) || *s->has_error) {
 328         qemu_del_timer(s->timer);
 329         qemu_free_timer(s->timer);
 330         qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
 331         migrate_finish(s);
 332         return;
 333     }
 334
 335     while (s->addr < phys_ram_size) {
 336 #ifdef USE_KVM
 337         if (kvm_allowed && (s->addr>=0xa0000) && (s->addr<0xc0000)) /* do not access video-addresses */
 338             s->addr = 0xc0000;
 339 #endif
 340
 341         if (cpu_physical_memory_get_dirty(s->addr, MIGRATION_DIRTY_FLAG)) {
 342             migrate_prepare_page(s);
 343             cpu_physical_memory_reset_dirty(s->addr, s->addr + TARGET_PAGE_SIZE, MIGRATION_DIRTY_FLAG);
 344
 345             s->addr += TARGET_PAGE_SIZE;
 346
 347             s->updated_pages++;
 348
 349             if (migrate_write_buffer(s))
 350                 return;
 351         } else
 352             s->addr += TARGET_PAGE_SIZE;
 353     }
 354
 355     if ((s->iteration) && (s->last_updated_pages <= s->updated_pages)) {
 356         s->rapid_writes++; /* "dirt-speed" is faster than transfer speed */
 357         if (max_throttle < (1 << 30))
 358             max_throttle *= 2; /* try harder */
 359     }
 360     s->last_updated_pages = s->updated_pages;
 361     s->updated_pages = 0;
 362     s->addr = 0;
 363     s->iteration++;
 364 }
 365
 366 static void migrate_reset_throttle(void *opaque)
 367 {
 368     MigrationState *s = opaque;
 369
 370     s->bps = s->throttle_count;
 371
 372     if (s->throttled) {
 373         s->throttled = 0;
 374         qemu_set_fd_handler2(s->fd, NULL, NULL, migrate_write, s);
 375     }
 376     s->throttle_count = 0;
 377     qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 1000);
 378 }
 379
 380 static int write_whole_buffer(int fd, const void *buff, size_t size)
 381 {
 382     size_t offset = 0, len;
 383
 384     while (offset < size) {
 385         len = write(fd, buff + offset, size - offset);
 386         if (len == -1 && errno == EINTR)
 387             continue;
 388         if (len < 1)
 389             return -EIO;
 390
 391         offset += len;
 392     }
 393     return !(offset == size); /* returns 0 on success */
 394 }
 395
 396 static int bit_is_set(int bit, unsigned char *map)
 397 {
 398     return map[bit/8] & (1 << (bit%8));
 399 }
 400
 401 static int start_migration(MigrationState *s)
 402 {
 403     uint32_t value = cpu_to_be32(phys_ram_size);
 404     target_phys_addr_t addr;
 405     int r;
 406     unsigned char running = vm_running?2:1; /* 1 + vm_running */
 407
 408 #ifdef USE_KVM
 409     int n = 0;
 410     unsigned char *phys_ram_page_exist_bitmap = NULL;
 411     if (kvm_allowed) {
 412         n = BITMAP_SIZE(phys_ram_size);
 413         phys_ram_page_exist_bitmap = qemu_malloc(n);
 414         if (!phys_ram_page_exist_bitmap) {
 415             perror("failed to allocate page bitmap");
 416             r = MIG_STAT_NO_MEM;
 417             goto out;
 418         }
 419         if (kvm_get_phys_ram_page_bitmap(phys_ram_page_exist_bitmap)) {
 420             r = MIG_STAT_KVM_GET_PAGE_BITMAP;
 421             perror("kvm_get_mem_map failed");
 422             goto out;
 423         }
 424     }
 425 #endif
 426
 427     r = MIG_STAT_WRITE_FAILED;
 428     if (write_whole_buffer(s->fd, &running, sizeof(running))) {
 429         perror("vm_running write failed");
 430         goto out;
 431     }
 432     if (write_whole_buffer(s->fd, &value, sizeof(value))) {
 433         perror("phys_ram_size write failed");
 434         goto out;
 435     }
 436
 437 #ifdef USE_KVM
 438     if (kvm_allowed) {
 439         value = cpu_to_be32(n);
 440         if (write_whole_buffer(s->fd, &value, sizeof(value))) {
 441             perror("phys_ram_size_bitmap size write failed");
 442             goto out;
 443         }
 444         if (write_whole_buffer(s->fd, phys_ram_page_exist_bitmap, n)) {
 445             perror("phys_ram_page_exist_bitmap write failed");
 446             goto out;
 447         }
 448     }
 449 #endif
 450     fcntl(s->fd, F_SETFL, O_NONBLOCK);
 451
 452     for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
 453 #ifdef USE_KVM
 454         if (kvm_allowed && !bit_is_set(addr>>TARGET_PAGE_BITS, phys_ram_page_exist_bitmap)) {
 455             cpu_physical_memory_reset_dirty(addr,
 456                                             addr + TARGET_PAGE_SIZE,
 457                                             MIGRATION_DIRTY_FLAG);
 458             continue;
 459         }
 460 #endif
 461         if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
 462             cpu_physical_memory_set_dirty(addr);
 463     }
 464
 465     if (cpu_physical_memory_set_dirty_tracking(1)) {
 466         *s->has_error = MIG_STAT_KVM_SET_DIRTY_TRACKING_FAILED;
 467         r = MIG_STAT_KVM_SET_DIRTY_TRACKING_FAILED;
 468         goto out;
 469     }
 470
 471     s->addr = 0;
 472     s->iteration = 0;
 473     s->updated_pages = 0;
 474     s->last_updated_pages = 0;
 475     s->n_buffer = s->l_buffer = 0;
 476     s->rapid_writes = 0;
 477     s->timer = qemu_new_timer(rt_clock, migrate_reset_throttle, s);
 478
 479     qemu_mod_timer(s->timer, qemu_get_clock(rt_clock));
 480     qemu_set_fd_handler2(s->fd, NULL, NULL, migrate_write, s);
 481
 482     r = 0;
 483
 484  out:
 485 #ifdef USE_KVM
 486     if (phys_ram_page_exist_bitmap)
 487         qemu_free(phys_ram_page_exist_bitmap);
 488 #endif
 489     return r;
 490 }
 491
 492 static MigrationState *migration_init_fd(int detach, int fd)
 493 {
 494     MigrationState *s;
 495
 496     s = qemu_mallocz(sizeof(MigrationState));
 497     if (s == NULL) {
 498         term_printf("Allocation error\n");
 499         return NULL;
 500     }
 501
 502     s->fd = fd;
 503     s->has_error = qemu_mallocz(sizeof(int));
 504     if (s->has_error == NULL) {
 505         term_printf("malloc failed (for has_error)\n");
 506         return NULL;
 507     }
 508     s->detach = detach;
 509
 510     current_migration = s;
 511
 512     if (start_migration(s)) {
 513         term_printf("Could not start migration\n");
 514         migrate_finish(s);
 515         return NULL;
 516     }
 517
 518     if (!detach)
 519         monitor_suspend();
 520
 521     return s;
 522 }
 523
 524 typedef struct MigrationCmdState
 525 {
 526     int fd;
 527     pid_t pid;
 528 } MigrationCmdState;
 529
 530 static int cmd_release(void *opaque)
 531 {
 532     MigrationCmdState *c = opaque;
 533     int status, ret;
 534
 535     close(c->fd);
 536
 537 again:
 538     ret = waitpid(c->pid, &status, 0);
 539     if (ret == -1 && errno == EINTR)
 540         goto again;
 541
 542     if (ret == -1) {
 543         term_printf("migration: waitpid failed (%s)\n", strerror(errno));
 544         return -1;
 545     }
 546     /* FIXME: check and uncomment
 547      * if (WIFEXITED(status))
 548      *     status = WEXITSTATUS(status);
 549      */
 550     return status;
 551 }
 552
 553 static MigrationState *migration_init_cmd(int detach, const char *command, char **argv)
 554 {
 555     int fds[2];
 556     pid_t pid;
 557     int i;
 558     MigrationState *s;
 559
 560     if (pipe(fds) == -1) {
 561         term_printf("pipe() (%s)\n", strerror(errno));
 562         return NULL;
 563     }
 564
 565     pid = fork();
 566     if (pid == -1) {
 567         close(fds[0]);
 568         close(fds[1]);
 569         term_printf("fork error (%s)\n", strerror(errno));
 570         return NULL;
 571     }
 572     if (pid == 0) {
 573         close(fds[1]);
 574         dup2(fds[0], STDIN_FILENO);
 575         execvp(command, argv);
 576         exit(1);
 577     } else
 578         close(fds[0]);
 579
 580     for (i = 0; argv[i]; i++)
 581         qemu_free(argv[i]);
 582     qemu_free(argv);
 583
 584     s = migration_init_fd(detach, fds[1]);
 585     if (s) {
 586         MigrationCmdState *c = qemu_mallocz(sizeof(*c));
 587         c->pid = pid;
 588         c->fd = fds[1];
 589         s->release = cmd_release;
 590         s->opaque = c;
 591     }
 592
 593     return s;
 594 }
 595
 596 static MigrationState *migration_init_exec(int detach, const char *command)
 597 {
 598     char **argv = NULL;
 599
 600     argv = qemu_mallocz(sizeof(char *) * 4);
 601     argv[0] = strdup("sh");
 602     argv[1] = strdup("-c");
 603     argv[2] = strdup(command);
 604     argv[3] = NULL;
 605
 606     return migration_init_cmd(detach, "/bin/sh", argv);
 607 }
 608
 609 static MigrationState *migration_init_ssh(int detach, const char *host)
 610 {
 611     int qemu_argc, daemonize = 0, argc, i;
 612     char **qemu_argv, **argv;
 613     const char *incoming = NULL;
 614
 615     qemu_get_launch_info(&qemu_argc, &qemu_argv, &daemonize, &incoming);
 616
 617     argc = 3 + qemu_argc;
 618     if (!daemonize)
 619         argc++;
 620     if (!incoming)
 621         argc+=2;
 622
 623     argv = qemu_mallocz(sizeof(char *) * (argc + 1));
 624     argv[0] = strdup("ssh");
 625     argv[1] = strdup("-XC");
 626     argv[2] = strdup(host);
 627
 628     for (i = 0; i < qemu_argc; i++)
 629         argv[3 + i] = strdup(qemu_argv[i]);
 630
 631     if (!daemonize)
 632         argv[3 + i++] = strdup("-daemonize");
 633     if (!incoming) {
 634         argv[3 + i++] = strdup("-incoming");
 635         argv[3 + i++] = strdup("stdio");
 636     }
 637
 638     argv[3 + i] = NULL;
 639
 640     return migration_init_cmd(detach, "ssh", argv);
 641 }
 642
 643 /* (busy) wait timeout (miliseconds) for a message to arrive on fd. */
 644 /* returns 0 on success error_code otherwise (18 for timeout) */
 645 static int wait_for_message(const char *msg, int fd, int timeout)
 646 {
 647     fd_set rfds;
 648     struct timeval tv;
 649     int64_t now, expiration, delta; /* milliseconds */
 650     int n = 0;
 651
 652     now = qemu_get_clock(rt_clock);
 653     expiration = now + timeout;
 654     do {
 655         FD_ZERO(&rfds);
 656         FD_SET(fd, &rfds);
 657         tv.tv_sec = tv.tv_usec = 0;
 658         now = qemu_get_clock(rt_clock);
 659         delta = expiration - now;
 660         if (delta > 0)
 661             tv.tv_usec = delta * 1000;
 662         n = select(fd + 1, &rfds, NULL, NULL, &tv);
 663     } while ( (n == -1) && (errno == EINTR) );
 664
 665     switch (n) {
 666     case -1: /* error */
 667         fprintf(stderr, "%s FAILED: ", msg);
 668         perror("");
 669         return MIG_STAT_SELECT_FAILED;
 670     case 0: /* timeout */
 671         fprintf(stderr, "%s: timeout reached\n", msg);
 672         return MIG_STAT_SELECT_TIMEOUT;
 673     case 1:
 674         break;
 675     default:
 676         fprintf(stderr, "wait_for_message: %s: select returned  %d\n", msg, n);
 677     }
 678     if (!FD_ISSET(fd, &rfds)) {
 679         fprintf(stderr, "wait_for_message: %s: s->fd not set\n", msg);
 680         return MIG_STAT_SELECT_FD_NOT_SET;
 681     }
 682
 683     return 0;
 684 }
 685
 686 static int tcp_release(void *opaque)
 687 {
 688     MigrationState *s = opaque;
 689     uint8_t status = 0;
 690     ssize_t len = 0;
 691     int n;
 692
 693     if (*s->has_error)
 694         goto out;
 695
 696     n = wait_for_message("WAIT FOR ACK", s->fd, wait_for_message_timeout);
 697     if (n) {
 698         *s->has_error = n;
 699         goto out;
 700     }
 701
 702 wait_for_ack:
 703     len = read(s->fd, &status, 1);
 704     if (len == -1 && errno == EINTR)
 705         goto wait_for_ack;
 706     if (len != 1 || status != 0) {
 707         *s->has_error = MIG_STAT_READ_FAILED;
 708         fprintf(stderr, "migration: wait_for_ack: read error l=%zu s=%d(%s)\n",
 709                 len, status, strerror(errno));
 710         goto out;
 711     }
 712
 713 send_go:
 714     len = write(s->fd, &status, 1);
 715     if (len == -1 && errno == EINTR)
 716         goto send_go;
 717     if (len != 1) {
 718         fprintf(stderr, "migration: send_go: write error l=%zu (%s)\n",
 719                 len, strerror(errno));
 720         *s->has_error = MIG_STAT_WRITE_FAILED;
 721     }
 722
 723 out:
 724     close(s->fd);
 725
 726     return (len != 1 || status != 0);
 727 }
 728
 729 static MigrationState *migration_init_tcp(int detach, const char *host)
 730 {
 731     int fd;
 732     struct sockaddr_in addr;
 733     MigrationState *s;
 734
 735     fd = socket(PF_INET, SOCK_STREAM, 0);
 736     if (fd == -1) {
 737         term_printf("socket() failed %s\n", strerror(errno));
 738         status = MIG_STAT_SOCKET_FAILED;
 739         return NULL;
 740     }
 741
 742     addr.sin_family = AF_INET;
 743     if (parse_host_port(&addr, host) == -1) {
 744         term_printf("parse_host_port() FAILED for %s\n", host);
 745         close(fd);
 746         status = MIG_STAT_INVALID_ADDR;
 747         return NULL;
 748     }
 749
 750 again:
 751     if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
 752         if (errno == EINTR)
 753             goto again;
 754         term_printf("connect() failed %s\n", strerror(errno));
 755         close(fd);
 756         status = MIG_STAT_CONNECT_FAILED;
 757         return NULL;
 758     }
 759
 760     s = migration_init_fd(detach, fd);
 761     if (s) {
 762         s->opaque = s;
 763         s->release = tcp_release;
 764     }
 765     return s;
 766 }
 767
 768 /* Incoming migration */
 769
 770 static void migrate_incoming_homogeneous_page(uint32_t addr, uint32_t v)
 771 {
 772     int i, n;
 773     uint32_t *p;
 774
 775     n = TARGET_PAGE_SIZE / sizeof(v);
 776     p = (uint32 *)(phys_ram_base + addr);
 777
 778     for (i=0; i<n; i++)
 779         p[i] = v;
 780 }
 781
 782 static int migrate_incoming_page(QEMUFile *f, uint32_t addr)
 783 {
 784     int l, v, ret = 0;
 785
 786     switch (qemu_get_byte(f)) {
 787     case 0: /* the whole page */
 788         l = qemu_get_buffer(f, phys_ram_base + addr, TARGET_PAGE_SIZE);
 789         if (l != TARGET_PAGE_SIZE)
 790             ret = MIG_STAT_DST_GET_PAGE_FAILED;
 791         break;
 792     case 1: /* homogeneous page -- a single byte */
 793         l = qemu_get_buffer(f, (void*)&v, 4);
 794         if (l != 4)
 795             ret = MIG_STAT_DST_GET_PAGE_FAILED;
 796         migrate_incoming_homogeneous_page(addr, v);
 797         break;
 798     default:
 799         ret = MIG_STAT_DST_GET_PAGE_UNKNOWN_TYPE;
 800     }
 801
 802     return ret;
 803 }
 804
 805 static int migrate_incoming_fd(int fd)
 806 {
 807     int ret = 0;
 808     QEMUFile *f = qemu_fopen_fd(fd);
 809     uint32_t addr, size;
 810     extern void qemu_announce_self(void);
 811     unsigned char running;
 812
 813     running = qemu_get_byte(f);
 814     if ((running != 1) && (running != 2)) {
 815         fprintf(stderr, "migration: illegal running value %u, not (1 or 2)\n",
 816                 running);
 817         return MIG_STAT_DST_MEM_SIZE_MISMATCH;
 818     }
 819     autostart = running - 1;
 820
 821     size = qemu_get_be32(f);
 822     if (size != phys_ram_size) {
 823         fprintf(stderr, "migration: memory size mismatch: recv %u mine %u\n",
 824                 size, phys_ram_size);
 825         return MIG_STAT_DST_MEM_SIZE_MISMATCH;
 826     }
 827
 828 #ifdef USE_KVM
 829     if (kvm_allowed) {
 830         int n, m;
 831         unsigned char *phys_ram_page_exist_bitmap = NULL;
 832
 833         /* allocate memory bitmap */
 834         n = BITMAP_SIZE(phys_ram_size);
 835         m = qemu_get_be32(f);
 836         if (m > n) // allocate enough space
 837             n = m;
 838         phys_ram_page_exist_bitmap = qemu_malloc(n);
 839         if (!phys_ram_page_exist_bitmap) {
 840             perror("failed to allocate page bitmap");
 841             return MIG_STAT_NO_MEM;
 842         }
 843
 844         /* receive memory bitmap */
 845         qemu_get_buffer(f, phys_ram_page_exist_bitmap, m);
 846
 847         /* FIXME: free dellocated-at-src guest memory pages */
 848
 849         qemu_free(phys_ram_page_exist_bitmap);
 850     }
 851 #endif
 852
 853     do {
 854         addr = qemu_get_be32(f);
 855         if (addr == 1)
 856             break;
 857         if (addr >= phys_ram_size)
 858             return MIG_STAT_DST_MEM_OUT_OF_RANGE;
 859         ret = migrate_incoming_page(f, addr);
 860         if (ret)
 861             return ret;
 862     } while (1);
 863
 864
 865     qemu_aio_flush();
 866     vm_stop(0);
 867     if (qemu_live_loadvm_state(f))
 868         ret = MIG_STAT_DST_LOADVM_FAILED;
 869 #ifdef MIGRATION_VERIFY
 870     if (ret==0) ret=load_verify_memory(f, NULL, 1);
 871 #endif /* MIGRATION_VERIFY */
 872     qemu_fclose(f);
 873
 874     return ret;
 875 }
 876
 877 static int migrate_incoming_tcp(const char *host)
 878 {
 879     struct sockaddr_in addr;
 880     socklen_t addrlen = sizeof(addr);
 881     int fd, sfd;
 882     ssize_t len;
 883     uint8_t status = 0;
 884     int reuse = 1;
 885     int rc;
 886
 887     addr.sin_family = AF_INET;
 888     if (parse_host_port(&addr, host) == -1) {
 889         fprintf(stderr, "parse_host_port() failed for %s\n", host);
 890         rc = MIG_STAT_DST_INVALID_ADDR;
 891         goto error;
 892     }
 893
 894     fd = socket(PF_INET, SOCK_STREAM, 0);
 895     if (fd == -1) {
 896         perror("socket failed");
 897         rc = MIG_STAT_DST_SOCKET_FAILED;
 898         goto error;
 899     }
 900
 901     if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1) {
 902         perror("setsockopt() failed");
 903         rc = MIG_STAT_DST_SOCKOPT_FAILED;
 904         goto error_socket;
 905     }
 906
 907     if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
 908         perror("bind() failed");
 909         rc = MIG_STAT_DST_BIND_FAILED;
 910         goto error_socket;
 911     }
 912
 913     if (listen(fd, 1) == -1) {
 914         perror("listen() failed");
 915         rc = MIG_STAT_DST_LISTEN_FAILED;
 916         goto error_socket;
 917     }
 918
 919 again:
 920     sfd = accept(fd, (struct sockaddr *)&addr, &addrlen);
 921     if (sfd == -1) {
 922         if (errno == EINTR)
 923             goto again;
 924         perror("accept() failed");
 925         rc = MIG_STAT_DST_ACCEPT_FAILED;
 926         goto error_socket;
 927     }
 928
 929     rc = migrate_incoming_fd(sfd);
 930     if (rc != 0) {
 931         fprintf(stderr, "migrate_incoming_fd failed (rc=%d)\n", rc);
 932         goto error_accept;
 933     }
 934
 935 send_ack:
 936     len = write(sfd, &status, 1);
 937     if (len == -1 && errno == EAGAIN)
 938         goto send_ack;
 939     if (len != 1) {
 940         fprintf(stderr, "migration: send_ack: write error len=%zu (%s)\n",
 941                 len, strerror(errno));
 942         rc = MIG_STAT_DST_WRITE_FAILED;
 943         goto error_accept;
 944     }
 945
 946     rc = wait_for_message("WAIT FOR GO", sfd, wait_for_message_timeout);
 947     if (rc) {
 948         rc += 200;
 949         goto error_accept;
 950     }
 951
 952 wait_for_go:
 953     len = read(sfd, &status, 1);
 954     if (len == -1 && errno == EAGAIN)
 955         goto wait_for_go;
 956     if (len != 1) {
 957         rc = MIG_STAT_DST_READ_FAILED;
 958         fprintf(stderr, "migration: wait_for_go: read error len=%zu (%s)\n",
 959                 len, strerror(errno));
 960     }
 961
 962 error_accept:
 963     close(sfd);
 964 error_socket:
 965     close(fd);
 966 error:
 967     return rc;
 968 }
 969
 970 int migrate_incoming(const char *device)
 971 {
 972     const char *ptr;
 973     int ret = 0;
 974
 975     if (strcmp(device, "stdio") == 0)
 976         ret = migrate_incoming_fd(STDIN_FILENO);
 977     else if (strstart(device, "file://", &ptr)) {
 978         int fd = open(ptr, O_RDONLY);
 979         if (fd < 0) {
 980             ret = MIG_STAT_DST_INVALID_PARAMS;
 981         } else {
 982             ret = migrate_incoming_fd(fd);
 983             close(fd);
 984         }
 985     } else if (strstart(device, "tcp://", &ptr)) {
 986         char *host, *end;
 987         host = strdup(ptr);
 988         end = strchr(host, '/');
 989         if (end) *end = 0;
 990         ret = migrate_incoming_tcp(host);
 991         qemu_free(host);
 992     } else {
 993         errno = EINVAL;
 994         ret = MIG_STAT_DST_INVALID_PARAMS;
 995     }
 996
 997     return ret;
 998 }
 999
1000 /* Migration monitor command */
1001
1002 /* TODO:
1003    1) audit all error paths
1004 */
1005
1006 void do_migrate(int detach, const char *uri)
1007 {
1008     const char *ptr;
1009     MigrationState *s = current_migration;
1010
1011     if (s) {
1012         term_printf("Migration already active\n");
1013         return;
1014     }
1015
1016     status = MIG_STAT_INVALID_PARAMS;
1017     if (strstart(uri, "exec:", &ptr)) {
1018         char *command = urldecode(ptr);
1019         migration_init_exec(detach, command);
1020         free(command);
1021     } else if (strstart(uri, "ssh://", &ptr)) {
1022         char *host, *end;
1023
1024         host = strdup(ptr);
1025         end = strchr(host, '/');
1026         if (end) *end = 0;
1027         migration_init_ssh(detach, host);
1028         qemu_free(host);
1029     } else if (strstart(uri, "tcp://", &ptr)) {
1030         char *host, *end;
1031
1032         host = strdup(ptr);
1033         end = strchr(host, '/');
1034         if (end) *end = 0;
1035
1036         if (migration_init_tcp(detach, host) == NULL)
1037             term_printf("migration failed (migration_init_tcp for %s failed)\n", host);
1038         free(host);
1039     } else {
1040         term_printf("Unknown migration protocol '%s'\n", uri);
1041         return;
1042     }
1043 }
1044
1045 void do_migrate_set_speed(const char *value)
1046 {
1047     double d;
1048     char *ptr;
1049
1050     d = strtod(value, &ptr);
1051     switch (*ptr) {
1052     case 'G': case 'g':
1053         d *= 1024;
1054     case 'M': case 'm':
1055         d *= 1024;
1056     case 'K': case 'k':
1057         d *= 1024;
1058     default:
1059         break;
1060     }
1061
1062     max_throttle = (uint32_t)d;
1063 }
1064
1065 void do_info_migration(void)
1066 {
1067     MigrationState *s = current_migration;
1068
1069     if (s) {
1070         term_printf("Migration active\n");
1071         if (s->bps < (1 << 20))
1072             term_printf("Transfer rate %3.1f kb/s\n",
1073                         (double)s->bps / 1024);
1074         else
1075             term_printf("Transfer rate %3.1f mb/s\n",
1076                         (double)s->bps / (1024 * 1024));
1077         term_printf("Iteration %d\n", s->iteration);
1078         term_printf("Transferred %d/%d pages\n", s->updated_pages, phys_ram_size >> TARGET_PAGE_BITS);
1079         if (s->iteration)
1080             term_printf("Last iteration found %d dirty pages\n", s->last_updated_pages);
1081     } else {
1082         term_printf("Migration inactive\n");
1083         term_printf("last migration status is %d\n", status);
1084     }
1085     term_printf("Maximum migration speed is ");
1086     if (max_throttle < (1 << 20))
1087         term_printf("%3.1f kb/s\n", (double)max_throttle / 1024);
1088     else
1089         term_printf("%3.1f mb/s\n", (double)max_throttle / (1024 * 1024));
1090 }
1091
1092 void do_migrate_cancel(void)
1093 {
1094     MigrationState *s = current_migration;
1095
1096     if (s)
1097         *s->has_error = MIG_STAT_MIGRATION_CANCEL;
1098 }
1099
1100
1101
1102 #ifdef MIGRATION_VERIFY
1103 unsigned int calc_page_checksum(target_ulong addr)
1104 {
1105     unsigned int sum=0;
1106     unsigned int *p = (unsigned int *)(phys_ram_base + addr);
1107     unsigned int *q = p + (TARGET_PAGE_SIZE / sizeof(unsigned int));
1108
1109     for ( /*initialized already */ ; p<q ; p++)
1110         sum += *p;
1111     return sum;
1112 }
1113
1114
1115 static int save_verify_memory(QEMUFile *f, void *opaque)
1116 {
1117     unsigned int addr;
1118     unsigned int sum;
1119
1120     for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
1121 #ifdef USE_KVM
1122         if (kvm_allowed && (addr>=0xa0000) && (addr<0xc0000)) /* do not access video-addresses */
1123             continue;
1124 #endif
1125         sum = calc_page_checksum(addr);
1126         qemu_put_be32(f, addr);
1127         qemu_put_be32(f, sum);
1128     }
1129     return 0;
1130 }
1131
1132 static int load_verify_memory(QEMUFile *f, void *opaque, int version_id)
1133 {
1134     unsigned int addr, raddr;
1135     unsigned int sum, rsum;
1136     int num_errors = 0;
1137
1138     for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
1139 #ifdef USE_KVM
1140         if (kvm_allowed && (addr>=0xa0000) && (addr<0xc0000)) /* do not access video-addresses */
1141             continue;
1142 #endif
1143         sum = calc_page_checksum(addr);
1144         raddr = qemu_get_be32(f);
1145         rsum  = qemu_get_be32(f);
1146         if ((raddr != addr) || (rsum != sum)) {
1147             term_printf("checksum mismatch: src:0x%x 0x%x , dst:0x%x 0x%x\n",
1148                     raddr, rsum, addr, sum);
1149             num_errors++;
1150         }
1151     }
1152     printf("memory_verify: num_errors=%d\n", num_errors);
1153     term_printf("memory_verify: num_errors=%d\n", num_errors);
1154     return 0/* num_errors */;
1155 }
1156 #endif /* MIGRATION_VERIFY */