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