1 /* 2 * QEMU Guest Agent POSIX-specific command implementations 3 * 4 * Copyright IBM Corp. 2011 5 * 6 * Authors: 7 * Michael Roth <mdroth@linux.vnet.ibm.com> 8 * Michal Privoznik <mprivozn@redhat.com> 9 * 10 * This work is licensed under the terms of the GNU GPL, version 2 or later. 11 * See the COPYING file in the top-level directory. 12 */ 13 14 #include <glib.h> 15 #include <sys/types.h> 16 #include <sys/ioctl.h> 17 #include <sys/wait.h> 18 #include <unistd.h> 19 #include <errno.h> 20 #include <fcntl.h> 21 #include <stdio.h> 22 #include <string.h> 23 #include <sys/stat.h> 24 #include <inttypes.h> 25 #include "qga/guest-agent-core.h" 26 #include "qga-qmp-commands.h" 27 #include "qapi/qmp/qerror.h" 28 #include "qemu/queue.h" 29 #include "qemu/host-utils.h" 30 31 #ifndef CONFIG_HAS_ENVIRON 32 #ifdef __APPLE__ 33 #include <crt_externs.h> 34 #define environ (*_NSGetEnviron()) 35 #else 36 extern char **environ; 37 #endif 38 #endif 39 40 #if defined(__linux__) 41 #include <mntent.h> 42 #include <linux/fs.h> 43 #include <ifaddrs.h> 44 #include <arpa/inet.h> 45 #include <sys/socket.h> 46 #include <net/if.h> 47 48 #ifdef FIFREEZE 49 #define CONFIG_FSFREEZE 50 #endif 51 #ifdef FITRIM 52 #define CONFIG_FSTRIM 53 #endif 54 #endif 55 56 static void ga_wait_child(pid_t pid, int *status, Error **err) 57 { 58 pid_t rpid; 59 60 *status = 0; 61 62 do { 63 rpid = waitpid(pid, status, 0); 64 } while (rpid == -1 && errno == EINTR); 65 66 if (rpid == -1) { 67 error_setg_errno(err, errno, "failed to wait for child (pid: %d)", pid); 68 return; 69 } 70 71 g_assert(rpid == pid); 72 } 73 74 void qmp_guest_shutdown(bool has_mode, const char *mode, Error **err) 75 { 76 const char *shutdown_flag; 77 Error *local_err = NULL; 78 pid_t pid; 79 int status; 80 81 slog("guest-shutdown called, mode: %s", mode); 82 if (!has_mode || strcmp(mode, "powerdown") == 0) { 83 shutdown_flag = "-P"; 84 } else if (strcmp(mode, "halt") == 0) { 85 shutdown_flag = "-H"; 86 } else if (strcmp(mode, "reboot") == 0) { 87 shutdown_flag = "-r"; 88 } else { 89 error_setg(err, 90 "mode is invalid (valid values are: halt|powerdown|reboot"); 91 return; 92 } 93 94 pid = fork(); 95 if (pid == 0) { 96 /* child, start the shutdown */ 97 setsid(); 98 reopen_fd_to_null(0); 99 reopen_fd_to_null(1); 100 reopen_fd_to_null(2); 101 102 execle("/sbin/shutdown", "shutdown", "-h", shutdown_flag, "+0", 103 "hypervisor initiated shutdown", (char*)NULL, environ); 104 _exit(EXIT_FAILURE); 105 } else if (pid < 0) { 106 error_setg_errno(err, errno, "failed to create child process"); 107 return; 108 } 109 110 ga_wait_child(pid, &status, &local_err); 111 if (error_is_set(&local_err)) { 112 error_propagate(err, local_err); 113 return; 114 } 115 116 if (!WIFEXITED(status)) { 117 error_setg(err, "child process has terminated abnormally"); 118 return; 119 } 120 121 if (WEXITSTATUS(status)) { 122 error_setg(err, "child process has failed to shutdown"); 123 return; 124 } 125 126 /* succeeded */ 127 } 128 129 int64_t qmp_guest_get_time(Error **errp) 130 { 131 int ret; 132 qemu_timeval tq; 133 int64_t time_ns; 134 135 ret = qemu_gettimeofday(&tq); 136 if (ret < 0) { 137 error_setg_errno(errp, errno, "Failed to get time"); 138 return -1; 139 } 140 141 time_ns = tq.tv_sec * 1000000000LL + tq.tv_usec * 1000; 142 return time_ns; 143 } 144 145 void qmp_guest_set_time(int64_t time_ns, Error **errp) 146 { 147 int ret; 148 int status; 149 pid_t pid; 150 Error *local_err = NULL; 151 struct timeval tv; 152 153 /* year-2038 will overflow in case time_t is 32bit */ 154 if (time_ns / 1000000000 != (time_t)(time_ns / 1000000000)) { 155 error_setg(errp, "Time %" PRId64 " is too large", time_ns); 156 return; 157 } 158 159 tv.tv_sec = time_ns / 1000000000; 160 tv.tv_usec = (time_ns % 1000000000) / 1000; 161 162 ret = settimeofday(&tv, NULL); 163 if (ret < 0) { 164 error_setg_errno(errp, errno, "Failed to set time to guest"); 165 return; 166 } 167 168 /* Set the Hardware Clock to the current System Time. */ 169 pid = fork(); 170 if (pid == 0) { 171 setsid(); 172 reopen_fd_to_null(0); 173 reopen_fd_to_null(1); 174 reopen_fd_to_null(2); 175 176 execle("/sbin/hwclock", "hwclock", "-w", NULL, environ); 177 _exit(EXIT_FAILURE); 178 } else if (pid < 0) { 179 error_setg_errno(errp, errno, "failed to create child process"); 180 return; 181 } 182 183 ga_wait_child(pid, &status, &local_err); 184 if (error_is_set(&local_err)) { 185 error_propagate(errp, local_err); 186 return; 187 } 188 189 if (!WIFEXITED(status)) { 190 error_setg(errp, "child process has terminated abnormally"); 191 return; 192 } 193 194 if (WEXITSTATUS(status)) { 195 error_setg(errp, "hwclock failed to set hardware clock to system time"); 196 return; 197 } 198 } 199 200 typedef struct GuestFileHandle { 201 uint64_t id; 202 FILE *fh; 203 QTAILQ_ENTRY(GuestFileHandle) next; 204 } GuestFileHandle; 205 206 static struct { 207 QTAILQ_HEAD(, GuestFileHandle) filehandles; 208 } guest_file_state; 209 210 static int64_t guest_file_handle_add(FILE *fh, Error **errp) 211 { 212 GuestFileHandle *gfh; 213 int64_t handle; 214 215 handle = ga_get_fd_handle(ga_state, errp); 216 if (error_is_set(errp)) { 217 return 0; 218 } 219 220 gfh = g_malloc0(sizeof(GuestFileHandle)); 221 gfh->id = handle; 222 gfh->fh = fh; 223 QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next); 224 225 return handle; 226 } 227 228 static GuestFileHandle *guest_file_handle_find(int64_t id, Error **err) 229 { 230 GuestFileHandle *gfh; 231 232 QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next) 233 { 234 if (gfh->id == id) { 235 return gfh; 236 } 237 } 238 239 error_setg(err, "handle '%" PRId64 "' has not been found", id); 240 return NULL; 241 } 242 243 typedef const char * const ccpc; 244 245 #ifndef O_BINARY 246 #define O_BINARY 0 247 #endif 248 249 /* http://pubs.opengroup.org/onlinepubs/9699919799/functions/fopen.html */ 250 static const struct { 251 ccpc *forms; 252 int oflag_base; 253 } guest_file_open_modes[] = { 254 { (ccpc[]){ "r", NULL }, O_RDONLY }, 255 { (ccpc[]){ "rb", NULL }, O_RDONLY | O_BINARY }, 256 { (ccpc[]){ "w", NULL }, O_WRONLY | O_CREAT | O_TRUNC }, 257 { (ccpc[]){ "wb", NULL }, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY }, 258 { (ccpc[]){ "a", NULL }, O_WRONLY | O_CREAT | O_APPEND }, 259 { (ccpc[]){ "ab", NULL }, O_WRONLY | O_CREAT | O_APPEND | O_BINARY }, 260 { (ccpc[]){ "r+", NULL }, O_RDWR }, 261 { (ccpc[]){ "rb+", "r+b", NULL }, O_RDWR | O_BINARY }, 262 { (ccpc[]){ "w+", NULL }, O_RDWR | O_CREAT | O_TRUNC }, 263 { (ccpc[]){ "wb+", "w+b", NULL }, O_RDWR | O_CREAT | O_TRUNC | O_BINARY }, 264 { (ccpc[]){ "a+", NULL }, O_RDWR | O_CREAT | O_APPEND }, 265 { (ccpc[]){ "ab+", "a+b", NULL }, O_RDWR | O_CREAT | O_APPEND | O_BINARY } 266 }; 267 268 static int 269 find_open_flag(const char *mode_str, Error **err) 270 { 271 unsigned mode; 272 273 for (mode = 0; mode < ARRAY_SIZE(guest_file_open_modes); ++mode) { 274 ccpc *form; 275 276 form = guest_file_open_modes[mode].forms; 277 while (*form != NULL && strcmp(*form, mode_str) != 0) { 278 ++form; 279 } 280 if (*form != NULL) { 281 break; 282 } 283 } 284 285 if (mode == ARRAY_SIZE(guest_file_open_modes)) { 286 error_setg(err, "invalid file open mode '%s'", mode_str); 287 return -1; 288 } 289 return guest_file_open_modes[mode].oflag_base | O_NOCTTY | O_NONBLOCK; 290 } 291 292 #define DEFAULT_NEW_FILE_MODE (S_IRUSR | S_IWUSR | \ 293 S_IRGRP | S_IWGRP | \ 294 S_IROTH | S_IWOTH) 295 296 static FILE * 297 safe_open_or_create(const char *path, const char *mode, Error **err) 298 { 299 Error *local_err = NULL; 300 int oflag; 301 302 oflag = find_open_flag(mode, &local_err); 303 if (local_err == NULL) { 304 int fd; 305 306 /* If the caller wants / allows creation of a new file, we implement it 307 * with a two step process: open() + (open() / fchmod()). 308 * 309 * First we insist on creating the file exclusively as a new file. If 310 * that succeeds, we're free to set any file-mode bits on it. (The 311 * motivation is that we want to set those file-mode bits independently 312 * of the current umask.) 313 * 314 * If the exclusive creation fails because the file already exists 315 * (EEXIST is not possible for any other reason), we just attempt to 316 * open the file, but in this case we won't be allowed to change the 317 * file-mode bits on the preexistent file. 318 * 319 * The pathname should never disappear between the two open()s in 320 * practice. If it happens, then someone very likely tried to race us. 321 * In this case just go ahead and report the ENOENT from the second 322 * open() to the caller. 323 * 324 * If the caller wants to open a preexistent file, then the first 325 * open() is decisive and its third argument is ignored, and the second 326 * open() and the fchmod() are never called. 327 */ 328 fd = open(path, oflag | ((oflag & O_CREAT) ? O_EXCL : 0), 0); 329 if (fd == -1 && errno == EEXIST) { 330 oflag &= ~(unsigned)O_CREAT; 331 fd = open(path, oflag); 332 } 333 334 if (fd == -1) { 335 error_setg_errno(&local_err, errno, "failed to open file '%s' " 336 "(mode: '%s')", path, mode); 337 } else { 338 qemu_set_cloexec(fd); 339 340 if ((oflag & O_CREAT) && fchmod(fd, DEFAULT_NEW_FILE_MODE) == -1) { 341 error_setg_errno(&local_err, errno, "failed to set permission " 342 "0%03o on new file '%s' (mode: '%s')", 343 (unsigned)DEFAULT_NEW_FILE_MODE, path, mode); 344 } else { 345 FILE *f; 346 347 f = fdopen(fd, mode); 348 if (f == NULL) { 349 error_setg_errno(&local_err, errno, "failed to associate " 350 "stdio stream with file descriptor %d, " 351 "file '%s' (mode: '%s')", fd, path, mode); 352 } else { 353 return f; 354 } 355 } 356 357 close(fd); 358 if (oflag & O_CREAT) { 359 unlink(path); 360 } 361 } 362 } 363 364 error_propagate(err, local_err); 365 return NULL; 366 } 367 368 int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode, Error **err) 369 { 370 FILE *fh; 371 Error *local_err = NULL; 372 int fd; 373 int64_t ret = -1, handle; 374 375 if (!has_mode) { 376 mode = "r"; 377 } 378 slog("guest-file-open called, filepath: %s, mode: %s", path, mode); 379 fh = safe_open_or_create(path, mode, &local_err); 380 if (local_err != NULL) { 381 error_propagate(err, local_err); 382 return -1; 383 } 384 385 /* set fd non-blocking to avoid common use cases (like reading from a 386 * named pipe) from hanging the agent 387 */ 388 fd = fileno(fh); 389 ret = fcntl(fd, F_GETFL); 390 ret = fcntl(fd, F_SETFL, ret | O_NONBLOCK); 391 if (ret == -1) { 392 error_setg_errno(err, errno, "failed to make file '%s' non-blocking", 393 path); 394 fclose(fh); 395 return -1; 396 } 397 398 handle = guest_file_handle_add(fh, err); 399 if (error_is_set(err)) { 400 fclose(fh); 401 return -1; 402 } 403 404 slog("guest-file-open, handle: %" PRId64, handle); 405 return handle; 406 } 407 408 void qmp_guest_file_close(int64_t handle, Error **err) 409 { 410 GuestFileHandle *gfh = guest_file_handle_find(handle, err); 411 int ret; 412 413 slog("guest-file-close called, handle: %" PRId64, handle); 414 if (!gfh) { 415 return; 416 } 417 418 ret = fclose(gfh->fh); 419 if (ret == EOF) { 420 error_setg_errno(err, errno, "failed to close handle"); 421 return; 422 } 423 424 QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next); 425 g_free(gfh); 426 } 427 428 struct GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count, 429 int64_t count, Error **err) 430 { 431 GuestFileHandle *gfh = guest_file_handle_find(handle, err); 432 GuestFileRead *read_data = NULL; 433 guchar *buf; 434 FILE *fh; 435 size_t read_count; 436 437 if (!gfh) { 438 return NULL; 439 } 440 441 if (!has_count) { 442 count = QGA_READ_COUNT_DEFAULT; 443 } else if (count < 0) { 444 error_setg(err, "value '%" PRId64 "' is invalid for argument count", 445 count); 446 return NULL; 447 } 448 449 fh = gfh->fh; 450 buf = g_malloc0(count+1); 451 read_count = fread(buf, 1, count, fh); 452 if (ferror(fh)) { 453 error_setg_errno(err, errno, "failed to read file"); 454 slog("guest-file-read failed, handle: %" PRId64, handle); 455 } else { 456 buf[read_count] = 0; 457 read_data = g_malloc0(sizeof(GuestFileRead)); 458 read_data->count = read_count; 459 read_data->eof = feof(fh); 460 if (read_count) { 461 read_data->buf_b64 = g_base64_encode(buf, read_count); 462 } 463 } 464 g_free(buf); 465 clearerr(fh); 466 467 return read_data; 468 } 469 470 GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64, 471 bool has_count, int64_t count, Error **err) 472 { 473 GuestFileWrite *write_data = NULL; 474 guchar *buf; 475 gsize buf_len; 476 int write_count; 477 GuestFileHandle *gfh = guest_file_handle_find(handle, err); 478 FILE *fh; 479 480 if (!gfh) { 481 return NULL; 482 } 483 484 fh = gfh->fh; 485 buf = g_base64_decode(buf_b64, &buf_len); 486 487 if (!has_count) { 488 count = buf_len; 489 } else if (count < 0 || count > buf_len) { 490 error_setg(err, "value '%" PRId64 "' is invalid for argument count", 491 count); 492 g_free(buf); 493 return NULL; 494 } 495 496 write_count = fwrite(buf, 1, count, fh); 497 if (ferror(fh)) { 498 error_setg_errno(err, errno, "failed to write to file"); 499 slog("guest-file-write failed, handle: %" PRId64, handle); 500 } else { 501 write_data = g_malloc0(sizeof(GuestFileWrite)); 502 write_data->count = write_count; 503 write_data->eof = feof(fh); 504 } 505 g_free(buf); 506 clearerr(fh); 507 508 return write_data; 509 } 510 511 struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset, 512 int64_t whence, Error **err) 513 { 514 GuestFileHandle *gfh = guest_file_handle_find(handle, err); 515 GuestFileSeek *seek_data = NULL; 516 FILE *fh; 517 int ret; 518 519 if (!gfh) { 520 return NULL; 521 } 522 523 fh = gfh->fh; 524 ret = fseek(fh, offset, whence); 525 if (ret == -1) { 526 error_setg_errno(err, errno, "failed to seek file"); 527 } else { 528 seek_data = g_malloc0(sizeof(GuestFileRead)); 529 seek_data->position = ftell(fh); 530 seek_data->eof = feof(fh); 531 } 532 clearerr(fh); 533 534 return seek_data; 535 } 536 537 void qmp_guest_file_flush(int64_t handle, Error **err) 538 { 539 GuestFileHandle *gfh = guest_file_handle_find(handle, err); 540 FILE *fh; 541 int ret; 542 543 if (!gfh) { 544 return; 545 } 546 547 fh = gfh->fh; 548 ret = fflush(fh); 549 if (ret == EOF) { 550 error_setg_errno(err, errno, "failed to flush file"); 551 } 552 } 553 554 static void guest_file_init(void) 555 { 556 QTAILQ_INIT(&guest_file_state.filehandles); 557 } 558 559 /* linux-specific implementations. avoid this if at all possible. */ 560 #if defined(__linux__) 561 562 #if defined(CONFIG_FSFREEZE) || defined(CONFIG_FSTRIM) 563 typedef struct FsMount { 564 char *dirname; 565 char *devtype; 566 QTAILQ_ENTRY(FsMount) next; 567 } FsMount; 568 569 typedef QTAILQ_HEAD(FsMountList, FsMount) FsMountList; 570 571 static void free_fs_mount_list(FsMountList *mounts) 572 { 573 FsMount *mount, *temp; 574 575 if (!mounts) { 576 return; 577 } 578 579 QTAILQ_FOREACH_SAFE(mount, mounts, next, temp) { 580 QTAILQ_REMOVE(mounts, mount, next); 581 g_free(mount->dirname); 582 g_free(mount->devtype); 583 g_free(mount); 584 } 585 } 586 587 /* 588 * Walk the mount table and build a list of local file systems 589 */ 590 static void build_fs_mount_list(FsMountList *mounts, Error **err) 591 { 592 struct mntent *ment; 593 FsMount *mount; 594 char const *mtab = "/proc/self/mounts"; 595 FILE *fp; 596 597 fp = setmntent(mtab, "r"); 598 if (!fp) { 599 error_setg(err, "failed to open mtab file: '%s'", mtab); 600 return; 601 } 602 603 while ((ment = getmntent(fp))) { 604 /* 605 * An entry which device name doesn't start with a '/' is 606 * either a dummy file system or a network file system. 607 * Add special handling for smbfs and cifs as is done by 608 * coreutils as well. 609 */ 610 if ((ment->mnt_fsname[0] != '/') || 611 (strcmp(ment->mnt_type, "smbfs") == 0) || 612 (strcmp(ment->mnt_type, "cifs") == 0)) { 613 continue; 614 } 615 616 mount = g_malloc0(sizeof(FsMount)); 617 mount->dirname = g_strdup(ment->mnt_dir); 618 mount->devtype = g_strdup(ment->mnt_type); 619 620 QTAILQ_INSERT_TAIL(mounts, mount, next); 621 } 622 623 endmntent(fp); 624 } 625 #endif 626 627 #if defined(CONFIG_FSFREEZE) 628 629 typedef enum { 630 FSFREEZE_HOOK_THAW = 0, 631 FSFREEZE_HOOK_FREEZE, 632 } FsfreezeHookArg; 633 634 const char *fsfreeze_hook_arg_string[] = { 635 "thaw", 636 "freeze", 637 }; 638 639 static void execute_fsfreeze_hook(FsfreezeHookArg arg, Error **err) 640 { 641 int status; 642 pid_t pid; 643 const char *hook; 644 const char *arg_str = fsfreeze_hook_arg_string[arg]; 645 Error *local_err = NULL; 646 647 hook = ga_fsfreeze_hook(ga_state); 648 if (!hook) { 649 return; 650 } 651 if (access(hook, X_OK) != 0) { 652 error_setg_errno(err, errno, "can't access fsfreeze hook '%s'", hook); 653 return; 654 } 655 656 slog("executing fsfreeze hook with arg '%s'", arg_str); 657 pid = fork(); 658 if (pid == 0) { 659 setsid(); 660 reopen_fd_to_null(0); 661 reopen_fd_to_null(1); 662 reopen_fd_to_null(2); 663 664 execle(hook, hook, arg_str, NULL, environ); 665 _exit(EXIT_FAILURE); 666 } else if (pid < 0) { 667 error_setg_errno(err, errno, "failed to create child process"); 668 return; 669 } 670 671 ga_wait_child(pid, &status, &local_err); 672 if (error_is_set(&local_err)) { 673 error_propagate(err, local_err); 674 return; 675 } 676 677 if (!WIFEXITED(status)) { 678 error_setg(err, "fsfreeze hook has terminated abnormally"); 679 return; 680 } 681 682 status = WEXITSTATUS(status); 683 if (status) { 684 error_setg(err, "fsfreeze hook has failed with status %d", status); 685 return; 686 } 687 } 688 689 /* 690 * Return status of freeze/thaw 691 */ 692 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err) 693 { 694 if (ga_is_frozen(ga_state)) { 695 return GUEST_FSFREEZE_STATUS_FROZEN; 696 } 697 698 return GUEST_FSFREEZE_STATUS_THAWED; 699 } 700 701 /* 702 * Walk list of mounted file systems in the guest, and freeze the ones which 703 * are real local file systems. 704 */ 705 int64_t qmp_guest_fsfreeze_freeze(Error **err) 706 { 707 int ret = 0, i = 0; 708 FsMountList mounts; 709 struct FsMount *mount; 710 Error *local_err = NULL; 711 int fd; 712 713 slog("guest-fsfreeze called"); 714 715 execute_fsfreeze_hook(FSFREEZE_HOOK_FREEZE, &local_err); 716 if (error_is_set(&local_err)) { 717 error_propagate(err, local_err); 718 return -1; 719 } 720 721 QTAILQ_INIT(&mounts); 722 build_fs_mount_list(&mounts, &local_err); 723 if (error_is_set(&local_err)) { 724 error_propagate(err, local_err); 725 return -1; 726 } 727 728 /* cannot risk guest agent blocking itself on a write in this state */ 729 ga_set_frozen(ga_state); 730 731 QTAILQ_FOREACH_REVERSE(mount, &mounts, FsMountList, next) { 732 fd = qemu_open(mount->dirname, O_RDONLY); 733 if (fd == -1) { 734 error_setg_errno(err, errno, "failed to open %s", mount->dirname); 735 goto error; 736 } 737 738 /* we try to cull filesytems we know won't work in advance, but other 739 * filesytems may not implement fsfreeze for less obvious reasons. 740 * these will report EOPNOTSUPP. we simply ignore these when tallying 741 * the number of frozen filesystems. 742 * 743 * any other error means a failure to freeze a filesystem we 744 * expect to be freezable, so return an error in those cases 745 * and return system to thawed state. 746 */ 747 ret = ioctl(fd, FIFREEZE); 748 if (ret == -1) { 749 if (errno != EOPNOTSUPP) { 750 error_setg_errno(err, errno, "failed to freeze %s", 751 mount->dirname); 752 close(fd); 753 goto error; 754 } 755 } else { 756 i++; 757 } 758 close(fd); 759 } 760 761 free_fs_mount_list(&mounts); 762 return i; 763 764 error: 765 free_fs_mount_list(&mounts); 766 qmp_guest_fsfreeze_thaw(NULL); 767 return 0; 768 } 769 770 /* 771 * Walk list of frozen file systems in the guest, and thaw them. 772 */ 773 int64_t qmp_guest_fsfreeze_thaw(Error **err) 774 { 775 int ret; 776 FsMountList mounts; 777 FsMount *mount; 778 int fd, i = 0, logged; 779 Error *local_err = NULL; 780 781 QTAILQ_INIT(&mounts); 782 build_fs_mount_list(&mounts, &local_err); 783 if (error_is_set(&local_err)) { 784 error_propagate(err, local_err); 785 return 0; 786 } 787 788 QTAILQ_FOREACH(mount, &mounts, next) { 789 logged = false; 790 fd = qemu_open(mount->dirname, O_RDONLY); 791 if (fd == -1) { 792 continue; 793 } 794 /* we have no way of knowing whether a filesystem was actually unfrozen 795 * as a result of a successful call to FITHAW, only that if an error 796 * was returned the filesystem was *not* unfrozen by that particular 797 * call. 798 * 799 * since multiple preceding FIFREEZEs require multiple calls to FITHAW 800 * to unfreeze, continuing issuing FITHAW until an error is returned, 801 * in which case either the filesystem is in an unfreezable state, or, 802 * more likely, it was thawed previously (and remains so afterward). 803 * 804 * also, since the most recent successful call is the one that did 805 * the actual unfreeze, we can use this to provide an accurate count 806 * of the number of filesystems unfrozen by guest-fsfreeze-thaw, which 807 * may * be useful for determining whether a filesystem was unfrozen 808 * during the freeze/thaw phase by a process other than qemu-ga. 809 */ 810 do { 811 ret = ioctl(fd, FITHAW); 812 if (ret == 0 && !logged) { 813 i++; 814 logged = true; 815 } 816 } while (ret == 0); 817 close(fd); 818 } 819 820 ga_unset_frozen(ga_state); 821 free_fs_mount_list(&mounts); 822 823 execute_fsfreeze_hook(FSFREEZE_HOOK_THAW, err); 824 825 return i; 826 } 827 828 static void guest_fsfreeze_cleanup(void) 829 { 830 Error *err = NULL; 831 832 if (ga_is_frozen(ga_state) == GUEST_FSFREEZE_STATUS_FROZEN) { 833 qmp_guest_fsfreeze_thaw(&err); 834 if (err) { 835 slog("failed to clean up frozen filesystems: %s", 836 error_get_pretty(err)); 837 error_free(err); 838 } 839 } 840 } 841 #endif /* CONFIG_FSFREEZE */ 842 843 #if defined(CONFIG_FSTRIM) 844 /* 845 * Walk list of mounted file systems in the guest, and trim them. 846 */ 847 void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **err) 848 { 849 int ret = 0; 850 FsMountList mounts; 851 struct FsMount *mount; 852 int fd; 853 Error *local_err = NULL; 854 struct fstrim_range r = { 855 .start = 0, 856 .len = -1, 857 .minlen = has_minimum ? minimum : 0, 858 }; 859 860 slog("guest-fstrim called"); 861 862 QTAILQ_INIT(&mounts); 863 build_fs_mount_list(&mounts, &local_err); 864 if (error_is_set(&local_err)) { 865 error_propagate(err, local_err); 866 return; 867 } 868 869 QTAILQ_FOREACH(mount, &mounts, next) { 870 fd = qemu_open(mount->dirname, O_RDONLY); 871 if (fd == -1) { 872 error_setg_errno(err, errno, "failed to open %s", mount->dirname); 873 goto error; 874 } 875 876 /* We try to cull filesytems we know won't work in advance, but other 877 * filesytems may not implement fstrim for less obvious reasons. These 878 * will report EOPNOTSUPP; we simply ignore these errors. Any other 879 * error means an unexpected error, so return it in those cases. In 880 * some other cases ENOTTY will be reported (e.g. CD-ROMs). 881 */ 882 ret = ioctl(fd, FITRIM, &r); 883 if (ret == -1) { 884 if (errno != ENOTTY && errno != EOPNOTSUPP) { 885 error_setg_errno(err, errno, "failed to trim %s", 886 mount->dirname); 887 close(fd); 888 goto error; 889 } 890 } 891 close(fd); 892 } 893 894 error: 895 free_fs_mount_list(&mounts); 896 } 897 #endif /* CONFIG_FSTRIM */ 898 899 900 #define LINUX_SYS_STATE_FILE "/sys/power/state" 901 #define SUSPEND_SUPPORTED 0 902 #define SUSPEND_NOT_SUPPORTED 1 903 904 static void bios_supports_mode(const char *pmutils_bin, const char *pmutils_arg, 905 const char *sysfile_str, Error **err) 906 { 907 Error *local_err = NULL; 908 char *pmutils_path; 909 pid_t pid; 910 int status; 911 912 pmutils_path = g_find_program_in_path(pmutils_bin); 913 914 pid = fork(); 915 if (!pid) { 916 char buf[32]; /* hopefully big enough */ 917 ssize_t ret; 918 int fd; 919 920 setsid(); 921 reopen_fd_to_null(0); 922 reopen_fd_to_null(1); 923 reopen_fd_to_null(2); 924 925 if (pmutils_path) { 926 execle(pmutils_path, pmutils_bin, pmutils_arg, NULL, environ); 927 } 928 929 /* 930 * If we get here either pm-utils is not installed or execle() has 931 * failed. Let's try the manual method if the caller wants it. 932 */ 933 934 if (!sysfile_str) { 935 _exit(SUSPEND_NOT_SUPPORTED); 936 } 937 938 fd = open(LINUX_SYS_STATE_FILE, O_RDONLY); 939 if (fd < 0) { 940 _exit(SUSPEND_NOT_SUPPORTED); 941 } 942 943 ret = read(fd, buf, sizeof(buf)-1); 944 if (ret <= 0) { 945 _exit(SUSPEND_NOT_SUPPORTED); 946 } 947 buf[ret] = '\0'; 948 949 if (strstr(buf, sysfile_str)) { 950 _exit(SUSPEND_SUPPORTED); 951 } 952 953 _exit(SUSPEND_NOT_SUPPORTED); 954 } else if (pid < 0) { 955 error_setg_errno(err, errno, "failed to create child process"); 956 goto out; 957 } 958 959 ga_wait_child(pid, &status, &local_err); 960 if (error_is_set(&local_err)) { 961 error_propagate(err, local_err); 962 goto out; 963 } 964 965 if (!WIFEXITED(status)) { 966 error_setg(err, "child process has terminated abnormally"); 967 goto out; 968 } 969 970 switch (WEXITSTATUS(status)) { 971 case SUSPEND_SUPPORTED: 972 goto out; 973 case SUSPEND_NOT_SUPPORTED: 974 error_setg(err, 975 "the requested suspend mode is not supported by the guest"); 976 goto out; 977 default: 978 error_setg(err, 979 "the helper program '%s' returned an unexpected exit status" 980 " code (%d)", pmutils_path, WEXITSTATUS(status)); 981 goto out; 982 } 983 984 out: 985 g_free(pmutils_path); 986 } 987 988 static void guest_suspend(const char *pmutils_bin, const char *sysfile_str, 989 Error **err) 990 { 991 Error *local_err = NULL; 992 char *pmutils_path; 993 pid_t pid; 994 int status; 995 996 pmutils_path = g_find_program_in_path(pmutils_bin); 997 998 pid = fork(); 999 if (pid == 0) { 1000 /* child */ 1001 int fd; 1002 1003 setsid(); 1004 reopen_fd_to_null(0); 1005 reopen_fd_to_null(1); 1006 reopen_fd_to_null(2); 1007 1008 if (pmutils_path) { 1009 execle(pmutils_path, pmutils_bin, NULL, environ); 1010 } 1011 1012 /* 1013 * If we get here either pm-utils is not installed or execle() has 1014 * failed. Let's try the manual method if the caller wants it. 1015 */ 1016 1017 if (!sysfile_str) { 1018 _exit(EXIT_FAILURE); 1019 } 1020 1021 fd = open(LINUX_SYS_STATE_FILE, O_WRONLY); 1022 if (fd < 0) { 1023 _exit(EXIT_FAILURE); 1024 } 1025 1026 if (write(fd, sysfile_str, strlen(sysfile_str)) < 0) { 1027 _exit(EXIT_FAILURE); 1028 } 1029 1030 _exit(EXIT_SUCCESS); 1031 } else if (pid < 0) { 1032 error_setg_errno(err, errno, "failed to create child process"); 1033 goto out; 1034 } 1035 1036 ga_wait_child(pid, &status, &local_err); 1037 if (error_is_set(&local_err)) { 1038 error_propagate(err, local_err); 1039 goto out; 1040 } 1041 1042 if (!WIFEXITED(status)) { 1043 error_setg(err, "child process has terminated abnormally"); 1044 goto out; 1045 } 1046 1047 if (WEXITSTATUS(status)) { 1048 error_setg(err, "child process has failed to suspend"); 1049 goto out; 1050 } 1051 1052 out: 1053 g_free(pmutils_path); 1054 } 1055 1056 void qmp_guest_suspend_disk(Error **err) 1057 { 1058 bios_supports_mode("pm-is-supported", "--hibernate", "disk", err); 1059 if (error_is_set(err)) { 1060 return; 1061 } 1062 1063 guest_suspend("pm-hibernate", "disk", err); 1064 } 1065 1066 void qmp_guest_suspend_ram(Error **err) 1067 { 1068 bios_supports_mode("pm-is-supported", "--suspend", "mem", err); 1069 if (error_is_set(err)) { 1070 return; 1071 } 1072 1073 guest_suspend("pm-suspend", "mem", err); 1074 } 1075 1076 void qmp_guest_suspend_hybrid(Error **err) 1077 { 1078 bios_supports_mode("pm-is-supported", "--suspend-hybrid", NULL, err); 1079 if (error_is_set(err)) { 1080 return; 1081 } 1082 1083 guest_suspend("pm-suspend-hybrid", NULL, err); 1084 } 1085 1086 static GuestNetworkInterfaceList * 1087 guest_find_interface(GuestNetworkInterfaceList *head, 1088 const char *name) 1089 { 1090 for (; head; head = head->next) { 1091 if (strcmp(head->value->name, name) == 0) { 1092 break; 1093 } 1094 } 1095 1096 return head; 1097 } 1098 1099 /* 1100 * Build information about guest interfaces 1101 */ 1102 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp) 1103 { 1104 GuestNetworkInterfaceList *head = NULL, *cur_item = NULL; 1105 struct ifaddrs *ifap, *ifa; 1106 1107 if (getifaddrs(&ifap) < 0) { 1108 error_setg_errno(errp, errno, "getifaddrs failed"); 1109 goto error; 1110 } 1111 1112 for (ifa = ifap; ifa; ifa = ifa->ifa_next) { 1113 GuestNetworkInterfaceList *info; 1114 GuestIpAddressList **address_list = NULL, *address_item = NULL; 1115 char addr4[INET_ADDRSTRLEN]; 1116 char addr6[INET6_ADDRSTRLEN]; 1117 int sock; 1118 struct ifreq ifr; 1119 unsigned char *mac_addr; 1120 void *p; 1121 1122 g_debug("Processing %s interface", ifa->ifa_name); 1123 1124 info = guest_find_interface(head, ifa->ifa_name); 1125 1126 if (!info) { 1127 info = g_malloc0(sizeof(*info)); 1128 info->value = g_malloc0(sizeof(*info->value)); 1129 info->value->name = g_strdup(ifa->ifa_name); 1130 1131 if (!cur_item) { 1132 head = cur_item = info; 1133 } else { 1134 cur_item->next = info; 1135 cur_item = info; 1136 } 1137 } 1138 1139 if (!info->value->has_hardware_address && 1140 ifa->ifa_flags & SIOCGIFHWADDR) { 1141 /* we haven't obtained HW address yet */ 1142 sock = socket(PF_INET, SOCK_STREAM, 0); 1143 if (sock == -1) { 1144 error_setg_errno(errp, errno, "failed to create socket"); 1145 goto error; 1146 } 1147 1148 memset(&ifr, 0, sizeof(ifr)); 1149 pstrcpy(ifr.ifr_name, IF_NAMESIZE, info->value->name); 1150 if (ioctl(sock, SIOCGIFHWADDR, &ifr) == -1) { 1151 error_setg_errno(errp, errno, 1152 "failed to get MAC address of %s", 1153 ifa->ifa_name); 1154 close(sock); 1155 goto error; 1156 } 1157 1158 close(sock); 1159 mac_addr = (unsigned char *) &ifr.ifr_hwaddr.sa_data; 1160 1161 info->value->hardware_address = 1162 g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x", 1163 (int) mac_addr[0], (int) mac_addr[1], 1164 (int) mac_addr[2], (int) mac_addr[3], 1165 (int) mac_addr[4], (int) mac_addr[5]); 1166 1167 info->value->has_hardware_address = true; 1168 } 1169 1170 if (ifa->ifa_addr && 1171 ifa->ifa_addr->sa_family == AF_INET) { 1172 /* interface with IPv4 address */ 1173 p = &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr; 1174 if (!inet_ntop(AF_INET, p, addr4, sizeof(addr4))) { 1175 error_setg_errno(errp, errno, "inet_ntop failed"); 1176 goto error; 1177 } 1178 1179 address_item = g_malloc0(sizeof(*address_item)); 1180 address_item->value = g_malloc0(sizeof(*address_item->value)); 1181 address_item->value->ip_address = g_strdup(addr4); 1182 address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4; 1183 1184 if (ifa->ifa_netmask) { 1185 /* Count the number of set bits in netmask. 1186 * This is safe as '1' and '0' cannot be shuffled in netmask. */ 1187 p = &((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr; 1188 address_item->value->prefix = ctpop32(((uint32_t *) p)[0]); 1189 } 1190 } else if (ifa->ifa_addr && 1191 ifa->ifa_addr->sa_family == AF_INET6) { 1192 /* interface with IPv6 address */ 1193 p = &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr; 1194 if (!inet_ntop(AF_INET6, p, addr6, sizeof(addr6))) { 1195 error_setg_errno(errp, errno, "inet_ntop failed"); 1196 goto error; 1197 } 1198 1199 address_item = g_malloc0(sizeof(*address_item)); 1200 address_item->value = g_malloc0(sizeof(*address_item->value)); 1201 address_item->value->ip_address = g_strdup(addr6); 1202 address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6; 1203 1204 if (ifa->ifa_netmask) { 1205 /* Count the number of set bits in netmask. 1206 * This is safe as '1' and '0' cannot be shuffled in netmask. */ 1207 p = &((struct sockaddr_in6 *)ifa->ifa_netmask)->sin6_addr; 1208 address_item->value->prefix = 1209 ctpop32(((uint32_t *) p)[0]) + 1210 ctpop32(((uint32_t *) p)[1]) + 1211 ctpop32(((uint32_t *) p)[2]) + 1212 ctpop32(((uint32_t *) p)[3]); 1213 } 1214 } 1215 1216 if (!address_item) { 1217 continue; 1218 } 1219 1220 address_list = &info->value->ip_addresses; 1221 1222 while (*address_list && (*address_list)->next) { 1223 address_list = &(*address_list)->next; 1224 } 1225 1226 if (!*address_list) { 1227 *address_list = address_item; 1228 } else { 1229 (*address_list)->next = address_item; 1230 } 1231 1232 info->value->has_ip_addresses = true; 1233 1234 1235 } 1236 1237 freeifaddrs(ifap); 1238 return head; 1239 1240 error: 1241 freeifaddrs(ifap); 1242 qapi_free_GuestNetworkInterfaceList(head); 1243 return NULL; 1244 } 1245 1246 #define SYSCONF_EXACT(name, err) sysconf_exact((name), #name, (err)) 1247 1248 static long sysconf_exact(int name, const char *name_str, Error **err) 1249 { 1250 long ret; 1251 1252 errno = 0; 1253 ret = sysconf(name); 1254 if (ret == -1) { 1255 if (errno == 0) { 1256 error_setg(err, "sysconf(%s): value indefinite", name_str); 1257 } else { 1258 error_setg_errno(err, errno, "sysconf(%s)", name_str); 1259 } 1260 } 1261 return ret; 1262 } 1263 1264 /* Transfer online/offline status between @vcpu and the guest system. 1265 * 1266 * On input either @errp or *@errp must be NULL. 1267 * 1268 * In system-to-@vcpu direction, the following @vcpu fields are accessed: 1269 * - R: vcpu->logical_id 1270 * - W: vcpu->online 1271 * - W: vcpu->can_offline 1272 * 1273 * In @vcpu-to-system direction, the following @vcpu fields are accessed: 1274 * - R: vcpu->logical_id 1275 * - R: vcpu->online 1276 * 1277 * Written members remain unmodified on error. 1278 */ 1279 static void transfer_vcpu(GuestLogicalProcessor *vcpu, bool sys2vcpu, 1280 Error **errp) 1281 { 1282 char *dirpath; 1283 int dirfd; 1284 1285 dirpath = g_strdup_printf("/sys/devices/system/cpu/cpu%" PRId64 "/", 1286 vcpu->logical_id); 1287 dirfd = open(dirpath, O_RDONLY | O_DIRECTORY); 1288 if (dirfd == -1) { 1289 error_setg_errno(errp, errno, "open(\"%s\")", dirpath); 1290 } else { 1291 static const char fn[] = "online"; 1292 int fd; 1293 int res; 1294 1295 fd = openat(dirfd, fn, sys2vcpu ? O_RDONLY : O_RDWR); 1296 if (fd == -1) { 1297 if (errno != ENOENT) { 1298 error_setg_errno(errp, errno, "open(\"%s/%s\")", dirpath, fn); 1299 } else if (sys2vcpu) { 1300 vcpu->online = true; 1301 vcpu->can_offline = false; 1302 } else if (!vcpu->online) { 1303 error_setg(errp, "logical processor #%" PRId64 " can't be " 1304 "offlined", vcpu->logical_id); 1305 } /* otherwise pretend successful re-onlining */ 1306 } else { 1307 unsigned char status; 1308 1309 res = pread(fd, &status, 1, 0); 1310 if (res == -1) { 1311 error_setg_errno(errp, errno, "pread(\"%s/%s\")", dirpath, fn); 1312 } else if (res == 0) { 1313 error_setg(errp, "pread(\"%s/%s\"): unexpected EOF", dirpath, 1314 fn); 1315 } else if (sys2vcpu) { 1316 vcpu->online = (status != '0'); 1317 vcpu->can_offline = true; 1318 } else if (vcpu->online != (status != '0')) { 1319 status = '0' + vcpu->online; 1320 if (pwrite(fd, &status, 1, 0) == -1) { 1321 error_setg_errno(errp, errno, "pwrite(\"%s/%s\")", dirpath, 1322 fn); 1323 } 1324 } /* otherwise pretend successful re-(on|off)-lining */ 1325 1326 res = close(fd); 1327 g_assert(res == 0); 1328 } 1329 1330 res = close(dirfd); 1331 g_assert(res == 0); 1332 } 1333 1334 g_free(dirpath); 1335 } 1336 1337 GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp) 1338 { 1339 int64_t current; 1340 GuestLogicalProcessorList *head, **link; 1341 long sc_max; 1342 Error *local_err = NULL; 1343 1344 current = 0; 1345 head = NULL; 1346 link = &head; 1347 sc_max = SYSCONF_EXACT(_SC_NPROCESSORS_CONF, &local_err); 1348 1349 while (local_err == NULL && current < sc_max) { 1350 GuestLogicalProcessor *vcpu; 1351 GuestLogicalProcessorList *entry; 1352 1353 vcpu = g_malloc0(sizeof *vcpu); 1354 vcpu->logical_id = current++; 1355 vcpu->has_can_offline = true; /* lolspeak ftw */ 1356 transfer_vcpu(vcpu, true, &local_err); 1357 1358 entry = g_malloc0(sizeof *entry); 1359 entry->value = vcpu; 1360 1361 *link = entry; 1362 link = &entry->next; 1363 } 1364 1365 if (local_err == NULL) { 1366 /* there's no guest with zero VCPUs */ 1367 g_assert(head != NULL); 1368 return head; 1369 } 1370 1371 qapi_free_GuestLogicalProcessorList(head); 1372 error_propagate(errp, local_err); 1373 return NULL; 1374 } 1375 1376 int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp) 1377 { 1378 int64_t processed; 1379 Error *local_err = NULL; 1380 1381 processed = 0; 1382 while (vcpus != NULL) { 1383 transfer_vcpu(vcpus->value, false, &local_err); 1384 if (local_err != NULL) { 1385 break; 1386 } 1387 ++processed; 1388 vcpus = vcpus->next; 1389 } 1390 1391 if (local_err != NULL) { 1392 if (processed == 0) { 1393 error_propagate(errp, local_err); 1394 } else { 1395 error_free(local_err); 1396 } 1397 } 1398 1399 return processed; 1400 } 1401 1402 #else /* defined(__linux__) */ 1403 1404 void qmp_guest_suspend_disk(Error **err) 1405 { 1406 error_set(err, QERR_UNSUPPORTED); 1407 } 1408 1409 void qmp_guest_suspend_ram(Error **err) 1410 { 1411 error_set(err, QERR_UNSUPPORTED); 1412 } 1413 1414 void qmp_guest_suspend_hybrid(Error **err) 1415 { 1416 error_set(err, QERR_UNSUPPORTED); 1417 } 1418 1419 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp) 1420 { 1421 error_set(errp, QERR_UNSUPPORTED); 1422 return NULL; 1423 } 1424 1425 GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp) 1426 { 1427 error_set(errp, QERR_UNSUPPORTED); 1428 return NULL; 1429 } 1430 1431 int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp) 1432 { 1433 error_set(errp, QERR_UNSUPPORTED); 1434 return -1; 1435 } 1436 1437 #endif 1438 1439 #if !defined(CONFIG_FSFREEZE) 1440 1441 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err) 1442 { 1443 error_set(err, QERR_UNSUPPORTED); 1444 1445 return 0; 1446 } 1447 1448 int64_t qmp_guest_fsfreeze_freeze(Error **err) 1449 { 1450 error_set(err, QERR_UNSUPPORTED); 1451 1452 return 0; 1453 } 1454 1455 int64_t qmp_guest_fsfreeze_thaw(Error **err) 1456 { 1457 error_set(err, QERR_UNSUPPORTED); 1458 1459 return 0; 1460 } 1461 #endif /* CONFIG_FSFREEZE */ 1462 1463 #if !defined(CONFIG_FSTRIM) 1464 void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **err) 1465 { 1466 error_set(err, QERR_UNSUPPORTED); 1467 } 1468 #endif 1469 1470 /* register init/cleanup routines for stateful command groups */ 1471 void ga_command_state_init(GAState *s, GACommandState *cs) 1472 { 1473 #if defined(CONFIG_FSFREEZE) 1474 ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup); 1475 #endif 1476 ga_command_state_add(cs, guest_file_init, NULL); 1477 } 1478