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