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