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