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