usr.sbin/bhyve/snapshot.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2016 Flavius Anton
   5  * Copyright (c) 2016 Mihai Tiganus
   6  * Copyright (c) 2016-2019 Mihai Carabas
   7  * Copyright (c) 2017-2019 Darius Mihai
   8  * Copyright (c) 2017-2019 Elena Mihailescu
   9  * Copyright (c) 2018-2019 Sergiu Weisz
  10  * All rights reserved.
  11  * The bhyve-snapshot feature was developed under sponsorships
  12  * from Matthew Grooms.
  13  *
  14  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions
  16  * are met:
  17  * 1. Redistributions of source code must retain the above copyright
  18  *    notice, this list of conditions and the following disclaimer.
  19  * 2. Redistributions in binary form must reproduce the above copyright
  20  *    notice, this list of conditions and the following disclaimer in the
  21  *    documentation and/or other materials provided with the distribution.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY NETAPP, INC ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL NETAPP, INC OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD$");
  38
  39 #include <sys/types.h>
  40 #ifndef WITHOUT_CAPSICUM
  41 #include <sys/capsicum.h>
  42 #endif
  43 #include <sys/mman.h>
  44 #include <sys/socket.h>
  45 #include <sys/stat.h>
  46 #include <sys/time.h>
  47 #include <sys/un.h>
  48
  49 #include <machine/atomic.h>
  50 #include <machine/segments.h>
  51
  52 #ifndef WITHOUT_CAPSICUM
  53 #include <capsicum_helpers.h>
  54 #endif
  55 #include <stdio.h>
  56 #include <stdlib.h>
  57 #include <string.h>
  58 #include <err.h>
  59 #include <errno.h>
  60 #include <fcntl.h>
  61 #include <libgen.h>
  62 #include <signal.h>
  63 #include <unistd.h>
  64 #include <assert.h>
  65 #include <errno.h>
  66 #include <pthread.h>
  67 #include <pthread_np.h>
  68 #include <sysexits.h>
  69 #include <stdbool.h>
  70 #include <sys/ioctl.h>
  71
  72 #include <machine/vmm.h>
  73 #ifndef WITHOUT_CAPSICUM
  74 #include <machine/vmm_dev.h>
  75 #endif
  76 #include <machine/vmm_snapshot.h>
  77 #include <vmmapi.h>
  78
  79 #include "bhyverun.h"
  80 #include "acpi.h"
  81 #include "atkbdc.h"
  82 #include "inout.h"
  83 #include "fwctl.h"
  84 #include "ioapic.h"
  85 #include "mem.h"
  86 #include "mevent.h"
  87 #include "mptbl.h"
  88 #include "pci_emul.h"
  89 #include "pci_irq.h"
  90 #include "pci_lpc.h"
  91 #include "smbiostbl.h"
  92 #include "snapshot.h"
  93 #include "xmsr.h"
  94 #include "spinup_ap.h"
  95 #include "rtc.h"
  96
  97 #include <libxo/xo.h>
  98 #include <ucl.h>
  99
 100 struct spinner_info {
 101         const size_t *crtval;
 102         const size_t maxval;
 103         const size_t total;
 104 };
 105
 106 extern int guest_ncpus;
 107
 108 static struct winsize winsize;
 109 static sig_t old_winch_handler;
 110
 111 #define KB              (1024UL)
 112 #define MB              (1024UL * KB)
 113 #define GB              (1024UL * MB)
 114
 115 #define SNAPSHOT_CHUNK  (4 * MB)
 116 #define PROG_BUF_SZ     (8192)
 117
 118 #define MAX_VMNAME 100
 119
 120 #define MAX_MSG_SIZE 1024
 121
 122 #define SNAPSHOT_BUFFER_SIZE (20 * MB)
 123
 124 #define JSON_STRUCT_ARR_KEY             "structs"
 125 #define JSON_DEV_ARR_KEY                "devices"
 126 #define JSON_BASIC_METADATA_KEY         "basic metadata"
 127 #define JSON_SNAPSHOT_REQ_KEY           "snapshot_req"
 128 #define JSON_SIZE_KEY                   "size"
 129 #define JSON_FILE_OFFSET_KEY            "file_offset"
 130
 131 #define JSON_NCPUS_KEY                  "ncpus"
 132 #define JSON_VMNAME_KEY                 "vmname"
 133 #define JSON_MEMSIZE_KEY                "memsize"
 134 #define JSON_MEMFLAGS_KEY               "memflags"
 135
 136 #define min(a,b)                \
 137 ({                              \
 138  __typeof__ (a) _a = (a);       \
 139  __typeof__ (b) _b = (b);       \
 140  _a < _b ? _a : _b;             \
 141  })
 142
 143 const struct vm_snapshot_dev_info snapshot_devs[] = {
 144         { "atkbdc",     atkbdc_snapshot,        NULL,           NULL            },
 145         { "virtio-net", pci_snapshot,           pci_pause,      pci_resume      },
 146         { "virtio-blk", pci_snapshot,           pci_pause,      pci_resume      },
 147         { "virtio-rnd", pci_snapshot,           NULL,           NULL            },
 148         { "lpc",        pci_snapshot,           NULL,           NULL            },
 149         { "fbuf",       pci_snapshot,           NULL,           NULL            },
 150         { "xhci",       pci_snapshot,           NULL,           NULL            },
 151         { "e1000",      pci_snapshot,           NULL,           NULL            },
 152         { "ahci",       pci_snapshot,           pci_pause,      pci_resume      },
 153         { "ahci-hd",    pci_snapshot,           pci_pause,      pci_resume      },
 154         { "ahci-cd",    pci_snapshot,           pci_pause,      pci_resume      },
 155 };
 156
 157 const struct vm_snapshot_kern_info snapshot_kern_structs[] = {
 158         { "vhpet",      STRUCT_VHPET    },
 159         { "vm",         STRUCT_VM       },
 160         { "vmx",        STRUCT_VMX      },
 161         { "vioapic",    STRUCT_VIOAPIC  },
 162         { "vlapic",     STRUCT_VLAPIC   },
 163         { "vmcx",       STRUCT_VMCX     },
 164         { "vatpit",     STRUCT_VATPIT   },
 165         { "vatpic",     STRUCT_VATPIC   },
 166         { "vpmtmr",     STRUCT_VPMTMR   },
 167         { "vrtc",       STRUCT_VRTC     },
 168 };
 169
 170 static cpuset_t vcpus_active, vcpus_suspended;
 171 static pthread_mutex_t vcpu_lock;
 172 static pthread_cond_t vcpus_idle, vcpus_can_run;
 173 static bool checkpoint_active;
 174
 175 /*
 176  * TODO: Harden this function and all of its callers since 'base_str' is a user
 177  * provided string.
 178  */
 179 static char *
 180 strcat_extension(const char *base_str, const char *ext)
 181 {
 182         char *res;
 183         size_t base_len, ext_len;
 184
 185         base_len = strnlen(base_str, MAX_VMNAME);
 186         ext_len = strnlen(ext, MAX_VMNAME);
 187
 188         if (base_len + ext_len > MAX_VMNAME) {
 189                 fprintf(stderr, "Filename exceeds maximum length.\n");
 190                 return (NULL);
 191         }
 192
 193         res = malloc(base_len + ext_len + 1);
 194         if (res == NULL) {
 195                 perror("Failed to allocate memory.");
 196                 return (NULL);
 197         }
 198
 199         memcpy(res, base_str, base_len);
 200         memcpy(res + base_len, ext, ext_len);
 201         res[base_len + ext_len] = 0;
 202
 203         return (res);
 204 }
 205
 206 void
 207 destroy_restore_state(struct restore_state *rstate)
 208 {
 209         if (rstate == NULL) {
 210                 fprintf(stderr, "Attempting to destroy NULL restore struct.\n");
 211                 return;
 212         }
 213
 214         if (rstate->kdata_map != MAP_FAILED)
 215                 munmap(rstate->kdata_map, rstate->kdata_len);
 216
 217         if (rstate->kdata_fd > 0)
 218                 close(rstate->kdata_fd);
 219         if (rstate->vmmem_fd > 0)
 220                 close(rstate->vmmem_fd);
 221
 222         if (rstate->meta_root_obj != NULL)
 223                 ucl_object_unref(rstate->meta_root_obj);
 224         if (rstate->meta_parser != NULL)
 225                 ucl_parser_free(rstate->meta_parser);
 226 }
 227
 228 static int
 229 load_vmmem_file(const char *filename, struct restore_state *rstate)
 230 {
 231         struct stat sb;
 232         int err;
 233
 234         rstate->vmmem_fd = open(filename, O_RDONLY);
 235         if (rstate->vmmem_fd < 0) {
 236                 perror("Failed to open restore file");
 237                 return (-1);
 238         }
 239
 240         err = fstat(rstate->vmmem_fd, &sb);
 241         if (err < 0) {
 242                 perror("Failed to stat restore file");
 243                 goto err_load_vmmem;
 244         }
 245
 246         if (sb.st_size == 0) {
 247                 fprintf(stderr, "Restore file is empty.\n");
 248                 goto err_load_vmmem;
 249         }
 250
 251         rstate->vmmem_len = sb.st_size;
 252
 253         return (0);
 254
 255 err_load_vmmem:
 256         if (rstate->vmmem_fd > 0)
 257                 close(rstate->vmmem_fd);
 258         return (-1);
 259 }
 260
 261 static int
 262 load_kdata_file(const char *filename, struct restore_state *rstate)
 263 {
 264         struct stat sb;
 265         int err;
 266
 267         rstate->kdata_fd = open(filename, O_RDONLY);
 268         if (rstate->kdata_fd < 0) {
 269                 perror("Failed to open kernel data file");
 270                 return (-1);
 271         }
 272
 273         err = fstat(rstate->kdata_fd, &sb);
 274         if (err < 0) {
 275                 perror("Failed to stat kernel data file");
 276                 goto err_load_kdata;
 277         }
 278
 279         if (sb.st_size == 0) {
 280                 fprintf(stderr, "Kernel data file is empty.\n");
 281                 goto err_load_kdata;
 282         }
 283
 284         rstate->kdata_len = sb.st_size;
 285         rstate->kdata_map = mmap(NULL, rstate->kdata_len, PROT_READ,
 286                                  MAP_SHARED, rstate->kdata_fd, 0);
 287         if (rstate->kdata_map == MAP_FAILED) {
 288                 perror("Failed to map restore file");
 289                 goto err_load_kdata;
 290         }
 291
 292         return (0);
 293
 294 err_load_kdata:
 295         if (rstate->kdata_fd > 0)
 296                 close(rstate->kdata_fd);
 297         return (-1);
 298 }
 299
 300 static int
 301 load_metadata_file(const char *filename, struct restore_state *rstate)
 302 {
 303         const ucl_object_t *obj;
 304         struct ucl_parser *parser;
 305         int err;
 306
 307         parser = ucl_parser_new(UCL_PARSER_DEFAULT);
 308         if (parser == NULL) {
 309                 fprintf(stderr, "Failed to initialize UCL parser.\n");
 310                 goto err_load_metadata;
 311         }
 312
 313         err = ucl_parser_add_file(parser, filename);
 314         if (err == 0) {
 315                 fprintf(stderr, "Failed to parse metadata file: '%s'\n",
 316                         filename);
 317                 err = -1;
 318                 goto err_load_metadata;
 319         }
 320
 321         obj = ucl_parser_get_object(parser);
 322         if (obj == NULL) {
 323                 fprintf(stderr, "Failed to parse object.\n");
 324                 err = -1;
 325                 goto err_load_metadata;
 326         }
 327
 328         rstate->meta_parser = parser;
 329         rstate->meta_root_obj = (ucl_object_t *)obj;
 330
 331         return (0);
 332
 333 err_load_metadata:
 334         if (parser != NULL)
 335                 ucl_parser_free(parser);
 336         return (err);
 337 }
 338
 339 int
 340 load_restore_file(const char *filename, struct restore_state *rstate)
 341 {
 342         int err = 0;
 343         char *kdata_filename = NULL, *meta_filename = NULL;
 344
 345         assert(filename != NULL);
 346         assert(rstate != NULL);
 347
 348         memset(rstate, 0, sizeof(*rstate));
 349         rstate->kdata_map = MAP_FAILED;
 350
 351         err = load_vmmem_file(filename, rstate);
 352         if (err != 0) {
 353                 fprintf(stderr, "Failed to load guest RAM file.\n");
 354                 goto err_restore;
 355         }
 356
 357         kdata_filename = strcat_extension(filename, ".kern");
 358         if (kdata_filename == NULL) {
 359                 fprintf(stderr, "Failed to construct kernel data filename.\n");
 360                 goto err_restore;
 361         }
 362
 363         err = load_kdata_file(kdata_filename, rstate);
 364         if (err != 0) {
 365                 fprintf(stderr, "Failed to load guest kernel data file.\n");
 366                 goto err_restore;
 367         }
 368
 369         meta_filename = strcat_extension(filename, ".meta");
 370         if (meta_filename == NULL) {
 371                 fprintf(stderr, "Failed to construct kernel metadata filename.\n");
 372                 goto err_restore;
 373         }
 374
 375         err = load_metadata_file(meta_filename, rstate);
 376         if (err != 0) {
 377                 fprintf(stderr, "Failed to load guest metadata file.\n");
 378                 goto err_restore;
 379         }
 380
 381         return (0);
 382
 383 err_restore:
 384         destroy_restore_state(rstate);
 385         if (kdata_filename != NULL)
 386                 free(kdata_filename);
 387         if (meta_filename != NULL)
 388                 free(meta_filename);
 389         return (-1);
 390 }
 391
 392 #define JSON_GET_INT_OR_RETURN(key, obj, result_ptr, ret)                       \
 393 do {                                                                            \
 394         const ucl_object_t *obj__;                                              \
 395         obj__ = ucl_object_lookup(obj, key);                                    \
 396         if (obj__ == NULL) {                                                    \
 397                 fprintf(stderr, "Missing key: '%s'", key);                      \
 398                 return (ret);                                                   \
 399         }                                                                       \
 400         if (!ucl_object_toint_safe(obj__, result_ptr)) {                        \
 401                 fprintf(stderr, "Cannot convert '%s' value to int.", key);      \
 402                 return (ret);                                                   \
 403         }                                                                       \
 404 } while(0)
 405
 406 #define JSON_GET_STRING_OR_RETURN(key, obj, result_ptr, ret)                    \
 407 do {                                                                            \
 408         const ucl_object_t *obj__;                                              \
 409         obj__ = ucl_object_lookup(obj, key);                                    \
 410         if (obj__ == NULL) {                                                    \
 411                 fprintf(stderr, "Missing key: '%s'", key);                      \
 412                 return (ret);                                                   \
 413         }                                                                       \
 414         if (!ucl_object_tostring_safe(obj__, result_ptr)) {                     \
 415                 fprintf(stderr, "Cannot convert '%s' value to string.", key);   \
 416                 return (ret);                                                   \
 417         }                                                                       \
 418 } while(0)
 419
 420 static void *
 421 lookup_struct(enum snapshot_req struct_id, struct restore_state *rstate,
 422               size_t *struct_size)
 423 {
 424         const ucl_object_t *structs = NULL, *obj = NULL;
 425         ucl_object_iter_t it = NULL;
 426         int64_t snapshot_req, size, file_offset;
 427
 428         structs = ucl_object_lookup(rstate->meta_root_obj, JSON_STRUCT_ARR_KEY);
 429         if (structs == NULL) {
 430                 fprintf(stderr, "Failed to find '%s' object.\n",
 431                         JSON_STRUCT_ARR_KEY);
 432                 return (NULL);
 433         }
 434
 435         if (ucl_object_type((ucl_object_t *)structs) != UCL_ARRAY) {
 436                 fprintf(stderr, "Object '%s' is not an array.\n",
 437                 JSON_STRUCT_ARR_KEY);
 438                 return (NULL);
 439         }
 440
 441         while ((obj = ucl_object_iterate(structs, &it, true)) != NULL) {
 442                 snapshot_req = -1;
 443                 JSON_GET_INT_OR_RETURN(JSON_SNAPSHOT_REQ_KEY, obj,
 444                                        &snapshot_req, NULL);
 445                 assert(snapshot_req >= 0);
 446                 if ((enum snapshot_req) snapshot_req == struct_id) {
 447                         JSON_GET_INT_OR_RETURN(JSON_SIZE_KEY, obj,
 448                                                &size, NULL);
 449                         assert(size >= 0);
 450
 451                         JSON_GET_INT_OR_RETURN(JSON_FILE_OFFSET_KEY, obj,
 452                                                &file_offset, NULL);
 453                         assert(file_offset >= 0);
 454                         assert(file_offset + size <= rstate->kdata_len);
 455
 456                         *struct_size = (size_t)size;
 457                         return (rstate->kdata_map + file_offset);
 458                 }
 459         }
 460
 461         return (NULL);
 462 }
 463
 464 static void *
 465 lookup_check_dev(const char *dev_name, struct restore_state *rstate,
 466                  const ucl_object_t *obj, size_t *data_size)
 467 {
 468         const char *snapshot_req;
 469         int64_t size, file_offset;
 470
 471         snapshot_req = NULL;
 472         JSON_GET_STRING_OR_RETURN(JSON_SNAPSHOT_REQ_KEY, obj,
 473                                   &snapshot_req, NULL);
 474         assert(snapshot_req != NULL);
 475         if (!strcmp(snapshot_req, dev_name)) {
 476                 JSON_GET_INT_OR_RETURN(JSON_SIZE_KEY, obj,
 477                                        &size, NULL);
 478                 assert(size >= 0);
 479
 480                 JSON_GET_INT_OR_RETURN(JSON_FILE_OFFSET_KEY, obj,
 481                                        &file_offset, NULL);
 482                 assert(file_offset >= 0);
 483                 assert(file_offset + size <= rstate->kdata_len);
 484
 485                 *data_size = (size_t)size;
 486                 return (rstate->kdata_map + file_offset);
 487         }
 488
 489         return (NULL);
 490 }
 491
 492 static void*
 493 lookup_dev(const char *dev_name, struct restore_state *rstate,
 494            size_t *data_size)
 495 {
 496         const ucl_object_t *devs = NULL, *obj = NULL;
 497         ucl_object_iter_t it = NULL;
 498         void *ret;
 499
 500         devs = ucl_object_lookup(rstate->meta_root_obj, JSON_DEV_ARR_KEY);
 501         if (devs == NULL) {
 502                 fprintf(stderr, "Failed to find '%s' object.\n",
 503                         JSON_DEV_ARR_KEY);
 504                 return (NULL);
 505         }
 506
 507         if (ucl_object_type((ucl_object_t *)devs) != UCL_ARRAY) {
 508                 fprintf(stderr, "Object '%s' is not an array.\n",
 509                         JSON_DEV_ARR_KEY);
 510                 return (NULL);
 511         }
 512
 513         while ((obj = ucl_object_iterate(devs, &it, true)) != NULL) {
 514                 ret = lookup_check_dev(dev_name, rstate, obj, data_size);
 515                 if (ret != NULL)
 516                         return (ret);
 517         }
 518
 519         return (NULL);
 520 }
 521
 522 static const ucl_object_t *
 523 lookup_basic_metadata_object(struct restore_state *rstate)
 524 {
 525         const ucl_object_t *basic_meta_obj = NULL;
 526
 527         basic_meta_obj = ucl_object_lookup(rstate->meta_root_obj,
 528                                            JSON_BASIC_METADATA_KEY);
 529         if (basic_meta_obj == NULL) {
 530                 fprintf(stderr, "Failed to find '%s' object.\n",
 531                         JSON_BASIC_METADATA_KEY);
 532                 return (NULL);
 533         }
 534
 535         if (ucl_object_type((ucl_object_t *)basic_meta_obj) != UCL_OBJECT) {
 536                 fprintf(stderr, "Object '%s' is not a JSON object.\n",
 537                 JSON_BASIC_METADATA_KEY);
 538                 return (NULL);
 539         }
 540
 541         return (basic_meta_obj);
 542 }
 543
 544 const char *
 545 lookup_vmname(struct restore_state *rstate)
 546 {
 547         const char *vmname;
 548         const ucl_object_t *obj;
 549
 550         obj = lookup_basic_metadata_object(rstate);
 551         if (obj == NULL)
 552                 return (NULL);
 553
 554         JSON_GET_STRING_OR_RETURN(JSON_VMNAME_KEY, obj, &vmname, NULL);
 555         return (vmname);
 556 }
 557
 558 int
 559 lookup_memflags(struct restore_state *rstate)
 560 {
 561         int64_t memflags;
 562         const ucl_object_t *obj;
 563
 564         obj = lookup_basic_metadata_object(rstate);
 565         if (obj == NULL)
 566                 return (0);
 567
 568         JSON_GET_INT_OR_RETURN(JSON_MEMFLAGS_KEY, obj, &memflags, 0);
 569
 570         return ((int)memflags);
 571 }
 572
 573 size_t
 574 lookup_memsize(struct restore_state *rstate)
 575 {
 576         int64_t memsize;
 577         const ucl_object_t *obj;
 578
 579         obj = lookup_basic_metadata_object(rstate);
 580         if (obj == NULL)
 581                 return (0);
 582
 583         JSON_GET_INT_OR_RETURN(JSON_MEMSIZE_KEY, obj, &memsize, 0);
 584         if (memsize < 0)
 585                 memsize = 0;
 586
 587         return ((size_t)memsize);
 588 }
 589
 590
 591 int
 592 lookup_guest_ncpus(struct restore_state *rstate)
 593 {
 594         int64_t ncpus;
 595         const ucl_object_t *obj;
 596
 597         obj = lookup_basic_metadata_object(rstate);
 598         if (obj == NULL)
 599                 return (0);
 600
 601         JSON_GET_INT_OR_RETURN(JSON_NCPUS_KEY, obj, &ncpus, 0);
 602         return ((int)ncpus);
 603 }
 604
 605 static void
 606 winch_handler(int signal)
 607 {
 608 #ifdef TIOCGWINSZ
 609         ioctl(STDOUT_FILENO, TIOCGWINSZ, &winsize);
 610 #endif /* TIOCGWINSZ */
 611 }
 612
 613 static int
 614 print_progress(size_t crtval, const size_t maxval)
 615 {
 616         size_t rc;
 617         double crtval_gb, maxval_gb;
 618         size_t i, win_width, prog_start, prog_done, prog_end;
 619         int mval_len;
 620
 621         static char prog_buf[PROG_BUF_SZ];
 622         static const size_t len = sizeof(prog_buf);
 623
 624         static size_t div;
 625         static char *div_str;
 626
 627         static char wip_bar[] = { '/', '-', '\\', '|' };
 628         static int wip_idx = 0;
 629
 630         if (maxval == 0) {
 631                 printf("[0B / 0B]\r\n");
 632                 return (0);
 633         }
 634
 635         if (crtval > maxval)
 636                 crtval = maxval;
 637
 638         if (maxval > 10 * GB) {
 639                 div = GB;
 640                 div_str = "GiB";
 641         } else if (maxval > 10 * MB) {
 642                 div = MB;
 643                 div_str = "MiB";
 644         } else {
 645                 div = KB;
 646                 div_str = "KiB";
 647         }
 648
 649         crtval_gb = (double) crtval / div;
 650         maxval_gb = (double) maxval / div;
 651
 652         rc = snprintf(prog_buf, len, "%.03lf", maxval_gb);
 653         if (rc == len) {
 654                 fprintf(stderr, "Maxval too big\n");
 655                 return (-1);
 656         }
 657         mval_len = rc;
 658
 659         rc = snprintf(prog_buf, len, "\r[%*.03lf%s / %.03lf%s] |",
 660                 mval_len, crtval_gb, div_str, maxval_gb, div_str);
 661
 662         if (rc == len) {
 663                 fprintf(stderr, "Buffer too small to print progress\n");
 664                 return (-1);
 665         }
 666
 667         win_width = min(winsize.ws_col, len);
 668         prog_start = rc;
 669
 670         if (prog_start < (win_width - 2)) {
 671                 prog_end = win_width - prog_start - 2;
 672                 prog_done = prog_end * (crtval_gb / maxval_gb);
 673
 674                 for (i = prog_start; i < prog_start + prog_done; i++)
 675                         prog_buf[i] = '#';
 676
 677                 if (crtval != maxval) {
 678                         prog_buf[i] = wip_bar[wip_idx];
 679                         wip_idx = (wip_idx + 1) % sizeof(wip_bar);
 680                         i++;
 681                 } else {
 682                         prog_buf[i++] = '#';
 683                 }
 684
 685                 for (; i < win_width - 2; i++)
 686                         prog_buf[i] = '_';
 687
 688                 prog_buf[win_width - 2] = '|';
 689         }
 690
 691         prog_buf[win_width - 1] = '\0';
 692         write(STDOUT_FILENO, prog_buf, win_width);
 693
 694         return (0);
 695 }
 696
 697 static void *
 698 snapshot_spinner_cb(void *arg)
 699 {
 700         int rc;
 701         size_t crtval, maxval, total;
 702         struct spinner_info *si;
 703         struct timespec ts;
 704
 705         si = arg;
 706         if (si == NULL)
 707                 pthread_exit(NULL);
 708
 709         ts.tv_sec = 0;
 710         ts.tv_nsec = 50 * 1000 * 1000; /* 50 ms sleep time */
 711
 712         do {
 713                 crtval = *si->crtval;
 714                 maxval = si->maxval;
 715                 total = si->total;
 716
 717                 rc = print_progress(crtval, total);
 718                 if (rc < 0) {
 719                         fprintf(stderr, "Failed to parse progress\n");
 720                         break;
 721                 }
 722
 723                 nanosleep(&ts, NULL);
 724         } while (crtval < maxval);
 725
 726         pthread_exit(NULL);
 727         return NULL;
 728 }
 729
 730 static int
 731 vm_snapshot_mem_part(const int snapfd, const size_t foff, void *src,
 732                      const size_t len, const size_t totalmem, const bool op_wr)
 733 {
 734         int rc;
 735         size_t part_done, todo, rem;
 736         ssize_t done;
 737         bool show_progress;
 738         pthread_t spinner_th;
 739         struct spinner_info *si;
 740
 741         if (lseek(snapfd, foff, SEEK_SET) < 0) {
 742                 perror("Failed to change file offset");
 743                 return (-1);
 744         }
 745
 746         show_progress = false;
 747         if (isatty(STDIN_FILENO) && (winsize.ws_col != 0))
 748                 show_progress = true;
 749
 750         part_done = foff;
 751         rem = len;
 752
 753         if (show_progress) {
 754                 si = &(struct spinner_info) {
 755                         .crtval = &part_done,
 756                         .maxval = foff + len,
 757                         .total = totalmem
 758                 };
 759
 760                 rc = pthread_create(&spinner_th, 0, snapshot_spinner_cb, si);
 761                 if (rc) {
 762                         perror("Unable to create spinner thread");
 763                         show_progress = false;
 764                 }
 765         }
 766
 767         while (rem > 0) {
 768                 if (show_progress)
 769                         todo = min(SNAPSHOT_CHUNK, rem);
 770                 else
 771                         todo = rem;
 772
 773                 if (op_wr)
 774                         done = write(snapfd, src, todo);
 775                 else
 776                         done = read(snapfd, src, todo);
 777                 if (done < 0) {
 778                         perror("Failed to write in file");
 779                         return (-1);
 780                 }
 781
 782                 src += done;
 783                 part_done += done;
 784                 rem -= done;
 785         }
 786
 787         if (show_progress) {
 788                 rc = pthread_join(spinner_th, NULL);
 789                 if (rc)
 790                         perror("Unable to end spinner thread");
 791         }
 792
 793         return (0);
 794 }
 795
 796 static size_t
 797 vm_snapshot_mem(struct vmctx *ctx, int snapfd, size_t memsz, const bool op_wr)
 798 {
 799         int ret;
 800         size_t lowmem, highmem, totalmem;
 801         char *baseaddr;
 802
 803         ret = vm_get_guestmem_from_ctx(ctx, &baseaddr, &lowmem, &highmem);
 804         if (ret) {
 805                 fprintf(stderr, "%s: unable to retrieve guest memory size\r\n",
 806                         __func__);
 807                 return (0);
 808         }
 809         totalmem = lowmem + highmem;
 810
 811         if ((op_wr == false) && (totalmem != memsz)) {
 812                 fprintf(stderr, "%s: mem size mismatch: %ld vs %ld\r\n",
 813                         __func__, totalmem, memsz);
 814                 return (0);
 815         }
 816
 817         winsize.ws_col = 80;
 818 #ifdef TIOCGWINSZ
 819         ioctl(STDOUT_FILENO, TIOCGWINSZ, &winsize);
 820 #endif /* TIOCGWINSZ */
 821         old_winch_handler = signal(SIGWINCH, winch_handler);
 822
 823         ret = vm_snapshot_mem_part(snapfd, 0, baseaddr, lowmem,
 824                 totalmem, op_wr);
 825         if (ret) {
 826                 fprintf(stderr, "%s: Could not %s lowmem\r\n",
 827                         __func__, op_wr ? "write" : "read");
 828                 totalmem = 0;
 829                 goto done;
 830         }
 831
 832         if (highmem == 0)
 833                 goto done;
 834
 835         ret = vm_snapshot_mem_part(snapfd, lowmem, baseaddr + 4*GB,
 836                 highmem, totalmem, op_wr);
 837         if (ret) {
 838                 fprintf(stderr, "%s: Could not %s highmem\r\n",
 839                         __func__, op_wr ? "write" : "read");
 840                 totalmem = 0;
 841                 goto done;
 842         }
 843
 844 done:
 845         printf("\r\n");
 846         signal(SIGWINCH, old_winch_handler);
 847
 848         return (totalmem);
 849 }
 850
 851 int
 852 restore_vm_mem(struct vmctx *ctx, struct restore_state *rstate)
 853 {
 854         size_t restored;
 855
 856         restored = vm_snapshot_mem(ctx, rstate->vmmem_fd, rstate->vmmem_len,
 857                                    false);
 858
 859         if (restored != rstate->vmmem_len)
 860                 return (-1);
 861
 862         return (0);
 863 }
 864
 865 static int
 866 vm_restore_kern_struct(struct vmctx *ctx, struct restore_state *rstate,
 867                        const struct vm_snapshot_kern_info *info)
 868 {
 869         void *struct_ptr;
 870         size_t struct_size;
 871         int ret;
 872         struct vm_snapshot_meta *meta;
 873
 874         struct_ptr = lookup_struct(info->req, rstate, &struct_size);
 875         if (struct_ptr == NULL) {
 876                 fprintf(stderr, "%s: Failed to lookup struct %s\r\n",
 877                         __func__, info->struct_name);
 878                 ret = -1;
 879                 goto done;
 880         }
 881
 882         if (struct_size == 0) {
 883                 fprintf(stderr, "%s: Kernel struct size was 0 for: %s\r\n",
 884                         __func__, info->struct_name);
 885                 ret = -1;
 886                 goto done;
 887         }
 888
 889         meta = &(struct vm_snapshot_meta) {
 890                 .ctx = ctx,
 891                 .dev_name = info->struct_name,
 892                 .dev_req  = info->req,
 893
 894                 .buffer.buf_start = struct_ptr,
 895                 .buffer.buf_size = struct_size,
 896
 897                 .buffer.buf = struct_ptr,
 898                 .buffer.buf_rem = struct_size,
 899
 900                 .op = VM_SNAPSHOT_RESTORE,
 901         };
 902
 903         ret = vm_snapshot_req(meta);
 904         if (ret != 0) {
 905                 fprintf(stderr, "%s: Failed to restore struct: %s\r\n",
 906                         __func__, info->struct_name);
 907                 goto done;
 908         }
 909
 910 done:
 911         return (ret);
 912 }
 913
 914 int
 915 vm_restore_kern_structs(struct vmctx *ctx, struct restore_state *rstate)
 916 {
 917         int ret;
 918         int i;
 919
 920         for (i = 0; i < nitems(snapshot_kern_structs); i++) {
 921                 ret = vm_restore_kern_struct(ctx, rstate,
 922                                              &snapshot_kern_structs[i]);
 923                 if (ret != 0)
 924                         return (ret);
 925         }
 926
 927         return (0);
 928 }
 929
 930 int
 931 vm_restore_user_dev(struct vmctx *ctx, struct restore_state *rstate,
 932                     const struct vm_snapshot_dev_info *info)
 933 {
 934         void *dev_ptr;
 935         size_t dev_size;
 936         int ret;
 937         struct vm_snapshot_meta *meta;
 938
 939         dev_ptr = lookup_dev(info->dev_name, rstate, &dev_size);
 940         if (dev_ptr == NULL) {
 941                 fprintf(stderr, "Failed to lookup dev: %s\r\n", info->dev_name);
 942                 fprintf(stderr, "Continuing the restore/migration process\r\n");
 943                 return (0);
 944         }
 945
 946         if (dev_size == 0) {
 947                 fprintf(stderr, "%s: Device size is 0. "
 948                         "Assuming %s is not used\r\n",
 949                         __func__, info->dev_name);
 950                 return (0);
 951         }
 952
 953         meta = &(struct vm_snapshot_meta) {
 954                 .ctx = ctx,
 955                 .dev_name = info->dev_name,
 956
 957                 .buffer.buf_start = dev_ptr,
 958                 .buffer.buf_size = dev_size,
 959
 960                 .buffer.buf = dev_ptr,
 961                 .buffer.buf_rem = dev_size,
 962
 963                 .op = VM_SNAPSHOT_RESTORE,
 964         };
 965
 966         ret = (*info->snapshot_cb)(meta);
 967         if (ret != 0) {
 968                 fprintf(stderr, "Failed to restore dev: %s\r\n",
 969                         info->dev_name);
 970                 return (-1);
 971         }
 972
 973         return (0);
 974 }
 975
 976
 977 int
 978 vm_restore_user_devs(struct vmctx *ctx, struct restore_state *rstate)
 979 {
 980         int ret;
 981         int i;
 982
 983         for (i = 0; i < nitems(snapshot_devs); i++) {
 984                 ret = vm_restore_user_dev(ctx, rstate, &snapshot_devs[i]);
 985                 if (ret != 0)
 986                         return (ret);
 987         }
 988
 989         return 0;
 990 }
 991
 992 int
 993 vm_pause_user_devs(struct vmctx *ctx)
 994 {
 995         const struct vm_snapshot_dev_info *info;
 996         int ret;
 997         int i;
 998
 999         for (i = 0; i < nitems(snapshot_devs); i++) {
1000                 info = &snapshot_devs[i];
1001                 if (info->pause_cb == NULL)
1002                         continue;
1003
1004                 ret = info->pause_cb(ctx, info->dev_name);
1005                 if (ret != 0)
1006                         return (ret);
1007         }
1008
1009         return (0);
1010 }
1011
1012 int
1013 vm_resume_user_devs(struct vmctx *ctx)
1014 {
1015         const struct vm_snapshot_dev_info *info;
1016         int ret;
1017         int i;
1018
1019         for (i = 0; i < nitems(snapshot_devs); i++) {
1020                 info = &snapshot_devs[i];
1021                 if (info->resume_cb == NULL)
1022                         continue;
1023
1024                 ret = info->resume_cb(ctx, info->dev_name);
1025                 if (ret != 0)
1026                         return (ret);
1027         }
1028
1029         return (0);
1030 }
1031
1032 static int
1033 vm_snapshot_kern_struct(int data_fd, xo_handle_t *xop, const char *array_key,
1034                         struct vm_snapshot_meta *meta, off_t *offset)
1035 {
1036         int ret;
1037         size_t data_size;
1038         ssize_t write_cnt;
1039
1040         ret = vm_snapshot_req(meta);
1041         if (ret != 0) {
1042                 fprintf(stderr, "%s: Failed to snapshot struct %s\r\n",
1043                         __func__, meta->dev_name);
1044                 ret = -1;
1045                 goto done;
1046         }
1047
1048         data_size = vm_get_snapshot_size(meta);
1049
1050         write_cnt = write(data_fd, meta->buffer.buf_start, data_size);
1051         if (write_cnt != data_size) {
1052                 perror("Failed to write all snapshotted data.");
1053                 ret = -1;
1054                 goto done;
1055         }
1056
1057         /* Write metadata. */
1058         xo_open_instance_h(xop, array_key);
1059         xo_emit_h(xop, "{:debug_name/%s}\n", meta->dev_name);
1060         xo_emit_h(xop, "{:" JSON_SNAPSHOT_REQ_KEY "/%d}\n",
1061                   meta->dev_req);
1062         xo_emit_h(xop, "{:" JSON_SIZE_KEY "/%lu}\n", data_size);
1063         xo_emit_h(xop, "{:" JSON_FILE_OFFSET_KEY "/%lu}\n", *offset);
1064         xo_close_instance_h(xop, JSON_STRUCT_ARR_KEY);
1065
1066         *offset += data_size;
1067
1068 done:
1069         return (ret);
1070 }
1071
1072 static int
1073 vm_snapshot_kern_structs(struct vmctx *ctx, int data_fd, xo_handle_t *xop)
1074 {
1075         int ret, i, error;
1076         size_t offset, buf_size;
1077         char *buffer;
1078         struct vm_snapshot_meta *meta;
1079
1080         error = 0;
1081         offset = 0;
1082         buf_size = SNAPSHOT_BUFFER_SIZE;
1083
1084         buffer = malloc(SNAPSHOT_BUFFER_SIZE * sizeof(char));
1085         if (buffer == NULL) {
1086                 error = ENOMEM;
1087                 perror("Failed to allocate memory for snapshot buffer");
1088                 goto err_vm_snapshot_kern_data;
1089         }
1090
1091         meta = &(struct vm_snapshot_meta) {
1092                 .ctx = ctx,
1093
1094                 .buffer.buf_start = buffer,
1095                 .buffer.buf_size = buf_size,
1096
1097                 .op = VM_SNAPSHOT_SAVE,
1098         };
1099
1100         xo_open_list_h(xop, JSON_STRUCT_ARR_KEY);
1101         for (i = 0; i < nitems(snapshot_kern_structs); i++) {
1102                 meta->dev_name = snapshot_kern_structs[i].struct_name;
1103                 meta->dev_req  = snapshot_kern_structs[i].req;
1104
1105                 memset(meta->buffer.buf_start, 0, meta->buffer.buf_size);
1106                 meta->buffer.buf = meta->buffer.buf_start;
1107                 meta->buffer.buf_rem = meta->buffer.buf_size;
1108
1109                 ret = vm_snapshot_kern_struct(data_fd, xop, JSON_DEV_ARR_KEY,
1110                                               meta, &offset);
1111                 if (ret != 0) {
1112                         error = -1;
1113                         goto err_vm_snapshot_kern_data;
1114                 }
1115         }
1116         xo_close_list_h(xop, JSON_STRUCT_ARR_KEY);
1117
1118 err_vm_snapshot_kern_data:
1119         if (buffer != NULL)
1120                 free(buffer);
1121         return (error);
1122 }
1123
1124 static int
1125 vm_snapshot_basic_metadata(struct vmctx *ctx, xo_handle_t *xop, size_t memsz)
1126 {
1127         int error;
1128         int memflags;
1129         char vmname_buf[MAX_VMNAME];
1130
1131         memset(vmname_buf, 0, MAX_VMNAME);
1132         error = vm_get_name(ctx, vmname_buf, MAX_VMNAME - 1);
1133         if (error != 0) {
1134                 perror("Failed to get VM name");
1135                 goto err;
1136         }
1137
1138         memflags = vm_get_memflags(ctx);
1139
1140         xo_open_container_h(xop, JSON_BASIC_METADATA_KEY);
1141         xo_emit_h(xop, "{:" JSON_NCPUS_KEY "/%ld}\n", guest_ncpus);
1142         xo_emit_h(xop, "{:" JSON_VMNAME_KEY "/%s}\n", vmname_buf);
1143         xo_emit_h(xop, "{:" JSON_MEMSIZE_KEY "/%lu}\n", memsz);
1144         xo_emit_h(xop, "{:" JSON_MEMFLAGS_KEY "/%d}\n", memflags);
1145         xo_close_container_h(xop, JSON_BASIC_METADATA_KEY);
1146
1147 err:
1148         return (error);
1149 }
1150
1151 static int
1152 vm_snapshot_dev_write_data(int data_fd, xo_handle_t *xop, const char *array_key,
1153                            struct vm_snapshot_meta *meta, off_t *offset)
1154 {
1155         int ret;
1156         size_t data_size;
1157
1158         data_size = vm_get_snapshot_size(meta);
1159
1160         ret = write(data_fd, meta->buffer.buf_start, data_size);
1161         if (ret != data_size) {
1162                 perror("Failed to write all snapshotted data.");
1163                 return (-1);
1164         }
1165
1166         /* Write metadata. */
1167         xo_open_instance_h(xop, array_key);
1168         xo_emit_h(xop, "{:" JSON_SNAPSHOT_REQ_KEY "/%s}\n", meta->dev_name);
1169         xo_emit_h(xop, "{:" JSON_SIZE_KEY "/%lu}\n", data_size);
1170         xo_emit_h(xop, "{:" JSON_FILE_OFFSET_KEY "/%lu}\n", *offset);
1171         xo_close_instance_h(xop, array_key);
1172
1173         *offset += data_size;
1174
1175         return (0);
1176 }
1177
1178 static int
1179 vm_snapshot_user_dev(const struct vm_snapshot_dev_info *info,
1180                      int data_fd, xo_handle_t *xop,
1181                      struct vm_snapshot_meta *meta, off_t *offset)
1182 {
1183         int ret;
1184
1185         ret = (*info->snapshot_cb)(meta);
1186         if (ret != 0) {
1187                 fprintf(stderr, "Failed to snapshot %s; ret=%d\r\n",
1188                         meta->dev_name, ret);
1189                 return (ret);
1190         }
1191
1192         ret = vm_snapshot_dev_write_data(data_fd, xop, JSON_DEV_ARR_KEY, meta,
1193                                          offset);
1194         if (ret != 0)
1195                 return (ret);
1196
1197         return (0);
1198 }
1199
1200 static int
1201 vm_snapshot_user_devs(struct vmctx *ctx, int data_fd, xo_handle_t *xop)
1202 {
1203         int ret, i;
1204         off_t offset;
1205         void *buffer;
1206         size_t buf_size;
1207         struct vm_snapshot_meta *meta;
1208
1209         buf_size = SNAPSHOT_BUFFER_SIZE;
1210
1211         offset = lseek(data_fd, 0, SEEK_CUR);
1212         if (offset < 0) {
1213                 perror("Failed to get data file current offset.");
1214                 return (-1);
1215         }
1216
1217         buffer = malloc(buf_size);
1218         if (buffer == NULL) {
1219                 perror("Failed to allocate memory for snapshot buffer");
1220                 ret = ENOSPC;
1221                 goto snapshot_err;
1222         }
1223
1224         meta = &(struct vm_snapshot_meta) {
1225                 .ctx = ctx,
1226
1227                 .buffer.buf_start = buffer,
1228                 .buffer.buf_size = buf_size,
1229
1230                 .op = VM_SNAPSHOT_SAVE,
1231         };
1232
1233         xo_open_list_h(xop, JSON_DEV_ARR_KEY);
1234
1235         /* Restore other devices that support this feature */
1236         for (i = 0; i < nitems(snapshot_devs); i++) {
1237                 meta->dev_name = snapshot_devs[i].dev_name;
1238
1239                 memset(meta->buffer.buf_start, 0, meta->buffer.buf_size);
1240                 meta->buffer.buf = meta->buffer.buf_start;
1241                 meta->buffer.buf_rem = meta->buffer.buf_size;
1242
1243                 ret = vm_snapshot_user_dev(&snapshot_devs[i], data_fd, xop,
1244                                            meta, &offset);
1245                 if (ret != 0)
1246                         goto snapshot_err;
1247         }
1248
1249         xo_close_list_h(xop, JSON_DEV_ARR_KEY);
1250
1251 snapshot_err:
1252         if (buffer != NULL)
1253                 free(buffer);
1254         return (ret);
1255 }
1256
1257 void
1258 checkpoint_cpu_add(int vcpu)
1259 {
1260
1261         pthread_mutex_lock(&vcpu_lock);
1262         CPU_SET(vcpu, &vcpus_active);
1263
1264         if (checkpoint_active) {
1265                 CPU_SET(vcpu, &vcpus_suspended);
1266                 while (checkpoint_active)
1267                         pthread_cond_wait(&vcpus_can_run, &vcpu_lock);
1268                 CPU_CLR(vcpu, &vcpus_suspended);
1269         }
1270         pthread_mutex_unlock(&vcpu_lock);
1271 }
1272
1273 /*
1274  * When a vCPU is suspended for any reason, it calls
1275  * checkpoint_cpu_suspend().  This records that the vCPU is idle.
1276  * Before returning from suspension, checkpoint_cpu_resume() is
1277  * called.  In suspend we note that the vCPU is idle.  In resume we
1278  * pause the vCPU thread until the checkpoint is complete.  The reason
1279  * for the two-step process is that vCPUs might already be stopped in
1280  * the debug server when a checkpoint is requested.  This approach
1281  * allows us to account for and handle those vCPUs.
1282  */
1283 void
1284 checkpoint_cpu_suspend(int vcpu)
1285 {
1286
1287         pthread_mutex_lock(&vcpu_lock);
1288         CPU_SET(vcpu, &vcpus_suspended);
1289         if (checkpoint_active && CPU_CMP(&vcpus_active, &vcpus_suspended) == 0)
1290                 pthread_cond_signal(&vcpus_idle);
1291         pthread_mutex_unlock(&vcpu_lock);
1292 }
1293
1294 void
1295 checkpoint_cpu_resume(int vcpu)
1296 {
1297
1298         pthread_mutex_lock(&vcpu_lock);
1299         while (checkpoint_active)
1300                 pthread_cond_wait(&vcpus_can_run, &vcpu_lock);
1301         CPU_CLR(vcpu, &vcpus_suspended);
1302         pthread_mutex_unlock(&vcpu_lock);
1303 }
1304
1305 static void
1306 vm_vcpu_pause(struct vmctx *ctx)
1307 {
1308
1309         pthread_mutex_lock(&vcpu_lock);
1310         checkpoint_active = true;
1311         vm_suspend_cpu(ctx, -1);
1312         while (CPU_CMP(&vcpus_active, &vcpus_suspended) != 0)
1313                 pthread_cond_wait(&vcpus_idle, &vcpu_lock);
1314         pthread_mutex_unlock(&vcpu_lock);
1315 }
1316
1317 static void
1318 vm_vcpu_resume(struct vmctx *ctx)
1319 {
1320
1321         pthread_mutex_lock(&vcpu_lock);
1322         checkpoint_active = false;
1323         pthread_mutex_unlock(&vcpu_lock);
1324         vm_resume_cpu(ctx, -1);
1325         pthread_cond_broadcast(&vcpus_can_run);
1326 }
1327
1328 static int
1329 vm_checkpoint(struct vmctx *ctx, char *checkpoint_file, bool stop_vm)
1330 {
1331         int fd_checkpoint = 0, kdata_fd = 0;
1332         int ret = 0;
1333         int error = 0;
1334         size_t memsz;
1335         xo_handle_t *xop = NULL;
1336         char *meta_filename = NULL;
1337         char *kdata_filename = NULL;
1338         FILE *meta_file = NULL;
1339
1340         kdata_filename = strcat_extension(checkpoint_file, ".kern");
1341         if (kdata_filename == NULL) {
1342                 fprintf(stderr, "Failed to construct kernel data filename.\n");
1343                 return (-1);
1344         }
1345
1346         kdata_fd = open(kdata_filename, O_WRONLY | O_CREAT | O_TRUNC, 0700);
1347         if (kdata_fd < 0) {
1348                 perror("Failed to open kernel data snapshot file.");
1349                 error = -1;
1350                 goto done;
1351         }
1352
1353         fd_checkpoint = open(checkpoint_file, O_RDWR | O_CREAT | O_TRUNC, 0700);
1354
1355         if (fd_checkpoint < 0) {
1356                 perror("Failed to create checkpoint file");
1357                 error = -1;
1358                 goto done;
1359         }
1360
1361         meta_filename = strcat_extension(checkpoint_file, ".meta");
1362         if (meta_filename == NULL) {
1363                 fprintf(stderr, "Failed to construct vm metadata filename.\n");
1364                 goto done;
1365         }
1366
1367         meta_file = fopen(meta_filename, "w");
1368         if (meta_file == NULL) {
1369                 perror("Failed to open vm metadata snapshot file.");
1370                 goto done;
1371         }
1372
1373         xop = xo_create_to_file(meta_file, XO_STYLE_JSON, XOF_PRETTY);
1374         if (xop == NULL) {
1375                 perror("Failed to get libxo handle on metadata file.");
1376                 goto done;
1377         }
1378
1379         vm_vcpu_pause(ctx);
1380
1381         ret = vm_pause_user_devs(ctx);
1382         if (ret != 0) {
1383                 fprintf(stderr, "Could not pause devices\r\n");
1384                 error = ret;
1385                 goto done;
1386         }
1387
1388         memsz = vm_snapshot_mem(ctx, fd_checkpoint, 0, true);
1389         if (memsz == 0) {
1390                 perror("Could not write guest memory to file");
1391                 error = -1;
1392                 goto done;
1393         }
1394
1395         ret = vm_snapshot_basic_metadata(ctx, xop, memsz);
1396         if (ret != 0) {
1397                 fprintf(stderr, "Failed to snapshot vm basic metadata.\n");
1398                 error = -1;
1399                 goto done;
1400         }
1401
1402
1403         ret = vm_snapshot_kern_structs(ctx, kdata_fd, xop);
1404         if (ret != 0) {
1405                 fprintf(stderr, "Failed to snapshot vm kernel data.\n");
1406                 error = -1;
1407                 goto done;
1408         }
1409
1410         ret = vm_snapshot_user_devs(ctx, kdata_fd, xop);
1411         if (ret != 0) {
1412                 fprintf(stderr, "Failed to snapshot device state.\n");
1413                 error = -1;
1414                 goto done;
1415         }
1416
1417         xo_finish_h(xop);
1418
1419         if (stop_vm) {
1420                 vm_destroy(ctx);
1421                 exit(0);
1422         }
1423
1424 done:
1425         ret = vm_resume_user_devs(ctx);
1426         if (ret != 0)
1427                 fprintf(stderr, "Could not resume devices\r\n");
1428         vm_vcpu_resume(ctx);
1429         if (fd_checkpoint > 0)
1430                 close(fd_checkpoint);
1431         if (meta_filename != NULL)
1432                 free(meta_filename);
1433         if (kdata_filename != NULL)
1434                 free(kdata_filename);
1435         if (xop != NULL)
1436                 xo_destroy(xop);
1437         if (meta_file != NULL)
1438                 fclose(meta_file);
1439         if (kdata_fd > 0)
1440                 close(kdata_fd);
1441         return (error);
1442 }
1443
1444 int
1445 get_checkpoint_msg(int conn_fd, struct vmctx *ctx)
1446 {
1447         unsigned char buf[MAX_MSG_SIZE];
1448         struct checkpoint_op *checkpoint_op;
1449         int len, recv_len, total_recv = 0;
1450         int err = 0;
1451
1452         len = sizeof(struct checkpoint_op); /* expected length */
1453         while ((recv_len = recv(conn_fd, buf + total_recv, len - total_recv, 0)) > 0) {
1454                 total_recv += recv_len;
1455         }
1456         if (recv_len < 0) {
1457                 perror("Error while receiving data from bhyvectl");
1458                 err = -1;
1459                 goto done;
1460         }
1461
1462         checkpoint_op = (struct checkpoint_op *)buf;
1463         switch (checkpoint_op->op) {
1464                 case START_CHECKPOINT:
1465                         err = vm_checkpoint(ctx, checkpoint_op->snapshot_filename, false);
1466                         break;
1467                 case START_SUSPEND:
1468                         err = vm_checkpoint(ctx, checkpoint_op->snapshot_filename, true);
1469                         break;
1470                 default:
1471                         fprintf(stderr, "Unrecognized checkpoint operation.\n");
1472                         err = -1;
1473         }
1474
1475 done:
1476         close(conn_fd);
1477         return (err);
1478 }
1479
1480 /*
1481  * Listen for commands from bhyvectl
1482  */
1483 void *
1484 checkpoint_thread(void *param)
1485 {
1486         struct checkpoint_thread_info *thread_info;
1487         int conn_fd, ret;
1488
1489         pthread_set_name_np(pthread_self(), "checkpoint thread");
1490         thread_info = (struct checkpoint_thread_info *)param;
1491
1492         while ((conn_fd = accept(thread_info->socket_fd, NULL, NULL)) > -1) {
1493                 ret = get_checkpoint_msg(conn_fd, thread_info->ctx);
1494                 if (ret != 0) {
1495                         fprintf(stderr, "Failed to read message on checkpoint "
1496                                         "socket. Retrying.\n");
1497                 }
1498         }
1499         if (conn_fd < -1) {
1500                 perror("Failed to accept connection");
1501         }
1502
1503         return (NULL);
1504 }
1505
1506 /*
1507  * Create the listening socket for IPC with bhyvectl
1508  */
1509 int
1510 init_checkpoint_thread(struct vmctx *ctx)
1511 {
1512         struct checkpoint_thread_info *checkpoint_info = NULL;
1513         struct sockaddr_un addr;
1514         int socket_fd;
1515         pthread_t checkpoint_pthread;
1516         char vmname_buf[MAX_VMNAME];
1517         int ret, err = 0;
1518
1519         memset(&addr, 0, sizeof(addr));
1520
1521         err = pthread_mutex_init(&vcpu_lock, NULL);
1522         if (err != 0)
1523                 errc(1, err, "checkpoint mutex init");
1524         err = pthread_cond_init(&vcpus_idle, NULL);
1525         if (err == 0)
1526                 err = pthread_cond_init(&vcpus_can_run, NULL);
1527         if (err != 0)
1528                 errc(1, err, "checkpoint cv init");
1529
1530         socket_fd = socket(PF_UNIX, SOCK_STREAM, 0);
1531         if (socket_fd < 0) {
1532                 perror("Socket creation failed (IPC with bhyvectl");
1533                 err = -1;
1534                 goto fail;
1535         }
1536
1537         addr.sun_family = AF_UNIX;
1538
1539         err = vm_get_name(ctx, vmname_buf, MAX_VMNAME - 1);
1540         if (err != 0) {
1541                 perror("Failed to get VM name");
1542                 goto fail;
1543         }
1544
1545         snprintf(addr.sun_path, sizeof(addr.sun_path), "%s%s",
1546                  BHYVE_RUN_DIR, vmname_buf);
1547         addr.sun_len = SUN_LEN(&addr);
1548         unlink(addr.sun_path);
1549
1550         if (bind(socket_fd, (struct sockaddr *)&addr, addr.sun_len) != 0) {
1551                 perror("Failed to bind socket (IPC with bhyvectl)");
1552                 err = -1;
1553                 goto fail;
1554         }
1555
1556         if (listen(socket_fd, 10) < 0) {
1557                 perror("Failed to listen on socket (IPC with bhyvectl)");
1558                 err = -1;
1559                 goto fail;
1560         }
1561
1562         checkpoint_info = calloc(1, sizeof(*checkpoint_info));
1563         checkpoint_info->ctx = ctx;
1564         checkpoint_info->socket_fd = socket_fd;
1565
1566         ret = pthread_create(&checkpoint_pthread, NULL, checkpoint_thread,
1567                 checkpoint_info);
1568         if (ret < 0) {
1569                 err = ret;
1570                 goto fail;
1571         }
1572
1573         return (0);
1574 fail:
1575         free(checkpoint_info);
1576         if (socket_fd > 0)
1577                 close(socket_fd);
1578         unlink(addr.sun_path);
1579
1580         return (err);
1581 }
1582
1583 void
1584 vm_snapshot_buf_err(const char *bufname, const enum vm_snapshot_op op)
1585 {
1586         const char *__op;
1587
1588         if (op == VM_SNAPSHOT_SAVE)
1589                 __op = "save";
1590         else if (op == VM_SNAPSHOT_RESTORE)
1591                 __op = "restore";
1592         else
1593                 __op = "unknown";
1594
1595         fprintf(stderr, "%s: snapshot-%s failed for %s\r\n",
1596                 __func__, __op, bufname);
1597 }
1598
1599 int
1600 vm_snapshot_buf(volatile void *data, size_t data_size,
1601                 struct vm_snapshot_meta *meta)
1602 {
1603         struct vm_snapshot_buffer *buffer;
1604         int op;
1605
1606         buffer = &meta->buffer;
1607         op = meta->op;
1608
1609         if (buffer->buf_rem < data_size) {
1610                 fprintf(stderr, "%s: buffer too small\r\n", __func__);
1611                 return (E2BIG);
1612         }
1613
1614         if (op == VM_SNAPSHOT_SAVE)
1615                 memcpy(buffer->buf, (uint8_t *) data, data_size);
1616         else if (op == VM_SNAPSHOT_RESTORE)
1617                 memcpy((uint8_t *) data, buffer->buf, data_size);
1618         else
1619                 return (EINVAL);
1620
1621         buffer->buf += data_size;
1622         buffer->buf_rem -= data_size;
1623
1624         return (0);
1625 }
1626
1627 size_t
1628 vm_get_snapshot_size(struct vm_snapshot_meta *meta)
1629 {
1630         size_t length;
1631         struct vm_snapshot_buffer *buffer;
1632
1633         buffer = &meta->buffer;
1634
1635         if (buffer->buf_size < buffer->buf_rem) {
1636                 fprintf(stderr, "%s: Invalid buffer: size = %zu, rem = %zu\r\n",
1637                         __func__, buffer->buf_size, buffer->buf_rem);
1638                 length = 0;
1639         } else {
1640                 length = buffer->buf_size - buffer->buf_rem;
1641         }
1642
1643         return (length);
1644 }
1645
1646 int
1647 vm_snapshot_guest2host_addr(void **addrp, size_t len, bool restore_null,
1648                             struct vm_snapshot_meta *meta)
1649 {
1650         int ret;
1651         vm_paddr_t gaddr;
1652
1653         if (meta->op == VM_SNAPSHOT_SAVE) {
1654                 gaddr = paddr_host2guest(meta->ctx, *addrp);
1655                 if (gaddr == (vm_paddr_t) -1) {
1656                         if (!restore_null ||
1657                             (restore_null && (*addrp != NULL))) {
1658                                 ret = EFAULT;
1659                                 goto done;
1660                         }
1661                 }
1662
1663                 SNAPSHOT_VAR_OR_LEAVE(gaddr, meta, ret, done);
1664         } else if (meta->op == VM_SNAPSHOT_RESTORE) {
1665                 SNAPSHOT_VAR_OR_LEAVE(gaddr, meta, ret, done);
1666                 if (gaddr == (vm_paddr_t) -1) {
1667                         if (!restore_null) {
1668                                 ret = EFAULT;
1669                                 goto done;
1670                         }
1671                 }
1672
1673                 *addrp = paddr_guest2host(meta->ctx, gaddr, len);
1674         } else {
1675                 ret = EINVAL;
1676         }
1677
1678 done:
1679         return (ret);
1680 }
1681
1682 int
1683 vm_snapshot_buf_cmp(volatile void *data, size_t data_size,
1684                     struct vm_snapshot_meta *meta)
1685 {
1686         struct vm_snapshot_buffer *buffer;
1687         int op;
1688         int ret;
1689
1690         buffer = &meta->buffer;
1691         op = meta->op;
1692
1693         if (buffer->buf_rem < data_size) {
1694                 fprintf(stderr, "%s: buffer too small\r\n", __func__);
1695                 ret = E2BIG;
1696                 goto done;
1697         }
1698
1699         if (op == VM_SNAPSHOT_SAVE) {
1700                 ret = 0;
1701                 memcpy(buffer->buf, (uint8_t *) data, data_size);
1702         } else if (op == VM_SNAPSHOT_RESTORE) {
1703                 ret = memcmp((uint8_t *) data, buffer->buf, data_size);
1704         } else {
1705                 ret = EINVAL;
1706                 goto done;
1707         }
1708
1709         buffer->buf += data_size;
1710         buffer->buf_rem -= data_size;
1711
1712 done:
1713         return (ret);
1714 }