palacios/src/palacios/vmm_checkpoint.c

   1 /*
   2  * This file is part of the Palacios Virtual Machine Monitor developed
   3  * by the V3VEE Project with funding from the United States National
   4  * Science Foundation and the Department of Energy.
   5  *
   6  * The V3VEE Project is a joint project between Northwestern University
   7  * and the University of New Mexico.  You can find out more at
   8  * http://www.v3vee.org
   9  *
  10  * Copyright (c) 2011, Madhav Suresh <madhav@u.northwestern.edu>
  11  * Copyright (c) 2011, The V3VEE Project <http://www.v3vee.org>
  12  * All rights reserved.
  13  *
  14  * Author: Madhav Suresh <madhav@u.northwestern.edu>
  15  *         Arefin Huq <fig@arefin.net>
  16  *         Peter Dinda <pdinda@northwestern.edu> (store interface changes)
  17  *
  18  *
  19  * This is free software.  You are permitted to use,
  20  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
  21  */
  22
  23 #include <palacios/vmm.h>
  24 #include <palacios/vmm_sprintf.h>
  25 #include <palacios/vm_guest.h>
  26 #include <palacios/svm.h>
  27 #include <palacios/vmx.h>
  28 #include <palacios/vmm_checkpoint.h>
  29 #include <palacios/vmm_hashtable.h>
  30 #include <palacios/vmm_direct_paging.h>
  31 #include <palacios/vmm_debug.h>
  32
  33 #include <palacios/vmm_dev_mgr.h>
  34
  35 #ifdef V3_CONFIG_LIVE_MIGRATION
  36 #include <palacios/vmm_time.h>
  37 #include <palacios/vm_guest_mem.h>
  38 #include <palacios/vmm_shadow_paging.h>
  39 #endif
  40
  41 #ifndef V3_CONFIG_DEBUG_CHECKPOINT
  42 #undef PrintDebug
  43 #define PrintDebug(fmt, args...)
  44 #endif
  45
  46
  47 static struct hashtable * store_table = NULL;
  48
  49 struct v3_chkpt;
  50
  51 typedef enum {SAVE, LOAD} chkpt_mode_t;
  52
  53 struct chkpt_interface {
  54   char name[128];
  55   // Opening a checkpoint should return a pointer to the internal representation
  56   // of the checkpoint in the store.  This will be passed back
  57   // as "store_data".  Return NULL if the context cannot be opened
  58   void * (*open_chkpt)(char * url, chkpt_mode_t mode);
  59   // Closing the checkpoint should return -1 on failure, 0 on success
  60   int    (*close_chkpt)(void * store_data);
  61
  62   // Opening a context on the checkpoint with a given name should return
  63   // a pointer to an internal representation of the context.  This pointer
  64   // is then passed back as "ctx".
  65   // We will open only a single context at a time.
  66   void * (*open_ctx)(void * store_data, char *name);
  67   // Closing the context should return -1 on failure, 0 on success
  68   int    (*close_ctx)(void * store_data, void * ctx);
  69
  70   // Save and load include a tagged data buffer.  These are
  71   // "all or nothing" writes and reads.
  72   // return -1 on failure, and 0 on success
  73   //
  74   int (*save)(void * store_data, void * ctx, char * tag, uint64_t len, void * buf);
  75   int (*load)(void * store_data, void * ctx, char * tag, uint64_t len, void * buf);
  76 };
  77
  78
  79 struct v3_chkpt {
  80   struct v3_vm_info * vm;
  81
  82   struct v3_chkpt_ctx *current_ctx;
  83
  84   struct chkpt_interface * interface;
  85
  86   void * store_data;
  87 };
  88
  89
  90
  91
  92 static uint_t store_hash_fn(addr_t key) {
  93     char * name = (char *)key;
  94     return v3_hash_buffer((uint8_t *)name, strlen(name));
  95 }
  96
  97 static int store_eq_fn(addr_t key1, addr_t key2) {
  98     char * name1 = (char *)key1;
  99     char * name2 = (char *)key2;
 100
 101     return (strcmp(name1, name2) == 0);
 102 }
 103
 104
 105
 106 #include "vmm_chkpt_stores.h"
 107
 108
 109 int V3_init_checkpoint() {
 110     extern struct chkpt_interface * __start__v3_chkpt_stores[];
 111     extern struct chkpt_interface * __stop__v3_chkpt_stores[];
 112     struct chkpt_interface ** tmp_store = __start__v3_chkpt_stores;
 113     int i = 0;
 114
 115     store_table = v3_create_htable(0, store_hash_fn, store_eq_fn);
 116
 117     while (tmp_store != __stop__v3_chkpt_stores) {
 118         V3_Print("Registering Checkpoint Backing Store (%s)\n", (*tmp_store)->name);
 119
 120         if (v3_htable_search(store_table, (addr_t)((*tmp_store)->name))) {
 121             PrintError("Multiple instances of Checkpoint backing Store (%s)\n", (*tmp_store)->name);
 122             return -1;
 123         }
 124
 125         if (v3_htable_insert(store_table, (addr_t)((*tmp_store)->name), (addr_t)(*tmp_store)) == 0) {
 126             PrintError("Could not register Checkpoint backing store (%s)\n", (*tmp_store)->name);
 127             return -1;
 128         }
 129
 130         tmp_store = &(__start__v3_chkpt_stores[++i]);
 131     }
 132
 133     return 0;
 134 }
 135
 136 int V3_deinit_checkpoint() {
 137     v3_free_htable(store_table, 0, 0);
 138     return 0;
 139 }
 140
 141
 142 static char svm_chkpt_header[] = "v3vee palacios checkpoint version: x.x, SVM x.x";
 143 static char vmx_chkpt_header[] = "v3vee palacios checkpoint version: x.x, VMX x.x";
 144
 145 static int chkpt_close(struct v3_chkpt * chkpt) {
 146   if (chkpt) {
 147     int rc;
 148
 149     rc = chkpt->interface->close_chkpt(chkpt->store_data);
 150
 151     V3_Free(chkpt);
 152
 153     if (rc!=0) {
 154       PrintError("Internal store failed to close valid checkpoint\n");
 155       return -1;
 156     } else {
 157       return 0;
 158     }
 159   } else {
 160     PrintError("Attempt to close null checkpoint\n");
 161     return -1;
 162   }
 163 }
 164
 165
 166 static struct v3_chkpt * chkpt_open(struct v3_vm_info * vm, char * store, char * url, chkpt_mode_t mode) {
 167     struct chkpt_interface * iface = NULL;
 168     struct v3_chkpt * chkpt = NULL;
 169     void * store_data = NULL;
 170
 171     iface = (void *)v3_htable_search(store_table, (addr_t)store);
 172
 173     if (iface == NULL) {
 174         V3_Print("Error: Could not locate Checkpoint interface for store (%s)\n", store);
 175         return NULL;
 176     }
 177
 178     store_data = iface->open_chkpt(url, mode);
 179
 180     if (store_data == NULL) {
 181         PrintError("Could not open url (%s) for backing store (%s)\n", url, store);
 182         return NULL;
 183     }
 184
 185
 186     chkpt = V3_Malloc(sizeof(struct v3_chkpt));
 187
 188     if (!chkpt) {
 189         PrintError("Could not allocate checkpoint state, closing checkpoint\n");
 190         iface->close_chkpt(store_data);
 191         return NULL;
 192     }
 193
 194     memset(chkpt,0,sizeof(struct v3_chkpt));
 195
 196     chkpt->interface = iface;
 197     chkpt->vm = vm;
 198     chkpt->store_data = store_data;
 199     chkpt->current_ctx = NULL;
 200
 201     return chkpt;
 202 }
 203
 204 struct v3_chkpt_ctx * v3_chkpt_open_ctx(struct v3_chkpt * chkpt, char * name) {
 205   struct v3_chkpt_ctx * ctx;
 206
 207   if (chkpt->current_ctx) {
 208     PrintError("Attempt to open context %s before old context has been closed\n", name);
 209     return NULL;
 210   }
 211
 212   ctx = V3_Malloc(sizeof(struct v3_chkpt_ctx));
 213
 214   if (!ctx) {
 215     PrintError("Unable to allocate context\n");
 216     return 0;
 217   }
 218
 219   memset(ctx, 0, sizeof(struct v3_chkpt_ctx));
 220
 221   ctx->chkpt = chkpt;
 222   ctx->store_ctx = chkpt->interface->open_ctx(chkpt->store_data, name);
 223
 224   if (!(ctx->store_ctx)) {
 225     PrintError("Underlying store failed to open context %s\n",name);
 226     V3_Free(ctx);
 227     return NULL;
 228   }
 229
 230   chkpt->current_ctx = ctx;
 231
 232   return ctx;
 233 }
 234
 235 int v3_chkpt_close_ctx(struct v3_chkpt_ctx * ctx) {
 236     struct v3_chkpt * chkpt = ctx->chkpt;
 237     int ret = 0;
 238
 239     if (chkpt->current_ctx != ctx) {
 240       PrintError("Attempt to close a context that is not the current context on the store\n");
 241       return -1;
 242     }
 243
 244     ret = chkpt->interface->close_ctx(chkpt->store_data, ctx->store_ctx);
 245
 246     if (ret) {
 247       PrintError("Failed to close context on store, closing device-independent context anyway - bad\n");
 248       ret = -1;
 249     }
 250
 251     chkpt->current_ctx=NULL;
 252
 253     V3_Free(ctx);
 254
 255     return ret;
 256 }
 257
 258
 259
 260
 261
 262 int v3_chkpt_save(struct v3_chkpt_ctx * ctx, char * tag, uint64_t len, void * buf) {
 263     struct v3_chkpt * chkpt = ctx->chkpt;
 264     int rc;
 265
 266     if (!ctx) {
 267       PrintError("Attempt to save tag %s on null context\n",tag);
 268       return -1;
 269     }
 270
 271     if (chkpt->current_ctx != ctx) {
 272       PrintError("Attempt to save on context that is not the current context for the store\n");
 273       return -1;
 274     }
 275
 276     rc = chkpt->interface->save(chkpt->store_data, ctx->store_ctx, tag , len, buf);
 277
 278     if (rc) {
 279       PrintError("Underlying store failed to save tag %s on valid context\n",tag);
 280       return -1;
 281     } else {
 282       return 0;
 283     }
 284 }
 285
 286
 287 int v3_chkpt_load(struct v3_chkpt_ctx * ctx, char * tag, uint64_t len, void * buf) {
 288     struct v3_chkpt * chkpt = ctx->chkpt;
 289     int rc;
 290
 291     if (!ctx) {
 292       PrintError("Attempt to load tag %s from null context\n",tag);
 293       return -1;
 294     }
 295
 296     if (chkpt->current_ctx != ctx) {
 297       PrintError("Attempt to load from context that is not the current context for the store\n");
 298       return -1;
 299     }
 300
 301     rc = chkpt->interface->load(chkpt->store_data, ctx->store_ctx, tag, len, buf);
 302
 303     if (rc) {
 304       PrintError("Underlying store failed to load tag %s from valid context\n",tag);
 305       return -1;
 306     } else {
 307       return 0;
 308     }
 309 }
 310
 311
 312
 313 static int load_memory(struct v3_vm_info * vm, struct v3_chkpt * chkpt) {
 314
 315     void * guest_mem_base = NULL;
 316     void * ctx = NULL;
 317     uint64_t ret = 0;
 318
 319     guest_mem_base = V3_VAddr((void *)vm->mem_map.base_region.host_addr);
 320
 321     ctx = v3_chkpt_open_ctx(chkpt, "memory_img");
 322
 323     if (!ctx) {
 324         PrintError("Unable to open context for memory load\n");
 325         return -1;
 326     }
 327
 328     if (v3_chkpt_load(ctx, "memory_img", vm->mem_size, guest_mem_base)) {
 329         PrintError("Unable to load all of memory (requested=%llu bytes, result=%llu bytes\n",(uint64_t)(vm->mem_size),ret);
 330         v3_chkpt_close_ctx(ctx);
 331         return -1;
 332     }
 333
 334     v3_chkpt_close_ctx(ctx);
 335
 336     return 0;
 337 }
 338
 339
 340 static int save_memory(struct v3_vm_info * vm, struct v3_chkpt * chkpt) {
 341     void * guest_mem_base = NULL;
 342     void * ctx = NULL;
 343     uint64_t ret = 0;
 344
 345     guest_mem_base = V3_VAddr((void *)vm->mem_map.base_region.host_addr);
 346
 347     ctx = v3_chkpt_open_ctx(chkpt, "memory_img");
 348
 349     if (!ctx) {
 350         PrintError("Unable to open context to save memory\n");
 351         return -1;
 352     }
 353
 354     if (v3_chkpt_save(ctx, "memory_img", vm->mem_size, guest_mem_base)) {
 355         PrintError("Unable to save all of memory (requested=%llu, received=%llu)\n",(uint64_t)(vm->mem_size),ret);
 356         v3_chkpt_close_ctx(ctx);
 357         return -1;
 358     }
 359
 360     v3_chkpt_close_ctx(ctx);
 361
 362     return 0;
 363 }
 364
 365 #ifdef V3_CONFIG_LIVE_MIGRATION
 366
 367 struct mem_migration_state {
 368     struct v3_vm_info *vm;
 369     struct v3_bitmap  modified_pages;
 370 };
 371
 372 static int paging_callback(struct guest_info *core,
 373                            struct v3_shdw_pg_event *event,
 374                            void      *priv_data)
 375 {
 376     struct mem_migration_state *m = (struct mem_migration_state *)priv_data;
 377
 378     if (event->event_type==SHADOW_PAGEFAULT &&
 379         event->event_order==SHADOW_PREIMPL &&
 380         event->error_code.write) {
 381         addr_t gpa;
 382         if (!v3_gva_to_gpa(core,event->gva,&gpa)) {
 383             // write to this page
 384             v3_bitmap_set(&(m->modified_pages),gpa>>12);
 385         } else {
 386             // no worries, this isn't physical memory
 387         }
 388     } else {
 389         // we don't care about other events
 390     }
 391
 392     return 0;
 393 }
 394
 395
 396
 397 static struct mem_migration_state *start_page_tracking(struct v3_vm_info *vm)
 398 {
 399     struct mem_migration_state *m;
 400     int i;
 401
 402     m = (struct mem_migration_state *)V3_Malloc(sizeof(struct mem_migration_state));
 403
 404     if (!m) {
 405         PrintError("Cannot allocate\n");
 406         return NULL;
 407     }
 408
 409     m->vm=vm;
 410
 411     if (v3_bitmap_init(&(m->modified_pages),vm->mem_size >> 12) == -1) {
 412         PrintError("Failed to initialize modified_pages bit vector");
 413         V3_Free(m);
 414     }
 415
 416     v3_register_shadow_paging_event_callback(vm,paging_callback,m);
 417
 418     for (i=0;i<vm->num_cores;i++) {
 419         v3_invalidate_shadow_pts(&(vm->cores[i]));
 420     }
 421
 422     // and now we should get callbacks as writes happen
 423
 424     return m;
 425 }
 426
 427 static void stop_page_tracking(struct mem_migration_state *m)
 428 {
 429     v3_unregister_shadow_paging_event_callback(m->vm,paging_callback,m);
 430
 431     v3_bitmap_deinit(&(m->modified_pages));
 432
 433     V3_Free(m);
 434 }
 435
 436
 437
 438
 439
 440
 441 //
 442 // Returns
 443 //  negative: error
 444 //  zero: done with this round
 445 static int save_inc_memory(struct v3_vm_info * vm,
 446                            struct v3_bitmap * mod_pgs_to_send,
 447                            struct v3_chkpt * chkpt) {
 448     int page_size_bytes = 1 << 12; // assuming 4k pages right now
 449     void * ctx = NULL;
 450     int i = 0;
 451     void * guest_mem_base = NULL;
 452     int bitmap_num_bytes = (mod_pgs_to_send->num_bits / 8)
 453                            + ((mod_pgs_to_send->num_bits % 8) > 0);
 454
 455
 456     guest_mem_base = V3_VAddr((void *)vm->mem_map.base_region.host_addr);
 457
 458     PrintDebug("Saving incremental memory.\n");
 459
 460     ctx = v3_chkpt_open_ctx(chkpt,"memory_bitmap_bits");
 461
 462     if (!ctx) {
 463         PrintError("Cannot open context for dirty memory bitmap\n");
 464         return -1;
 465     }
 466
 467
 468     if (v3_chkpt_save(ctx,
 469                       "memory_bitmap_bits",
 470                       bitmap_num_bytes,
 471                       mod_pgs_to_send->bits)) {
 472         PrintError("Unable to write all of the dirty memory bitmap\n");
 473         v3_chkpt_close_ctx(ctx);
 474         return -1;
 475     }
 476
 477     v3_chkpt_close_ctx(ctx);
 478
 479     PrintDebug("Sent bitmap bits.\n");
 480
 481     // Dirty memory pages are sent in bitmap order
 482     for (i = 0; i < mod_pgs_to_send->num_bits; i++) {
 483         if (v3_bitmap_check(mod_pgs_to_send, i)) {
 484            // PrintDebug("Sending memory page %d.\n",i);
 485             ctx = v3_chkpt_open_ctx(chkpt, "memory_page");
 486             if (!ctx) {
 487                 PrintError("Unable to open context to send memory page\n");
 488                 return -1;
 489             }
 490             if (v3_chkpt_save(ctx,
 491                               "memory_page",
 492                               page_size_bytes,
 493                               guest_mem_base + (page_size_bytes * i))) {
 494                 PrintError("Unable to send a memory page\n");
 495                 v3_chkpt_close_ctx(ctx);
 496                 return -1;
 497             }
 498
 499             v3_chkpt_close_ctx(ctx);
 500         }
 501     }
 502
 503     return 0;
 504 }
 505
 506
 507 //
 508 // returns:
 509 //  negative: error
 510 //  zero: ok, but not done
 511 //  positive: ok, and also done
 512 static int load_inc_memory(struct v3_vm_info * vm,
 513                            struct v3_bitmap * mod_pgs,
 514                            struct v3_chkpt * chkpt) {
 515     int page_size_bytes = 1 << 12; // assuming 4k pages right now
 516     void * ctx = NULL;
 517     int i = 0;
 518     void * guest_mem_base = NULL;
 519     bool empty_bitmap = true;
 520     int bitmap_num_bytes = (mod_pgs->num_bits / 8)
 521                            + ((mod_pgs->num_bits % 8) > 0);
 522
 523
 524     guest_mem_base = V3_VAddr((void *)vm->mem_map.base_region.host_addr);
 525
 526     ctx = v3_chkpt_open_ctx(chkpt, "memory_bitmap_bits");
 527
 528     if (!ctx) {
 529         PrintError("Cannot open context to receive memory bitmap\n");
 530         return -1;
 531     }
 532
 533     if (v3_chkpt_load(ctx,
 534                       "memory_bitmap_bits",
 535                       bitmap_num_bytes,
 536                       mod_pgs->bits)) {
 537         PrintError("Did not receive all of memory bitmap\n");
 538         v3_chkpt_close_ctx(ctx);
 539         return -1;
 540     }
 541
 542     v3_chkpt_close_ctx(ctx);
 543
 544     // Receive also follows bitmap order
 545     for (i = 0; i < mod_pgs->num_bits; i ++) {
 546         if (v3_bitmap_check(mod_pgs, i)) {
 547             PrintDebug("Loading page %d\n", i);
 548             empty_bitmap = false;
 549             ctx = v3_chkpt_open_ctx(chkpt, "memory_page");
 550             if (!ctx) {
 551                 PrintError("Cannot open context to receive memory page\n");
 552                 return -1;
 553             }
 554
 555             if (v3_chkpt_load(ctx,
 556                               "memory_page",
 557                               page_size_bytes,
 558                               guest_mem_base + (page_size_bytes * i))) {
 559                 PrintError("Did not receive all of memory page\n");
 560                 v3_chkpt_close_ctx(ctx);
 561                 return -1;
 562             }
 563             v3_chkpt_close_ctx(ctx);
 564         }
 565     }
 566
 567     if (empty_bitmap) {
 568         // signal end of receiving pages
 569         PrintDebug("Finished receiving pages.\n");
 570         return 1;
 571     } else {
 572         // need to run again
 573         return 0;
 574     }
 575
 576 }
 577
 578 #endif
 579
 580 int save_header(struct v3_vm_info * vm, struct v3_chkpt * chkpt) {
 581     extern v3_cpu_arch_t v3_mach_type;
 582     void * ctx = NULL;
 583
 584     ctx = v3_chkpt_open_ctx(chkpt, "header");
 585     if (!ctx) {
 586         PrintError("Cannot open context to save header\n");
 587         return -1;
 588     }
 589
 590     switch (v3_mach_type) {
 591         case V3_SVM_CPU:
 592         case V3_SVM_REV3_CPU: {
 593             if (v3_chkpt_save(ctx, "header", strlen(svm_chkpt_header), svm_chkpt_header)) {
 594                 PrintError("Could not save all of SVM header\n");
 595                 v3_chkpt_close_ctx(ctx);
 596                 return -1;
 597             }
 598             break;
 599         }
 600         case V3_VMX_CPU:
 601         case V3_VMX_EPT_CPU:
 602         case V3_VMX_EPT_UG_CPU: {
 603             if (v3_chkpt_save(ctx, "header", strlen(vmx_chkpt_header), vmx_chkpt_header)) {
 604                 PrintError("Could not save all of VMX header\n");
 605                 v3_chkpt_close_ctx(ctx);
 606                 return -1;
 607             }
 608             break;
 609         }
 610         default:
 611             PrintError("checkpoint not supported on this architecture\n");
 612             v3_chkpt_close_ctx(ctx);
 613             return -1;
 614     }
 615
 616     v3_chkpt_close_ctx(ctx);
 617
 618     return 0;
 619 }
 620
 621 static int load_header(struct v3_vm_info * vm, struct v3_chkpt * chkpt) {
 622     extern v3_cpu_arch_t v3_mach_type;
 623     void * ctx = NULL;
 624
 625     ctx = v3_chkpt_open_ctx(chkpt, "header");
 626
 627     switch (v3_mach_type) {
 628         case V3_SVM_CPU:
 629         case V3_SVM_REV3_CPU: {
 630             char header[strlen(svm_chkpt_header) + 1];
 631
 632             if (v3_chkpt_load(ctx, "header", strlen(svm_chkpt_header), header)) {
 633                 PrintError("Could not load all of SVM header\n");
 634                 v3_chkpt_close_ctx(ctx);
 635                 return -1;
 636             }
 637
 638             header[strlen(svm_chkpt_header)] = 0;
 639
 640             break;
 641         }
 642         case V3_VMX_CPU:
 643         case V3_VMX_EPT_CPU:
 644         case V3_VMX_EPT_UG_CPU: {
 645             char header[strlen(vmx_chkpt_header) + 1];
 646
 647             if (v3_chkpt_load(ctx, "header", strlen(vmx_chkpt_header), header)) {
 648                 PrintError("Could not load all of VMX header\n");
 649                 v3_chkpt_close_ctx(ctx);
 650                 return -1;
 651             }
 652
 653             header[strlen(vmx_chkpt_header)] = 0;
 654
 655             break;
 656         }
 657         default:
 658             PrintError("checkpoint not supported on this architecture\n");
 659             v3_chkpt_close_ctx(ctx);
 660             return -1;
 661     }
 662
 663     v3_chkpt_close_ctx(ctx);
 664
 665     return 0;
 666 }
 667
 668
 669 static int load_core(struct guest_info * info, struct v3_chkpt * chkpt) {
 670     extern v3_cpu_arch_t v3_mach_type;
 671     void * ctx = NULL;
 672     char key_name[16];
 673     v3_reg_t tempreg;
 674
 675     PrintDebug("Loading core\n");
 676
 677     memset(key_name, 0, 16);
 678
 679     snprintf(key_name, 16, "guest_info%d", info->vcpu_id);
 680
 681     ctx = v3_chkpt_open_ctx(chkpt, key_name);
 682
 683     if (!ctx) {
 684         PrintError("Could not open context to load core\n");
 685         goto loadfailout;
 686     }
 687
 688     V3_CHKPT_LOAD(ctx, "RIP", info->rip, loadfailout);
 689
 690     // GPRs
 691     V3_CHKPT_LOAD(ctx,"RDI",info->vm_regs.rdi, loadfailout);
 692     V3_CHKPT_LOAD(ctx,"RSI",info->vm_regs.rsi, loadfailout);
 693     V3_CHKPT_LOAD(ctx,"RBP",info->vm_regs.rbp, loadfailout);
 694     V3_CHKPT_LOAD(ctx,"RSP",info->vm_regs.rsp, loadfailout);
 695     V3_CHKPT_LOAD(ctx,"RBX",info->vm_regs.rbx, loadfailout);
 696     V3_CHKPT_LOAD(ctx,"RDX",info->vm_regs.rdx, loadfailout);
 697     V3_CHKPT_LOAD(ctx,"RCX",info->vm_regs.rcx, loadfailout);
 698     V3_CHKPT_LOAD(ctx,"RAX",info->vm_regs.rax, loadfailout);
 699     V3_CHKPT_LOAD(ctx,"R8",info->vm_regs.r8, loadfailout);
 700     V3_CHKPT_LOAD(ctx,"R9",info->vm_regs.r9, loadfailout);
 701     V3_CHKPT_LOAD(ctx,"R10",info->vm_regs.r10, loadfailout);
 702     V3_CHKPT_LOAD(ctx,"R11",info->vm_regs.r11, loadfailout);
 703     V3_CHKPT_LOAD(ctx,"R12",info->vm_regs.r12, loadfailout);
 704     V3_CHKPT_LOAD(ctx,"R13",info->vm_regs.r13, loadfailout);
 705     V3_CHKPT_LOAD(ctx,"R14",info->vm_regs.r14, loadfailout);
 706     V3_CHKPT_LOAD(ctx,"R15",info->vm_regs.r15, loadfailout);
 707
 708     // Control registers
 709     V3_CHKPT_LOAD(ctx, "CR0", info->ctrl_regs.cr0, loadfailout);
 710     // there is no CR1
 711     V3_CHKPT_LOAD(ctx, "CR2", info->ctrl_regs.cr2, loadfailout);
 712     V3_CHKPT_LOAD(ctx, "CR3", info->ctrl_regs.cr3, loadfailout);
 713     V3_CHKPT_LOAD(ctx, "CR4", info->ctrl_regs.cr4, loadfailout);
 714     // There are no CR5,6,7
 715     // CR8 is derived from apic_tpr
 716     tempreg = (info->ctrl_regs.apic_tpr >> 4) & 0xf;
 717     V3_CHKPT_LOAD(ctx, "CR8", tempreg, loadfailout);
 718     V3_CHKPT_LOAD(ctx, "APIC_TPR", info->ctrl_regs.apic_tpr, loadfailout);
 719     V3_CHKPT_LOAD(ctx, "RFLAGS", info->ctrl_regs.rflags, loadfailout);
 720     V3_CHKPT_LOAD(ctx, "EFER", info->ctrl_regs.efer, loadfailout);
 721
 722     // Debug registers
 723     V3_CHKPT_LOAD(ctx, "DR0", info->dbg_regs.dr0, loadfailout);
 724     V3_CHKPT_LOAD(ctx, "DR1", info->dbg_regs.dr1, loadfailout);
 725     V3_CHKPT_LOAD(ctx, "DR2", info->dbg_regs.dr2, loadfailout);
 726     V3_CHKPT_LOAD(ctx, "DR3", info->dbg_regs.dr3, loadfailout);
 727     // there is no DR4 or DR5
 728     V3_CHKPT_LOAD(ctx, "DR6", info->dbg_regs.dr6, loadfailout);
 729     V3_CHKPT_LOAD(ctx, "DR7", info->dbg_regs.dr7, loadfailout);
 730
 731     // Segment registers
 732     V3_CHKPT_LOAD(ctx, "CS", info->segments.cs, loadfailout);
 733     V3_CHKPT_LOAD(ctx, "DS", info->segments.ds, loadfailout);
 734     V3_CHKPT_LOAD(ctx, "ES", info->segments.es, loadfailout);
 735     V3_CHKPT_LOAD(ctx, "FS", info->segments.fs, loadfailout);
 736     V3_CHKPT_LOAD(ctx, "GS", info->segments.gs, loadfailout);
 737     V3_CHKPT_LOAD(ctx, "SS", info->segments.ss, loadfailout);
 738     V3_CHKPT_LOAD(ctx, "LDTR", info->segments.ldtr, loadfailout);
 739     V3_CHKPT_LOAD(ctx, "GDTR", info->segments.gdtr, loadfailout);
 740     V3_CHKPT_LOAD(ctx, "IDTR", info->segments.idtr, loadfailout);
 741     V3_CHKPT_LOAD(ctx, "TR", info->segments.tr, loadfailout);
 742
 743     // several MSRs...
 744     V3_CHKPT_LOAD(ctx, "STAR", info->msrs.star, loadfailout);
 745     V3_CHKPT_LOAD(ctx, "LSTAR", info->msrs.lstar, loadfailout);
 746     V3_CHKPT_LOAD(ctx, "SFMASK", info->msrs.sfmask, loadfailout);
 747     V3_CHKPT_LOAD(ctx, "KERN_GS_BASE", info->msrs.kern_gs_base, loadfailout);
 748
 749     // Some components of guest state captured in the shadow pager
 750     V3_CHKPT_LOAD(ctx, "GUEST_CR3", info->shdw_pg_state.guest_cr3, loadfailout);
 751     V3_CHKPT_LOAD(ctx, "GUEST_CRO", info->shdw_pg_state.guest_cr0, loadfailout);
 752     V3_CHKPT_LOAD(ctx, "GUEST_EFER", info->shdw_pg_state.guest_efer, loadfailout);
 753
 754     v3_chkpt_close_ctx(ctx); ctx=0;
 755
 756     PrintDebug("Finished reading guest_info information\n");
 757
 758     info->cpu_mode = v3_get_vm_cpu_mode(info);
 759     info->mem_mode = v3_get_vm_mem_mode(info);
 760
 761     if (info->shdw_pg_mode == SHADOW_PAGING) {
 762         if (v3_get_vm_mem_mode(info) == VIRTUAL_MEM) {
 763             if (v3_activate_shadow_pt(info) == -1) {
 764                 PrintError("Failed to activate shadow page tables\n");
 765                 goto loadfailout;
 766             }
 767         } else {
 768             if (v3_activate_passthrough_pt(info) == -1) {
 769                 PrintError("Failed to activate passthrough page tables\n");
 770                 goto loadfailout;
 771             }
 772         }
 773     }
 774
 775
 776     switch (v3_mach_type) {
 777         case V3_SVM_CPU:
 778         case V3_SVM_REV3_CPU: {
 779             char key_name[16];
 780
 781             snprintf(key_name, 16, "vmcb_data%d", info->vcpu_id);
 782             ctx = v3_chkpt_open_ctx(chkpt, key_name);
 783
 784             if (!ctx) {
 785                 PrintError("Could not open context to load SVM core\n");
 786                 goto loadfailout;
 787             }
 788
 789             if (v3_svm_load_core(info, ctx) < 0 ) {
 790                 PrintError("Failed to patch core %d\n", info->vcpu_id);
 791                 goto loadfailout;
 792             }
 793
 794             v3_chkpt_close_ctx(ctx); ctx=0;
 795
 796             break;
 797         }
 798         case V3_VMX_CPU:
 799         case V3_VMX_EPT_CPU:
 800         case V3_VMX_EPT_UG_CPU: {
 801             char key_name[16];
 802
 803             snprintf(key_name, 16, "vmcs_data%d", info->vcpu_id);
 804
 805             ctx = v3_chkpt_open_ctx(chkpt, key_name);
 806
 807             if (!ctx) {
 808                 PrintError("Could not open context to load VMX core\n");
 809                 goto loadfailout;
 810             }
 811
 812             if (v3_vmx_load_core(info, ctx) < 0) {
 813                 PrintError("VMX checkpoint failed\n");
 814                 goto loadfailout;
 815             }
 816
 817             v3_chkpt_close_ctx(ctx); ctx=0;
 818
 819             break;
 820         }
 821         default:
 822             PrintError("Invalid CPU Type (%d)\n", v3_mach_type);
 823             goto loadfailout;
 824     }
 825
 826     PrintDebug("Load of core succeeded\n");
 827
 828     v3_print_guest_state(info);
 829
 830     return 0;
 831
 832  loadfailout:
 833     PrintError("Failed to load core\n");
 834     if (ctx) { v3_chkpt_close_ctx(ctx);}
 835     return -1;
 836
 837 }
 838
 839 // GEM5 - Hypercall for initiating transfer to gem5 (checkpoint)
 840
 841 static int save_core(struct guest_info * info, struct v3_chkpt * chkpt) {
 842     extern v3_cpu_arch_t v3_mach_type;
 843     void * ctx = NULL;
 844     char key_name[16];
 845     v3_reg_t tempreg;
 846
 847     PrintDebug("Saving core\n");
 848
 849     v3_print_guest_state(info);
 850
 851     memset(key_name, 0, 16);
 852
 853     snprintf(key_name, 16, "guest_info%d", info->vcpu_id);
 854
 855     ctx = v3_chkpt_open_ctx(chkpt, key_name);
 856
 857     if (!ctx) {
 858         PrintError("Unable to open context to save core\n");
 859         goto savefailout;
 860     }
 861
 862
 863     V3_CHKPT_SAVE(ctx, "RIP", info->rip, savefailout);
 864
 865     // GPRs
 866     V3_CHKPT_SAVE(ctx,"RDI",info->vm_regs.rdi, savefailout);
 867     V3_CHKPT_SAVE(ctx,"RSI",info->vm_regs.rsi, savefailout);
 868     V3_CHKPT_SAVE(ctx,"RBP",info->vm_regs.rbp, savefailout);
 869     V3_CHKPT_SAVE(ctx,"RSP",info->vm_regs.rsp, savefailout);
 870     V3_CHKPT_SAVE(ctx,"RBX",info->vm_regs.rbx, savefailout);
 871     V3_CHKPT_SAVE(ctx,"RDX",info->vm_regs.rdx, savefailout);
 872     V3_CHKPT_SAVE(ctx,"RCX",info->vm_regs.rcx, savefailout);
 873     V3_CHKPT_SAVE(ctx,"RAX",info->vm_regs.rax, savefailout);
 874     V3_CHKPT_SAVE(ctx,"R8",info->vm_regs.r8, savefailout);
 875     V3_CHKPT_SAVE(ctx,"R9",info->vm_regs.r9, savefailout);
 876     V3_CHKPT_SAVE(ctx,"R10",info->vm_regs.r10, savefailout);
 877     V3_CHKPT_SAVE(ctx,"R11",info->vm_regs.r11, savefailout);
 878     V3_CHKPT_SAVE(ctx,"R12",info->vm_regs.r12, savefailout);
 879     V3_CHKPT_SAVE(ctx,"R13",info->vm_regs.r13, savefailout);
 880     V3_CHKPT_SAVE(ctx,"R14",info->vm_regs.r14, savefailout);
 881     V3_CHKPT_SAVE(ctx,"R15",info->vm_regs.r15, savefailout);
 882
 883     // Control registers
 884     V3_CHKPT_SAVE(ctx, "CR0", info->ctrl_regs.cr0, savefailout);
 885     // there is no CR1
 886     V3_CHKPT_SAVE(ctx, "CR2", info->ctrl_regs.cr2, savefailout);
 887     V3_CHKPT_SAVE(ctx, "CR3", info->ctrl_regs.cr3, savefailout);
 888     V3_CHKPT_SAVE(ctx, "CR4", info->ctrl_regs.cr4, savefailout);
 889     // There are no CR5,6,7
 890     // CR8 is derived from apic_tpr
 891     tempreg = (info->ctrl_regs.apic_tpr >> 4) & 0xf;
 892     V3_CHKPT_SAVE(ctx, "CR8", tempreg, savefailout);
 893     V3_CHKPT_SAVE(ctx, "APIC_TPR", info->ctrl_regs.apic_tpr, savefailout);
 894     V3_CHKPT_SAVE(ctx, "RFLAGS", info->ctrl_regs.rflags, savefailout);
 895     V3_CHKPT_SAVE(ctx, "EFER", info->ctrl_regs.efer, savefailout);
 896
 897     // Debug registers
 898     V3_CHKPT_SAVE(ctx, "DR0", info->dbg_regs.dr0, savefailout);
 899     V3_CHKPT_SAVE(ctx, "DR1", info->dbg_regs.dr1, savefailout);
 900     V3_CHKPT_SAVE(ctx, "DR2", info->dbg_regs.dr2, savefailout);
 901     V3_CHKPT_SAVE(ctx, "DR3", info->dbg_regs.dr3, savefailout);
 902     // there is no DR4 or DR5
 903     V3_CHKPT_SAVE(ctx, "DR6", info->dbg_regs.dr6, savefailout);
 904     V3_CHKPT_SAVE(ctx, "DR7", info->dbg_regs.dr7, savefailout);
 905
 906     // Segment registers
 907     V3_CHKPT_SAVE(ctx, "CS", info->segments.cs, savefailout);
 908     V3_CHKPT_SAVE(ctx, "DS", info->segments.ds, savefailout);
 909     V3_CHKPT_SAVE(ctx, "ES", info->segments.es, savefailout);
 910     V3_CHKPT_SAVE(ctx, "FS", info->segments.fs, savefailout);
 911     V3_CHKPT_SAVE(ctx, "GS", info->segments.gs, savefailout);
 912     V3_CHKPT_SAVE(ctx, "SS", info->segments.ss, savefailout);
 913     V3_CHKPT_SAVE(ctx, "LDTR", info->segments.ldtr, savefailout);
 914     V3_CHKPT_SAVE(ctx, "GDTR", info->segments.gdtr, savefailout);
 915     V3_CHKPT_SAVE(ctx, "IDTR", info->segments.idtr, savefailout);
 916     V3_CHKPT_SAVE(ctx, "TR", info->segments.tr, savefailout);
 917
 918     // several MSRs...
 919     V3_CHKPT_SAVE(ctx, "STAR", info->msrs.star, savefailout);
 920     V3_CHKPT_SAVE(ctx, "LSTAR", info->msrs.lstar, savefailout);
 921     V3_CHKPT_SAVE(ctx, "SFMASK", info->msrs.sfmask, savefailout);
 922     V3_CHKPT_SAVE(ctx, "KERN_GS_BASE", info->msrs.kern_gs_base, savefailout);
 923
 924     // Some components of guest state captured in the shadow pager
 925     V3_CHKPT_SAVE(ctx, "GUEST_CR3", info->shdw_pg_state.guest_cr3, savefailout);
 926     V3_CHKPT_SAVE(ctx, "GUEST_CRO", info->shdw_pg_state.guest_cr0, savefailout);
 927     V3_CHKPT_SAVE(ctx, "GUEST_EFER", info->shdw_pg_state.guest_efer, savefailout);
 928
 929     v3_chkpt_close_ctx(ctx); ctx=0;
 930
 931     //Architechture specific code
 932     switch (v3_mach_type) {
 933         case V3_SVM_CPU:
 934         case V3_SVM_REV3_CPU: {
 935             char key_name[16];
 936
 937             snprintf(key_name, 16, "vmcb_data%d", info->vcpu_id);
 938
 939             ctx = v3_chkpt_open_ctx(chkpt, key_name);
 940
 941             if (!ctx) {
 942                 PrintError("Could not open context to store SVM core\n");
 943                 goto savefailout;
 944             }
 945
 946             if (v3_svm_save_core(info, ctx) < 0) {
 947                 PrintError("VMCB Unable to be written\n");
 948                 goto savefailout;
 949             }
 950
 951             v3_chkpt_close_ctx(ctx); ctx=0;;
 952             break;
 953         }
 954         case V3_VMX_CPU:
 955         case V3_VMX_EPT_CPU:
 956         case V3_VMX_EPT_UG_CPU: {
 957             char key_name[16];
 958
 959             snprintf(key_name, 16, "vmcs_data%d", info->vcpu_id);
 960
 961             ctx = v3_chkpt_open_ctx(chkpt, key_name);
 962
 963             if (!ctx) {
 964                 PrintError("Could not open context to store VMX core\n");
 965                 goto savefailout;
 966             }
 967
 968             if (v3_vmx_save_core(info, ctx) == -1) {
 969                 PrintError("VMX checkpoint failed\n");
 970                 goto savefailout;
 971             }
 972
 973             v3_chkpt_close_ctx(ctx); ctx=0;
 974
 975             break;
 976         }
 977         default:
 978             PrintError("Invalid CPU Type (%d)\n", v3_mach_type);
 979             goto savefailout;
 980
 981     }
 982
 983     return 0;
 984
 985  savefailout:
 986     PrintError("Failed to save core\n");
 987     if (ctx) { v3_chkpt_close_ctx(ctx); }
 988     return -1;
 989
 990 }
 991
 992 //
 993 // GEM5 - Madhav has debug code here for printing instrucions
 994 //
 995
 996 int v3_chkpt_save_vm(struct v3_vm_info * vm, char * store, char * url) {
 997     struct v3_chkpt * chkpt = NULL;
 998     int ret = 0;;
 999     int i = 0;
1000
1001
1002     chkpt = chkpt_open(vm, store, url, SAVE);
1003
1004     if (chkpt == NULL) {
1005         PrintError("Error creating checkpoint store for url %s\n",url);
1006         return -1;
1007     }
1008
1009     /* If this guest is running we need to block it while the checkpoint occurs */
1010     if (vm->run_state == VM_RUNNING) {
1011         while (v3_raise_barrier(vm, NULL) == -1);
1012     }
1013
1014     if ((ret = save_memory(vm, chkpt)) == -1) {
1015         PrintError("Unable to save memory\n");
1016         goto out;
1017     }
1018
1019
1020     if ((ret = v3_save_vm_devices(vm, chkpt)) == -1) {
1021         PrintError("Unable to save devices\n");
1022         goto out;
1023     }
1024
1025
1026     if ((ret = save_header(vm, chkpt)) == -1) {
1027         PrintError("Unable to save header\n");
1028         goto out;
1029     }
1030
1031     for (i = 0; i < vm->num_cores; i++){
1032         if ((ret = save_core(&(vm->cores[i]), chkpt)) == -1) {
1033             PrintError("chkpt of core %d failed\n", i);
1034             goto out;
1035         }
1036     }
1037
1038  out:
1039
1040     /* Resume the guest if it was running */
1041     if (vm->run_state == VM_RUNNING) {
1042         v3_lower_barrier(vm);
1043     }
1044
1045     chkpt_close(chkpt);
1046
1047     return ret;
1048
1049 }
1050
1051 int v3_chkpt_load_vm(struct v3_vm_info * vm, char * store, char * url) {
1052     struct v3_chkpt * chkpt = NULL;
1053     int i = 0;
1054     int ret = 0;
1055
1056     chkpt = chkpt_open(vm, store, url, LOAD);
1057
1058     if (chkpt == NULL) {
1059         PrintError("Error creating checkpoint store\n");
1060         return -1;
1061     }
1062
1063     /* If this guest is running we need to block it while the checkpoint occurs */
1064     if (vm->run_state == VM_RUNNING) {
1065         while (v3_raise_barrier(vm, NULL) == -1);
1066     }
1067
1068     if ((ret = load_memory(vm, chkpt)) == -1) {
1069         PrintError("Unable to load memory\n");
1070         goto out;
1071     }
1072
1073
1074     if ((ret = v3_load_vm_devices(vm, chkpt)) == -1) {
1075         PrintError("Unable to load devies\n");
1076         goto out;
1077     }
1078
1079
1080     if ((ret = load_header(vm, chkpt)) == -1) {
1081         PrintError("Unable to load header\n");
1082         goto out;
1083     }
1084
1085     //per core cloning
1086     for (i = 0; i < vm->num_cores; i++) {
1087         if ((ret = load_core(&(vm->cores[i]), chkpt)) == -1) {
1088             PrintError("Error loading core state (core=%d)\n", i);
1089             goto out;
1090         }
1091     }
1092
1093  out:
1094
1095     /* Resume the guest if it was running and we didn't just trash the state*/
1096     if (vm->run_state == VM_RUNNING) {
1097
1098         if (ret == -1) {
1099             vm->run_state = VM_STOPPED;
1100         }
1101
1102         /* We check the run state of the VM after every barrier
1103            So this will immediately halt the VM
1104         */
1105         v3_lower_barrier(vm);
1106     }
1107
1108     chkpt_close(chkpt);
1109
1110     return ret;
1111
1112 }
1113
1114
1115 #ifdef V3_CONFIG_LIVE_MIGRATION
1116
1117 #define MOD_THRESHOLD   200  // pages below which we declare victory
1118 #define ITER_THRESHOLD  32   // iters below which we declare victory
1119
1120
1121
1122 int v3_chkpt_send_vm(struct v3_vm_info * vm, char * store, char * url) {
1123     struct v3_chkpt * chkpt = NULL;
1124     int ret = 0;;
1125     int iter = 0;
1126     bool last_modpage_iteration=false;
1127     struct v3_bitmap modified_pages_to_send;
1128     uint64_t start_time;
1129     uint64_t stop_time;
1130     int num_mod_pages=0;
1131     struct mem_migration_state *mm_state;
1132     int i;
1133
1134     // Currently will work only for shadow paging
1135     for (i=0;i<vm->num_cores;i++) {
1136         if (vm->cores[i].shdw_pg_mode!=SHADOW_PAGING) {
1137             PrintError("Cannot currently handle nested paging\n");
1138             return -1;
1139         }
1140     }
1141
1142
1143     chkpt = chkpt_open(vm, store, url, SAVE);
1144
1145     if (chkpt == NULL) {
1146         PrintError("Error creating checkpoint store\n");
1147         chkpt_close(chkpt);
1148         return -1;
1149     }
1150
1151     // In a send, the memory is copied incrementally first,
1152     // followed by the remainder of the state
1153
1154     if (v3_bitmap_init(&modified_pages_to_send,
1155                        vm->mem_size>>12 // number of pages in main region
1156                        ) == -1) {
1157         PrintError("Could not intialize bitmap.\n");
1158         return -1;
1159     }
1160
1161     // 0. Initialize bitmap to all 1s
1162     for (i=0; i < modified_pages_to_send.num_bits; i++) {
1163         v3_bitmap_set(&modified_pages_to_send,i);
1164     }
1165
1166     iter = 0;
1167     while (!last_modpage_iteration) {
1168         PrintDebug("Modified memory page iteration %d\n",i++);
1169
1170         start_time = v3_get_host_time(&(vm->cores[0].time_state));
1171
1172         // We will pause the VM for a short while
1173         // so that we can collect the set of changed pages
1174         if (v3_pause_vm(vm) == -1) {
1175             PrintError("Could not pause VM\n");
1176             ret = -1;
1177             goto out;
1178         }
1179
1180         if (iter==0) {
1181             // special case, we already have the pages to send (all of them)
1182             // they are already in modified_pages_to_send
1183         } else {
1184             // normally, we are in the middle of a round
1185             // We need to copy from the current tracking bitmap
1186             // to our send bitmap
1187             v3_bitmap_copy(&modified_pages_to_send,&(mm_state->modified_pages));
1188             // and now we need to remove our tracking
1189             stop_page_tracking(mm_state);
1190         }
1191
1192         // are we done? (note that we are still paused)
1193         num_mod_pages = v3_bitmap_count(&modified_pages_to_send);
1194         if (num_mod_pages<MOD_THRESHOLD || iter>ITER_THRESHOLD) {
1195             // we are done, so we will not restart page tracking
1196             // the vm is paused, and so we should be able
1197             // to just send the data
1198             PrintDebug("Last modified memory page iteration.\n");
1199             last_modpage_iteration = true;
1200         } else {
1201             // we are not done, so we will restart page tracking
1202             // to prepare for a second round of pages
1203             // we will resume the VM as this happens
1204             if (!(mm_state=start_page_tracking(vm))) {
1205                 PrintError("Error enabling page tracking.\n");
1206                 ret = -1;
1207                 goto out;
1208             }
1209             if (v3_continue_vm(vm) == -1) {
1210                 PrintError("Error resuming the VM\n");
1211                 stop_page_tracking(mm_state);
1212                 ret = -1;
1213                 goto out;
1214             }
1215
1216             stop_time = v3_get_host_time(&(vm->cores[0].time_state));
1217             PrintDebug("num_mod_pages=%d\ndowntime=%llu\n",num_mod_pages,stop_time-start_time);
1218         }
1219
1220
1221         // At this point, we are either paused and about to copy
1222         // the last chunk, or we are running, and will copy the last
1223         // round in parallel with current execution
1224         if (num_mod_pages>0) {
1225             if (save_inc_memory(vm, &modified_pages_to_send, chkpt) == -1) {
1226                 PrintError("Error sending incremental memory.\n");
1227                 ret = -1;
1228                 goto out;
1229             }
1230         } // we don't want to copy an empty bitmap here
1231
1232         iter++;
1233     }
1234
1235     if (v3_bitmap_reset(&modified_pages_to_send) == -1) {
1236         PrintError("Error reseting bitmap.\n");
1237         ret = -1;
1238         goto out;
1239     }
1240
1241     // send bitmap of 0s to signal end of modpages
1242     if (save_inc_memory(vm, &modified_pages_to_send, chkpt) == -1) {
1243         PrintError("Error sending incremental memory.\n");
1244         ret = -1;
1245         goto out;
1246     }
1247
1248     // save the non-memory state
1249     if ((ret = v3_save_vm_devices(vm, chkpt)) == -1) {
1250         PrintError("Unable to save devices\n");
1251         goto out;
1252     }
1253
1254
1255     if ((ret = save_header(vm, chkpt)) == -1) {
1256         PrintError("Unable to save header\n");
1257         goto out;
1258     }
1259
1260     for (i = 0; i < vm->num_cores; i++){
1261         if ((ret = save_core(&(vm->cores[i]), chkpt)) == -1) {
1262             PrintError("chkpt of core %d failed\n", i);
1263             goto out;
1264         }
1265     }
1266
1267     stop_time = v3_get_host_time(&(vm->cores[0].time_state));
1268     PrintDebug("num_mod_pages=%d\ndowntime=%llu\n",num_mod_pages,stop_time-start_time);
1269     PrintDebug("Done sending VM!\n");
1270  out:
1271     v3_bitmap_deinit(&modified_pages_to_send);
1272     chkpt_close(chkpt);
1273
1274     return ret;
1275
1276 }
1277
1278 int v3_chkpt_receive_vm(struct v3_vm_info * vm, char * store, char * url) {
1279     struct v3_chkpt * chkpt = NULL;
1280     int i = 0;
1281     int ret = 0;
1282     struct v3_bitmap mod_pgs;
1283
1284     // Currently will work only for shadow paging
1285     for (i=0;i<vm->num_cores;i++) {
1286         if (vm->cores[i].shdw_pg_mode!=SHADOW_PAGING) {
1287             PrintError("Cannot currently handle nested paging\n");
1288             return -1;
1289         }
1290     }
1291
1292     chkpt = chkpt_open(vm, store, url, LOAD);
1293
1294     if (chkpt == NULL) {
1295         PrintError("Error creating checkpoint store\n");
1296         chkpt_close(chkpt);
1297         return -1;
1298     }
1299
1300     if (v3_bitmap_init(&mod_pgs,vm->mem_size>>12) == -1) {
1301         chkpt_close(chkpt);
1302         PrintError("Could not intialize bitmap.\n");
1303         return -1;
1304     }
1305
1306     /* If this guest is running we need to block it while the checkpoint occurs */
1307     if (vm->run_state == VM_RUNNING) {
1308         while (v3_raise_barrier(vm, NULL) == -1);
1309     }
1310
1311     i = 0;
1312     while(true) {
1313         // 1. Receive copy of bitmap
1314         // 2. Receive pages
1315         PrintDebug("Memory page iteration %d\n",i++);
1316         int retval = load_inc_memory(vm, &mod_pgs, chkpt);
1317         if (retval == 1) {
1318             // end of receiving memory pages
1319             break;
1320         } else if (retval == -1) {
1321             PrintError("Error receiving incremental memory.\n");
1322             ret = -1;
1323             goto out;
1324         }
1325     }
1326
1327     if ((ret = v3_load_vm_devices(vm, chkpt)) == -1) {
1328         PrintError("Unable to load devices\n");
1329         ret = -1;
1330         goto out;
1331     }
1332
1333
1334     if ((ret = load_header(vm, chkpt)) == -1) {
1335         PrintError("Unable to load header\n");
1336         ret = -1;
1337         goto out;
1338     }
1339
1340     //per core cloning
1341     for (i = 0; i < vm->num_cores; i++) {
1342         if ((ret = load_core(&(vm->cores[i]), chkpt)) == -1) {
1343             PrintError("Error loading core state (core=%d)\n", i);
1344             goto out;
1345         }
1346     }
1347
1348  out:
1349     if (ret==-1) {
1350         PrintError("Unable to receive VM\n");
1351     } else {
1352         PrintDebug("Done receving the VM\n");
1353     }
1354
1355
1356     /* Resume the guest if it was running and we didn't just trash the state*/
1357     if (vm->run_state == VM_RUNNING) {
1358         if (ret == -1) {
1359             PrintError("VM was previously running.  It is now borked.  Pausing it. \n");
1360             vm->run_state = VM_STOPPED;
1361         }
1362
1363         /* We check the run state of the VM after every barrier
1364            So this will immediately halt the VM
1365         */
1366         v3_lower_barrier(vm);
1367     }
1368
1369     v3_bitmap_deinit(&mod_pgs);
1370     chkpt_close(chkpt);
1371
1372     return ret;
1373 }
1374
1375 #endif