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