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