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 "qemu/osdep.h" 15 #include <sys/ioctl.h> 16 #include <sys/utsname.h> 17 #include <sys/wait.h> 18 #include <dirent.h> 19 #include "qga-qapi-commands.h" 20 #include "qapi/error.h" 21 #include "qapi/qmp/qerror.h" 22 #include "qemu/host-utils.h" 23 #include "qemu/sockets.h" 24 #include "qemu/base64.h" 25 #include "qemu/cutils.h" 26 #include "commands-common.h" 27 #include "block/nvme.h" 28 #include "cutils.h" 29 30 #ifdef HAVE_UTMPX 31 #include <utmpx.h> 32 #endif 33 34 #if defined(__linux__) 35 #include <mntent.h> 36 #include <sys/statvfs.h> 37 #include <linux/nvme_ioctl.h> 38 39 #ifdef CONFIG_LIBUDEV 40 #include <libudev.h> 41 #endif 42 #endif 43 44 #ifdef HAVE_GETIFADDRS 45 #include <arpa/inet.h> 46 #include <sys/socket.h> 47 #include <net/if.h> 48 #if defined(__NetBSD__) || defined(__OpenBSD__) || defined(CONFIG_SOLARIS) 49 #include <net/if_arp.h> 50 #include <netinet/if_ether.h> 51 #if !defined(ETHER_ADDR_LEN) && defined(ETHERADDRL) 52 #define ETHER_ADDR_LEN ETHERADDRL 53 #endif 54 #else 55 #include <net/ethernet.h> 56 #endif 57 #ifdef CONFIG_SOLARIS 58 #include <sys/sockio.h> 59 #endif 60 #endif 61 62 static void ga_wait_child(pid_t pid, int *status, Error **errp) 63 { 64 pid_t rpid; 65 66 *status = 0; 67 68 rpid = RETRY_ON_EINTR(waitpid(pid, status, 0)); 69 70 if (rpid == -1) { 71 error_setg_errno(errp, errno, "failed to wait for child (pid: %d)", 72 pid); 73 return; 74 } 75 76 g_assert(rpid == pid); 77 } 78 79 void qmp_guest_shutdown(const char *mode, Error **errp) 80 { 81 const char *shutdown_flag; 82 Error *local_err = NULL; 83 pid_t pid; 84 int status; 85 86 #ifdef CONFIG_SOLARIS 87 const char *powerdown_flag = "-i5"; 88 const char *halt_flag = "-i0"; 89 const char *reboot_flag = "-i6"; 90 #elif defined(CONFIG_BSD) 91 const char *powerdown_flag = "-p"; 92 const char *halt_flag = "-h"; 93 const char *reboot_flag = "-r"; 94 #else 95 const char *powerdown_flag = "-P"; 96 const char *halt_flag = "-H"; 97 const char *reboot_flag = "-r"; 98 #endif 99 100 slog("guest-shutdown called, mode: %s", mode); 101 if (!mode || strcmp(mode, "powerdown") == 0) { 102 shutdown_flag = powerdown_flag; 103 } else if (strcmp(mode, "halt") == 0) { 104 shutdown_flag = halt_flag; 105 } else if (strcmp(mode, "reboot") == 0) { 106 shutdown_flag = reboot_flag; 107 } else { 108 error_setg(errp, 109 "mode is invalid (valid values are: halt|powerdown|reboot"); 110 return; 111 } 112 113 pid = fork(); 114 if (pid == 0) { 115 /* child, start the shutdown */ 116 setsid(); 117 reopen_fd_to_null(0); 118 reopen_fd_to_null(1); 119 reopen_fd_to_null(2); 120 121 #ifdef CONFIG_SOLARIS 122 execl("/sbin/shutdown", "shutdown", shutdown_flag, "-g0", "-y", 123 "hypervisor initiated shutdown", (char *)NULL); 124 #elif defined(CONFIG_BSD) 125 execl("/sbin/shutdown", "shutdown", shutdown_flag, "+0", 126 "hypervisor initiated shutdown", (char *)NULL); 127 #else 128 execl("/sbin/shutdown", "shutdown", "-h", shutdown_flag, "+0", 129 "hypervisor initiated shutdown", (char *)NULL); 130 #endif 131 _exit(EXIT_FAILURE); 132 } else if (pid < 0) { 133 error_setg_errno(errp, errno, "failed to create child process"); 134 return; 135 } 136 137 ga_wait_child(pid, &status, &local_err); 138 if (local_err) { 139 error_propagate(errp, local_err); 140 return; 141 } 142 143 if (!WIFEXITED(status)) { 144 error_setg(errp, "child process has terminated abnormally"); 145 return; 146 } 147 148 if (WEXITSTATUS(status)) { 149 error_setg(errp, "child process has failed to shutdown"); 150 return; 151 } 152 153 /* succeeded */ 154 } 155 156 void qmp_guest_set_time(bool has_time, int64_t time_ns, Error **errp) 157 { 158 int ret; 159 int status; 160 pid_t pid; 161 Error *local_err = NULL; 162 struct timeval tv; 163 static const char hwclock_path[] = "/sbin/hwclock"; 164 static int hwclock_available = -1; 165 166 if (hwclock_available < 0) { 167 hwclock_available = (access(hwclock_path, X_OK) == 0); 168 } 169 170 if (!hwclock_available) { 171 error_setg(errp, QERR_UNSUPPORTED); 172 return; 173 } 174 175 /* If user has passed a time, validate and set it. */ 176 if (has_time) { 177 GDate date = { 0, }; 178 179 /* year-2038 will overflow in case time_t is 32bit */ 180 if (time_ns / 1000000000 != (time_t)(time_ns / 1000000000)) { 181 error_setg(errp, "Time %" PRId64 " is too large", time_ns); 182 return; 183 } 184 185 tv.tv_sec = time_ns / 1000000000; 186 tv.tv_usec = (time_ns % 1000000000) / 1000; 187 g_date_set_time_t(&date, tv.tv_sec); 188 if (date.year < 1970 || date.year >= 2070) { 189 error_setg_errno(errp, errno, "Invalid time"); 190 return; 191 } 192 193 ret = settimeofday(&tv, NULL); 194 if (ret < 0) { 195 error_setg_errno(errp, errno, "Failed to set time to guest"); 196 return; 197 } 198 } 199 200 /* Now, if user has passed a time to set and the system time is set, we 201 * just need to synchronize the hardware clock. However, if no time was 202 * passed, user is requesting the opposite: set the system time from the 203 * hardware clock (RTC). */ 204 pid = fork(); 205 if (pid == 0) { 206 setsid(); 207 reopen_fd_to_null(0); 208 reopen_fd_to_null(1); 209 reopen_fd_to_null(2); 210 211 /* Use '/sbin/hwclock -w' to set RTC from the system time, 212 * or '/sbin/hwclock -s' to set the system time from RTC. */ 213 execl(hwclock_path, "hwclock", has_time ? "-w" : "-s", NULL); 214 _exit(EXIT_FAILURE); 215 } else if (pid < 0) { 216 error_setg_errno(errp, errno, "failed to create child process"); 217 return; 218 } 219 220 ga_wait_child(pid, &status, &local_err); 221 if (local_err) { 222 error_propagate(errp, local_err); 223 return; 224 } 225 226 if (!WIFEXITED(status)) { 227 error_setg(errp, "child process has terminated abnormally"); 228 return; 229 } 230 231 if (WEXITSTATUS(status)) { 232 error_setg(errp, "hwclock failed to set hardware clock to system time"); 233 return; 234 } 235 } 236 237 typedef enum { 238 RW_STATE_NEW, 239 RW_STATE_READING, 240 RW_STATE_WRITING, 241 } RwState; 242 243 struct GuestFileHandle { 244 uint64_t id; 245 FILE *fh; 246 RwState state; 247 QTAILQ_ENTRY(GuestFileHandle) next; 248 }; 249 250 static struct { 251 QTAILQ_HEAD(, GuestFileHandle) filehandles; 252 } guest_file_state = { 253 .filehandles = QTAILQ_HEAD_INITIALIZER(guest_file_state.filehandles), 254 }; 255 256 static int64_t guest_file_handle_add(FILE *fh, Error **errp) 257 { 258 GuestFileHandle *gfh; 259 int64_t handle; 260 261 handle = ga_get_fd_handle(ga_state, errp); 262 if (handle < 0) { 263 return -1; 264 } 265 266 gfh = g_new0(GuestFileHandle, 1); 267 gfh->id = handle; 268 gfh->fh = fh; 269 QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next); 270 271 return handle; 272 } 273 274 GuestFileHandle *guest_file_handle_find(int64_t id, Error **errp) 275 { 276 GuestFileHandle *gfh; 277 278 QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next) 279 { 280 if (gfh->id == id) { 281 return gfh; 282 } 283 } 284 285 error_setg(errp, "handle '%" PRId64 "' has not been found", id); 286 return NULL; 287 } 288 289 typedef const char * const ccpc; 290 291 #ifndef O_BINARY 292 #define O_BINARY 0 293 #endif 294 295 /* http://pubs.opengroup.org/onlinepubs/9699919799/functions/fopen.html */ 296 static const struct { 297 ccpc *forms; 298 int oflag_base; 299 } guest_file_open_modes[] = { 300 { (ccpc[]){ "r", NULL }, O_RDONLY }, 301 { (ccpc[]){ "rb", NULL }, O_RDONLY | O_BINARY }, 302 { (ccpc[]){ "w", NULL }, O_WRONLY | O_CREAT | O_TRUNC }, 303 { (ccpc[]){ "wb", NULL }, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY }, 304 { (ccpc[]){ "a", NULL }, O_WRONLY | O_CREAT | O_APPEND }, 305 { (ccpc[]){ "ab", NULL }, O_WRONLY | O_CREAT | O_APPEND | O_BINARY }, 306 { (ccpc[]){ "r+", NULL }, O_RDWR }, 307 { (ccpc[]){ "rb+", "r+b", NULL }, O_RDWR | O_BINARY }, 308 { (ccpc[]){ "w+", NULL }, O_RDWR | O_CREAT | O_TRUNC }, 309 { (ccpc[]){ "wb+", "w+b", NULL }, O_RDWR | O_CREAT | O_TRUNC | O_BINARY }, 310 { (ccpc[]){ "a+", NULL }, O_RDWR | O_CREAT | O_APPEND }, 311 { (ccpc[]){ "ab+", "a+b", NULL }, O_RDWR | O_CREAT | O_APPEND | O_BINARY } 312 }; 313 314 static int 315 find_open_flag(const char *mode_str, Error **errp) 316 { 317 unsigned mode; 318 319 for (mode = 0; mode < ARRAY_SIZE(guest_file_open_modes); ++mode) { 320 ccpc *form; 321 322 form = guest_file_open_modes[mode].forms; 323 while (*form != NULL && strcmp(*form, mode_str) != 0) { 324 ++form; 325 } 326 if (*form != NULL) { 327 break; 328 } 329 } 330 331 if (mode == ARRAY_SIZE(guest_file_open_modes)) { 332 error_setg(errp, "invalid file open mode '%s'", mode_str); 333 return -1; 334 } 335 return guest_file_open_modes[mode].oflag_base | O_NOCTTY | O_NONBLOCK; 336 } 337 338 #define DEFAULT_NEW_FILE_MODE (S_IRUSR | S_IWUSR | \ 339 S_IRGRP | S_IWGRP | \ 340 S_IROTH | S_IWOTH) 341 342 static FILE * 343 safe_open_or_create(const char *path, const char *mode, Error **errp) 344 { 345 int oflag; 346 int fd = -1; 347 FILE *f = NULL; 348 349 oflag = find_open_flag(mode, errp); 350 if (oflag < 0) { 351 goto end; 352 } 353 354 /* If the caller wants / allows creation of a new file, we implement it 355 * with a two step process: open() + (open() / fchmod()). 356 * 357 * First we insist on creating the file exclusively as a new file. If 358 * that succeeds, we're free to set any file-mode bits on it. (The 359 * motivation is that we want to set those file-mode bits independently 360 * of the current umask.) 361 * 362 * If the exclusive creation fails because the file already exists 363 * (EEXIST is not possible for any other reason), we just attempt to 364 * open the file, but in this case we won't be allowed to change the 365 * file-mode bits on the preexistent file. 366 * 367 * The pathname should never disappear between the two open()s in 368 * practice. If it happens, then someone very likely tried to race us. 369 * In this case just go ahead and report the ENOENT from the second 370 * open() to the caller. 371 * 372 * If the caller wants to open a preexistent file, then the first 373 * open() is decisive and its third argument is ignored, and the second 374 * open() and the fchmod() are never called. 375 */ 376 fd = qga_open_cloexec(path, oflag | ((oflag & O_CREAT) ? O_EXCL : 0), 0); 377 if (fd == -1 && errno == EEXIST) { 378 oflag &= ~(unsigned)O_CREAT; 379 fd = qga_open_cloexec(path, oflag, 0); 380 } 381 if (fd == -1) { 382 error_setg_errno(errp, errno, 383 "failed to open file '%s' (mode: '%s')", 384 path, mode); 385 goto end; 386 } 387 388 if ((oflag & O_CREAT) && fchmod(fd, DEFAULT_NEW_FILE_MODE) == -1) { 389 error_setg_errno(errp, errno, "failed to set permission " 390 "0%03o on new file '%s' (mode: '%s')", 391 (unsigned)DEFAULT_NEW_FILE_MODE, path, mode); 392 goto end; 393 } 394 395 f = fdopen(fd, mode); 396 if (f == NULL) { 397 error_setg_errno(errp, errno, "failed to associate stdio stream with " 398 "file descriptor %d, file '%s' (mode: '%s')", 399 fd, path, mode); 400 } 401 402 end: 403 if (f == NULL && fd != -1) { 404 close(fd); 405 if (oflag & O_CREAT) { 406 unlink(path); 407 } 408 } 409 return f; 410 } 411 412 int64_t qmp_guest_file_open(const char *path, const char *mode, 413 Error **errp) 414 { 415 FILE *fh; 416 Error *local_err = NULL; 417 int64_t handle; 418 419 if (!mode) { 420 mode = "r"; 421 } 422 slog("guest-file-open called, filepath: %s, mode: %s", path, mode); 423 fh = safe_open_or_create(path, mode, &local_err); 424 if (local_err != NULL) { 425 error_propagate(errp, local_err); 426 return -1; 427 } 428 429 /* set fd non-blocking to avoid common use cases (like reading from a 430 * named pipe) from hanging the agent 431 */ 432 if (!g_unix_set_fd_nonblocking(fileno(fh), true, NULL)) { 433 fclose(fh); 434 error_setg_errno(errp, errno, "Failed to set FD nonblocking"); 435 return -1; 436 } 437 438 handle = guest_file_handle_add(fh, errp); 439 if (handle < 0) { 440 fclose(fh); 441 return -1; 442 } 443 444 slog("guest-file-open, handle: %" PRId64, handle); 445 return handle; 446 } 447 448 void qmp_guest_file_close(int64_t handle, Error **errp) 449 { 450 GuestFileHandle *gfh = guest_file_handle_find(handle, errp); 451 int ret; 452 453 slog("guest-file-close called, handle: %" PRId64, handle); 454 if (!gfh) { 455 return; 456 } 457 458 ret = fclose(gfh->fh); 459 if (ret == EOF) { 460 error_setg_errno(errp, errno, "failed to close handle"); 461 return; 462 } 463 464 QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next); 465 g_free(gfh); 466 } 467 468 GuestFileRead *guest_file_read_unsafe(GuestFileHandle *gfh, 469 int64_t count, Error **errp) 470 { 471 GuestFileRead *read_data = NULL; 472 guchar *buf; 473 FILE *fh = gfh->fh; 474 size_t read_count; 475 476 /* explicitly flush when switching from writing to reading */ 477 if (gfh->state == RW_STATE_WRITING) { 478 int ret = fflush(fh); 479 if (ret == EOF) { 480 error_setg_errno(errp, errno, "failed to flush file"); 481 return NULL; 482 } 483 gfh->state = RW_STATE_NEW; 484 } 485 486 buf = g_malloc0(count + 1); 487 read_count = fread(buf, 1, count, fh); 488 if (ferror(fh)) { 489 error_setg_errno(errp, errno, "failed to read file"); 490 } else { 491 buf[read_count] = 0; 492 read_data = g_new0(GuestFileRead, 1); 493 read_data->count = read_count; 494 read_data->eof = feof(fh); 495 if (read_count) { 496 read_data->buf_b64 = g_base64_encode(buf, read_count); 497 } 498 gfh->state = RW_STATE_READING; 499 } 500 g_free(buf); 501 clearerr(fh); 502 503 return read_data; 504 } 505 506 GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64, 507 bool has_count, int64_t count, 508 Error **errp) 509 { 510 GuestFileWrite *write_data = NULL; 511 guchar *buf; 512 gsize buf_len; 513 int write_count; 514 GuestFileHandle *gfh = guest_file_handle_find(handle, errp); 515 FILE *fh; 516 517 if (!gfh) { 518 return NULL; 519 } 520 521 fh = gfh->fh; 522 523 if (gfh->state == RW_STATE_READING) { 524 int ret = fseek(fh, 0, SEEK_CUR); 525 if (ret == -1) { 526 error_setg_errno(errp, errno, "failed to seek file"); 527 return NULL; 528 } 529 gfh->state = RW_STATE_NEW; 530 } 531 532 buf = qbase64_decode(buf_b64, -1, &buf_len, errp); 533 if (!buf) { 534 return NULL; 535 } 536 537 if (!has_count) { 538 count = buf_len; 539 } else if (count < 0 || count > buf_len) { 540 error_setg(errp, "value '%" PRId64 "' is invalid for argument count", 541 count); 542 g_free(buf); 543 return NULL; 544 } 545 546 write_count = fwrite(buf, 1, count, fh); 547 if (ferror(fh)) { 548 error_setg_errno(errp, errno, "failed to write to file"); 549 slog("guest-file-write failed, handle: %" PRId64, handle); 550 } else { 551 write_data = g_new0(GuestFileWrite, 1); 552 write_data->count = write_count; 553 write_data->eof = feof(fh); 554 gfh->state = RW_STATE_WRITING; 555 } 556 g_free(buf); 557 clearerr(fh); 558 559 return write_data; 560 } 561 562 struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset, 563 GuestFileWhence *whence_code, 564 Error **errp) 565 { 566 GuestFileHandle *gfh = guest_file_handle_find(handle, errp); 567 GuestFileSeek *seek_data = NULL; 568 FILE *fh; 569 int ret; 570 int whence; 571 Error *err = NULL; 572 573 if (!gfh) { 574 return NULL; 575 } 576 577 /* We stupidly exposed 'whence':'int' in our qapi */ 578 whence = ga_parse_whence(whence_code, &err); 579 if (err) { 580 error_propagate(errp, err); 581 return NULL; 582 } 583 584 fh = gfh->fh; 585 ret = fseek(fh, offset, whence); 586 if (ret == -1) { 587 error_setg_errno(errp, errno, "failed to seek file"); 588 if (errno == ESPIPE) { 589 /* file is non-seekable, stdio shouldn't be buffering anyways */ 590 gfh->state = RW_STATE_NEW; 591 } 592 } else { 593 seek_data = g_new0(GuestFileSeek, 1); 594 seek_data->position = ftell(fh); 595 seek_data->eof = feof(fh); 596 gfh->state = RW_STATE_NEW; 597 } 598 clearerr(fh); 599 600 return seek_data; 601 } 602 603 void qmp_guest_file_flush(int64_t handle, Error **errp) 604 { 605 GuestFileHandle *gfh = guest_file_handle_find(handle, errp); 606 FILE *fh; 607 int ret; 608 609 if (!gfh) { 610 return; 611 } 612 613 fh = gfh->fh; 614 ret = fflush(fh); 615 if (ret == EOF) { 616 error_setg_errno(errp, errno, "failed to flush file"); 617 } else { 618 gfh->state = RW_STATE_NEW; 619 } 620 } 621 622 #if defined(CONFIG_FSFREEZE) || defined(CONFIG_FSTRIM) 623 void free_fs_mount_list(FsMountList *mounts) 624 { 625 FsMount *mount, *temp; 626 627 if (!mounts) { 628 return; 629 } 630 631 QTAILQ_FOREACH_SAFE(mount, mounts, next, temp) { 632 QTAILQ_REMOVE(mounts, mount, next); 633 g_free(mount->dirname); 634 g_free(mount->devtype); 635 g_free(mount); 636 } 637 } 638 #endif 639 640 #if defined(CONFIG_FSFREEZE) 641 typedef enum { 642 FSFREEZE_HOOK_THAW = 0, 643 FSFREEZE_HOOK_FREEZE, 644 } FsfreezeHookArg; 645 646 static const char *fsfreeze_hook_arg_string[] = { 647 "thaw", 648 "freeze", 649 }; 650 651 static void execute_fsfreeze_hook(FsfreezeHookArg arg, Error **errp) 652 { 653 int status; 654 pid_t pid; 655 const char *hook; 656 const char *arg_str = fsfreeze_hook_arg_string[arg]; 657 Error *local_err = NULL; 658 659 hook = ga_fsfreeze_hook(ga_state); 660 if (!hook) { 661 return; 662 } 663 if (access(hook, X_OK) != 0) { 664 error_setg_errno(errp, errno, "can't access fsfreeze hook '%s'", hook); 665 return; 666 } 667 668 slog("executing fsfreeze hook with arg '%s'", arg_str); 669 pid = fork(); 670 if (pid == 0) { 671 setsid(); 672 reopen_fd_to_null(0); 673 reopen_fd_to_null(1); 674 reopen_fd_to_null(2); 675 676 execl(hook, hook, arg_str, NULL); 677 _exit(EXIT_FAILURE); 678 } else if (pid < 0) { 679 error_setg_errno(errp, errno, "failed to create child process"); 680 return; 681 } 682 683 ga_wait_child(pid, &status, &local_err); 684 if (local_err) { 685 error_propagate(errp, local_err); 686 return; 687 } 688 689 if (!WIFEXITED(status)) { 690 error_setg(errp, "fsfreeze hook has terminated abnormally"); 691 return; 692 } 693 694 status = WEXITSTATUS(status); 695 if (status) { 696 error_setg(errp, "fsfreeze hook has failed with status %d", status); 697 return; 698 } 699 } 700 701 /* 702 * Return status of freeze/thaw 703 */ 704 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **errp) 705 { 706 if (ga_is_frozen(ga_state)) { 707 return GUEST_FSFREEZE_STATUS_FROZEN; 708 } 709 710 return GUEST_FSFREEZE_STATUS_THAWED; 711 } 712 713 int64_t qmp_guest_fsfreeze_freeze(Error **errp) 714 { 715 return qmp_guest_fsfreeze_freeze_list(false, NULL, errp); 716 } 717 718 int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints, 719 strList *mountpoints, 720 Error **errp) 721 { 722 int ret; 723 FsMountList mounts; 724 Error *local_err = NULL; 725 726 slog("guest-fsfreeze called"); 727 728 execute_fsfreeze_hook(FSFREEZE_HOOK_FREEZE, &local_err); 729 if (local_err) { 730 error_propagate(errp, local_err); 731 return -1; 732 } 733 734 QTAILQ_INIT(&mounts); 735 if (!build_fs_mount_list(&mounts, &local_err)) { 736 error_propagate(errp, local_err); 737 return -1; 738 } 739 740 /* cannot risk guest agent blocking itself on a write in this state */ 741 ga_set_frozen(ga_state); 742 743 ret = qmp_guest_fsfreeze_do_freeze_list(has_mountpoints, mountpoints, 744 mounts, errp); 745 746 free_fs_mount_list(&mounts); 747 /* We may not issue any FIFREEZE here. 748 * Just unset ga_state here and ready for the next call. 749 */ 750 if (ret == 0) { 751 ga_unset_frozen(ga_state); 752 } else if (ret < 0) { 753 qmp_guest_fsfreeze_thaw(NULL); 754 } 755 return ret; 756 } 757 758 int64_t qmp_guest_fsfreeze_thaw(Error **errp) 759 { 760 int ret; 761 762 ret = qmp_guest_fsfreeze_do_thaw(errp); 763 if (ret >= 0) { 764 ga_unset_frozen(ga_state); 765 execute_fsfreeze_hook(FSFREEZE_HOOK_THAW, errp); 766 } else { 767 ret = 0; 768 } 769 770 return ret; 771 } 772 773 static void guest_fsfreeze_cleanup(void) 774 { 775 Error *err = NULL; 776 777 if (ga_is_frozen(ga_state) == GUEST_FSFREEZE_STATUS_FROZEN) { 778 qmp_guest_fsfreeze_thaw(&err); 779 if (err) { 780 slog("failed to clean up frozen filesystems: %s", 781 error_get_pretty(err)); 782 error_free(err); 783 } 784 } 785 } 786 #endif 787 788 /* linux-specific implementations. avoid this if at all possible. */ 789 #if defined(__linux__) 790 #if defined(CONFIG_FSFREEZE) 791 792 static char *get_pci_driver(char const *syspath, int pathlen, Error **errp) 793 { 794 char *path; 795 char *dpath; 796 char *driver = NULL; 797 char buf[PATH_MAX]; 798 ssize_t len; 799 800 path = g_strndup(syspath, pathlen); 801 dpath = g_strdup_printf("%s/driver", path); 802 len = readlink(dpath, buf, sizeof(buf) - 1); 803 if (len != -1) { 804 buf[len] = 0; 805 driver = g_path_get_basename(buf); 806 } 807 g_free(dpath); 808 g_free(path); 809 return driver; 810 } 811 812 static int compare_uint(const void *_a, const void *_b) 813 { 814 unsigned int a = *(unsigned int *)_a; 815 unsigned int b = *(unsigned int *)_b; 816 817 return a < b ? -1 : a > b ? 1 : 0; 818 } 819 820 /* Walk the specified sysfs and build a sorted list of host or ata numbers */ 821 static int build_hosts(char const *syspath, char const *host, bool ata, 822 unsigned int *hosts, int hosts_max, Error **errp) 823 { 824 char *path; 825 DIR *dir; 826 struct dirent *entry; 827 int i = 0; 828 829 path = g_strndup(syspath, host - syspath); 830 dir = opendir(path); 831 if (!dir) { 832 error_setg_errno(errp, errno, "opendir(\"%s\")", path); 833 g_free(path); 834 return -1; 835 } 836 837 while (i < hosts_max) { 838 entry = readdir(dir); 839 if (!entry) { 840 break; 841 } 842 if (ata && sscanf(entry->d_name, "ata%d", hosts + i) == 1) { 843 ++i; 844 } else if (!ata && sscanf(entry->d_name, "host%d", hosts + i) == 1) { 845 ++i; 846 } 847 } 848 849 qsort(hosts, i, sizeof(hosts[0]), compare_uint); 850 851 g_free(path); 852 closedir(dir); 853 return i; 854 } 855 856 /* 857 * Store disk device info for devices on the PCI bus. 858 * Returns true if information has been stored, or false for failure. 859 */ 860 static bool build_guest_fsinfo_for_pci_dev(char const *syspath, 861 GuestDiskAddress *disk, 862 Error **errp) 863 { 864 unsigned int pci[4], host, hosts[8], tgt[3]; 865 int i, nhosts = 0, pcilen; 866 GuestPCIAddress *pciaddr = disk->pci_controller; 867 bool has_ata = false, has_host = false, has_tgt = false; 868 char *p, *q, *driver = NULL; 869 bool ret = false; 870 871 p = strstr(syspath, "/devices/pci"); 872 if (!p || sscanf(p + 12, "%*x:%*x/%x:%x:%x.%x%n", 873 pci, pci + 1, pci + 2, pci + 3, &pcilen) < 4) { 874 g_debug("only pci device is supported: sysfs path '%s'", syspath); 875 return false; 876 } 877 878 p += 12 + pcilen; 879 while (true) { 880 driver = get_pci_driver(syspath, p - syspath, errp); 881 if (driver && (g_str_equal(driver, "ata_piix") || 882 g_str_equal(driver, "sym53c8xx") || 883 g_str_equal(driver, "virtio-pci") || 884 g_str_equal(driver, "ahci") || 885 g_str_equal(driver, "nvme") || 886 g_str_equal(driver, "xhci_hcd") || 887 g_str_equal(driver, "ehci-pci"))) { 888 break; 889 } 890 891 g_free(driver); 892 if (sscanf(p, "/%x:%x:%x.%x%n", 893 pci, pci + 1, pci + 2, pci + 3, &pcilen) == 4) { 894 p += pcilen; 895 continue; 896 } 897 898 g_debug("unsupported driver or sysfs path '%s'", syspath); 899 return false; 900 } 901 902 p = strstr(syspath, "/target"); 903 if (p && sscanf(p + 7, "%*u:%*u:%*u/%*u:%u:%u:%u", 904 tgt, tgt + 1, tgt + 2) == 3) { 905 has_tgt = true; 906 } 907 908 p = strstr(syspath, "/ata"); 909 if (p) { 910 q = p + 4; 911 has_ata = true; 912 } else { 913 p = strstr(syspath, "/host"); 914 q = p + 5; 915 } 916 if (p && sscanf(q, "%u", &host) == 1) { 917 has_host = true; 918 nhosts = build_hosts(syspath, p, has_ata, hosts, 919 ARRAY_SIZE(hosts), errp); 920 if (nhosts < 0) { 921 goto cleanup; 922 } 923 } 924 925 pciaddr->domain = pci[0]; 926 pciaddr->bus = pci[1]; 927 pciaddr->slot = pci[2]; 928 pciaddr->function = pci[3]; 929 930 if (strcmp(driver, "ata_piix") == 0) { 931 /* a host per ide bus, target*:0:<unit>:0 */ 932 if (!has_host || !has_tgt) { 933 g_debug("invalid sysfs path '%s' (driver '%s')", syspath, driver); 934 goto cleanup; 935 } 936 for (i = 0; i < nhosts; i++) { 937 if (host == hosts[i]) { 938 disk->bus_type = GUEST_DISK_BUS_TYPE_IDE; 939 disk->bus = i; 940 disk->unit = tgt[1]; 941 break; 942 } 943 } 944 if (i >= nhosts) { 945 g_debug("no host for '%s' (driver '%s')", syspath, driver); 946 goto cleanup; 947 } 948 } else if (strcmp(driver, "sym53c8xx") == 0) { 949 /* scsi(LSI Logic): target*:0:<unit>:0 */ 950 if (!has_tgt) { 951 g_debug("invalid sysfs path '%s' (driver '%s')", syspath, driver); 952 goto cleanup; 953 } 954 disk->bus_type = GUEST_DISK_BUS_TYPE_SCSI; 955 disk->unit = tgt[1]; 956 } else if (strcmp(driver, "virtio-pci") == 0) { 957 if (has_tgt) { 958 /* virtio-scsi: target*:0:0:<unit> */ 959 disk->bus_type = GUEST_DISK_BUS_TYPE_SCSI; 960 disk->unit = tgt[2]; 961 } else { 962 /* virtio-blk: 1 disk per 1 device */ 963 disk->bus_type = GUEST_DISK_BUS_TYPE_VIRTIO; 964 } 965 } else if (strcmp(driver, "ahci") == 0) { 966 /* ahci: 1 host per 1 unit */ 967 if (!has_host || !has_tgt) { 968 g_debug("invalid sysfs path '%s' (driver '%s')", syspath, driver); 969 goto cleanup; 970 } 971 for (i = 0; i < nhosts; i++) { 972 if (host == hosts[i]) { 973 disk->unit = i; 974 disk->bus_type = GUEST_DISK_BUS_TYPE_SATA; 975 break; 976 } 977 } 978 if (i >= nhosts) { 979 g_debug("no host for '%s' (driver '%s')", syspath, driver); 980 goto cleanup; 981 } 982 } else if (strcmp(driver, "nvme") == 0) { 983 disk->bus_type = GUEST_DISK_BUS_TYPE_NVME; 984 } else if (strcmp(driver, "ehci-pci") == 0 || strcmp(driver, "xhci_hcd") == 0) { 985 disk->bus_type = GUEST_DISK_BUS_TYPE_USB; 986 } else { 987 g_debug("unknown driver '%s' (sysfs path '%s')", driver, syspath); 988 goto cleanup; 989 } 990 991 ret = true; 992 993 cleanup: 994 g_free(driver); 995 return ret; 996 } 997 998 /* 999 * Store disk device info for non-PCI virtio devices (for example s390x 1000 * channel I/O devices). Returns true if information has been stored, or 1001 * false for failure. 1002 */ 1003 static bool build_guest_fsinfo_for_nonpci_virtio(char const *syspath, 1004 GuestDiskAddress *disk, 1005 Error **errp) 1006 { 1007 unsigned int tgt[3]; 1008 char *p; 1009 1010 if (!strstr(syspath, "/virtio") || !strstr(syspath, "/block")) { 1011 g_debug("Unsupported virtio device '%s'", syspath); 1012 return false; 1013 } 1014 1015 p = strstr(syspath, "/target"); 1016 if (p && sscanf(p + 7, "%*u:%*u:%*u/%*u:%u:%u:%u", 1017 &tgt[0], &tgt[1], &tgt[2]) == 3) { 1018 /* virtio-scsi: target*:0:<target>:<unit> */ 1019 disk->bus_type = GUEST_DISK_BUS_TYPE_SCSI; 1020 disk->bus = tgt[0]; 1021 disk->target = tgt[1]; 1022 disk->unit = tgt[2]; 1023 } else { 1024 /* virtio-blk: 1 disk per 1 device */ 1025 disk->bus_type = GUEST_DISK_BUS_TYPE_VIRTIO; 1026 } 1027 1028 return true; 1029 } 1030 1031 /* 1032 * Store disk device info for CCW devices (s390x channel I/O devices). 1033 * Returns true if information has been stored, or false for failure. 1034 */ 1035 static bool build_guest_fsinfo_for_ccw_dev(char const *syspath, 1036 GuestDiskAddress *disk, 1037 Error **errp) 1038 { 1039 unsigned int cssid, ssid, subchno, devno; 1040 char *p; 1041 1042 p = strstr(syspath, "/devices/css"); 1043 if (!p || sscanf(p + 12, "%*x/%x.%x.%x/%*x.%*x.%x/", 1044 &cssid, &ssid, &subchno, &devno) < 4) { 1045 g_debug("could not parse ccw device sysfs path: %s", syspath); 1046 return false; 1047 } 1048 1049 disk->ccw_address = g_new0(GuestCCWAddress, 1); 1050 disk->ccw_address->cssid = cssid; 1051 disk->ccw_address->ssid = ssid; 1052 disk->ccw_address->subchno = subchno; 1053 disk->ccw_address->devno = devno; 1054 1055 if (strstr(p, "/virtio")) { 1056 build_guest_fsinfo_for_nonpci_virtio(syspath, disk, errp); 1057 } 1058 1059 return true; 1060 } 1061 1062 /* Store disk device info specified by @sysfs into @fs */ 1063 static void build_guest_fsinfo_for_real_device(char const *syspath, 1064 GuestFilesystemInfo *fs, 1065 Error **errp) 1066 { 1067 GuestDiskAddress *disk; 1068 GuestPCIAddress *pciaddr; 1069 bool has_hwinf; 1070 #ifdef CONFIG_LIBUDEV 1071 struct udev *udev = NULL; 1072 struct udev_device *udevice = NULL; 1073 #endif 1074 1075 pciaddr = g_new0(GuestPCIAddress, 1); 1076 pciaddr->domain = -1; /* -1 means field is invalid */ 1077 pciaddr->bus = -1; 1078 pciaddr->slot = -1; 1079 pciaddr->function = -1; 1080 1081 disk = g_new0(GuestDiskAddress, 1); 1082 disk->pci_controller = pciaddr; 1083 disk->bus_type = GUEST_DISK_BUS_TYPE_UNKNOWN; 1084 1085 #ifdef CONFIG_LIBUDEV 1086 udev = udev_new(); 1087 udevice = udev_device_new_from_syspath(udev, syspath); 1088 if (udev == NULL || udevice == NULL) { 1089 g_debug("failed to query udev"); 1090 } else { 1091 const char *devnode, *serial; 1092 devnode = udev_device_get_devnode(udevice); 1093 if (devnode != NULL) { 1094 disk->dev = g_strdup(devnode); 1095 } 1096 serial = udev_device_get_property_value(udevice, "ID_SERIAL"); 1097 if (serial != NULL && *serial != 0) { 1098 disk->serial = g_strdup(serial); 1099 } 1100 } 1101 1102 udev_unref(udev); 1103 udev_device_unref(udevice); 1104 #endif 1105 1106 if (strstr(syspath, "/devices/pci")) { 1107 has_hwinf = build_guest_fsinfo_for_pci_dev(syspath, disk, errp); 1108 } else if (strstr(syspath, "/devices/css")) { 1109 has_hwinf = build_guest_fsinfo_for_ccw_dev(syspath, disk, errp); 1110 } else if (strstr(syspath, "/virtio")) { 1111 has_hwinf = build_guest_fsinfo_for_nonpci_virtio(syspath, disk, errp); 1112 } else { 1113 g_debug("Unsupported device type for '%s'", syspath); 1114 has_hwinf = false; 1115 } 1116 1117 if (has_hwinf || disk->dev || disk->serial) { 1118 QAPI_LIST_PREPEND(fs->disk, disk); 1119 } else { 1120 qapi_free_GuestDiskAddress(disk); 1121 } 1122 } 1123 1124 static void build_guest_fsinfo_for_device(char const *devpath, 1125 GuestFilesystemInfo *fs, 1126 Error **errp); 1127 1128 /* Store a list of slave devices of virtual volume specified by @syspath into 1129 * @fs */ 1130 static void build_guest_fsinfo_for_virtual_device(char const *syspath, 1131 GuestFilesystemInfo *fs, 1132 Error **errp) 1133 { 1134 Error *err = NULL; 1135 DIR *dir; 1136 char *dirpath; 1137 struct dirent *entry; 1138 1139 dirpath = g_strdup_printf("%s/slaves", syspath); 1140 dir = opendir(dirpath); 1141 if (!dir) { 1142 if (errno != ENOENT) { 1143 error_setg_errno(errp, errno, "opendir(\"%s\")", dirpath); 1144 } 1145 g_free(dirpath); 1146 return; 1147 } 1148 1149 for (;;) { 1150 errno = 0; 1151 entry = readdir(dir); 1152 if (entry == NULL) { 1153 if (errno) { 1154 error_setg_errno(errp, errno, "readdir(\"%s\")", dirpath); 1155 } 1156 break; 1157 } 1158 1159 if (entry->d_type == DT_LNK) { 1160 char *path; 1161 1162 g_debug(" slave device '%s'", entry->d_name); 1163 path = g_strdup_printf("%s/slaves/%s", syspath, entry->d_name); 1164 build_guest_fsinfo_for_device(path, fs, &err); 1165 g_free(path); 1166 1167 if (err) { 1168 error_propagate(errp, err); 1169 break; 1170 } 1171 } 1172 } 1173 1174 g_free(dirpath); 1175 closedir(dir); 1176 } 1177 1178 static bool is_disk_virtual(const char *devpath, Error **errp) 1179 { 1180 g_autofree char *syspath = realpath(devpath, NULL); 1181 1182 if (!syspath) { 1183 error_setg_errno(errp, errno, "realpath(\"%s\")", devpath); 1184 return false; 1185 } 1186 return strstr(syspath, "/devices/virtual/block/") != NULL; 1187 } 1188 1189 /* Dispatch to functions for virtual/real device */ 1190 static void build_guest_fsinfo_for_device(char const *devpath, 1191 GuestFilesystemInfo *fs, 1192 Error **errp) 1193 { 1194 ERRP_GUARD(); 1195 g_autofree char *syspath = NULL; 1196 bool is_virtual = false; 1197 1198 syspath = realpath(devpath, NULL); 1199 if (!syspath) { 1200 if (errno != ENOENT) { 1201 error_setg_errno(errp, errno, "realpath(\"%s\")", devpath); 1202 return; 1203 } 1204 1205 /* ENOENT: This devpath may not exist because of container config */ 1206 if (!fs->name) { 1207 fs->name = g_path_get_basename(devpath); 1208 } 1209 return; 1210 } 1211 1212 if (!fs->name) { 1213 fs->name = g_path_get_basename(syspath); 1214 } 1215 1216 g_debug(" parse sysfs path '%s'", syspath); 1217 is_virtual = is_disk_virtual(syspath, errp); 1218 if (*errp != NULL) { 1219 return; 1220 } 1221 if (is_virtual) { 1222 build_guest_fsinfo_for_virtual_device(syspath, fs, errp); 1223 } else { 1224 build_guest_fsinfo_for_real_device(syspath, fs, errp); 1225 } 1226 } 1227 1228 #ifdef CONFIG_LIBUDEV 1229 1230 /* 1231 * Wrapper around build_guest_fsinfo_for_device() for getting just 1232 * the disk address. 1233 */ 1234 static GuestDiskAddress *get_disk_address(const char *syspath, Error **errp) 1235 { 1236 g_autoptr(GuestFilesystemInfo) fs = NULL; 1237 1238 fs = g_new0(GuestFilesystemInfo, 1); 1239 build_guest_fsinfo_for_device(syspath, fs, errp); 1240 if (fs->disk != NULL) { 1241 return g_steal_pointer(&fs->disk->value); 1242 } 1243 return NULL; 1244 } 1245 1246 static char *get_alias_for_syspath(const char *syspath) 1247 { 1248 struct udev *udev = NULL; 1249 struct udev_device *udevice = NULL; 1250 char *ret = NULL; 1251 1252 udev = udev_new(); 1253 if (udev == NULL) { 1254 g_debug("failed to query udev"); 1255 goto out; 1256 } 1257 udevice = udev_device_new_from_syspath(udev, syspath); 1258 if (udevice == NULL) { 1259 g_debug("failed to query udev for path: %s", syspath); 1260 goto out; 1261 } else { 1262 const char *alias = udev_device_get_property_value( 1263 udevice, "DM_NAME"); 1264 /* 1265 * NULL means there was an error and empty string means there is no 1266 * alias. In case of no alias we return NULL instead of empty string. 1267 */ 1268 if (alias == NULL) { 1269 g_debug("failed to query udev for device alias for: %s", 1270 syspath); 1271 } else if (*alias != 0) { 1272 ret = g_strdup(alias); 1273 } 1274 } 1275 1276 out: 1277 udev_unref(udev); 1278 udev_device_unref(udevice); 1279 return ret; 1280 } 1281 1282 static char *get_device_for_syspath(const char *syspath) 1283 { 1284 struct udev *udev = NULL; 1285 struct udev_device *udevice = NULL; 1286 char *ret = NULL; 1287 1288 udev = udev_new(); 1289 if (udev == NULL) { 1290 g_debug("failed to query udev"); 1291 goto out; 1292 } 1293 udevice = udev_device_new_from_syspath(udev, syspath); 1294 if (udevice == NULL) { 1295 g_debug("failed to query udev for path: %s", syspath); 1296 goto out; 1297 } else { 1298 ret = g_strdup(udev_device_get_devnode(udevice)); 1299 } 1300 1301 out: 1302 udev_unref(udev); 1303 udev_device_unref(udevice); 1304 return ret; 1305 } 1306 1307 static void get_disk_deps(const char *disk_dir, GuestDiskInfo *disk) 1308 { 1309 g_autofree char *deps_dir = NULL; 1310 const gchar *dep; 1311 GDir *dp_deps = NULL; 1312 1313 /* List dependent disks */ 1314 deps_dir = g_strdup_printf("%s/slaves", disk_dir); 1315 g_debug(" listing entries in: %s", deps_dir); 1316 dp_deps = g_dir_open(deps_dir, 0, NULL); 1317 if (dp_deps == NULL) { 1318 g_debug("failed to list entries in %s", deps_dir); 1319 return; 1320 } 1321 disk->has_dependencies = true; 1322 while ((dep = g_dir_read_name(dp_deps)) != NULL) { 1323 g_autofree char *dep_dir = NULL; 1324 char *dev_name; 1325 1326 /* Add dependent disks */ 1327 dep_dir = g_strdup_printf("%s/%s", deps_dir, dep); 1328 dev_name = get_device_for_syspath(dep_dir); 1329 if (dev_name != NULL) { 1330 g_debug(" adding dependent device: %s", dev_name); 1331 QAPI_LIST_PREPEND(disk->dependencies, dev_name); 1332 } 1333 } 1334 g_dir_close(dp_deps); 1335 } 1336 1337 /* 1338 * Detect partitions subdirectory, name is "<disk_name><number>" or 1339 * "<disk_name>p<number>" 1340 * 1341 * @disk_name -- last component of /sys path (e.g. sda) 1342 * @disk_dir -- sys path of the disk (e.g. /sys/block/sda) 1343 * @disk_dev -- device node of the disk (e.g. /dev/sda) 1344 */ 1345 static GuestDiskInfoList *get_disk_partitions( 1346 GuestDiskInfoList *list, 1347 const char *disk_name, const char *disk_dir, 1348 const char *disk_dev) 1349 { 1350 GuestDiskInfoList *ret = list; 1351 struct dirent *de_disk; 1352 DIR *dp_disk = NULL; 1353 size_t len = strlen(disk_name); 1354 1355 dp_disk = opendir(disk_dir); 1356 while ((de_disk = readdir(dp_disk)) != NULL) { 1357 g_autofree char *partition_dir = NULL; 1358 char *dev_name; 1359 GuestDiskInfo *partition; 1360 1361 if (!(de_disk->d_type & DT_DIR)) { 1362 continue; 1363 } 1364 1365 if (!(strncmp(disk_name, de_disk->d_name, len) == 0 && 1366 ((*(de_disk->d_name + len) == 'p' && 1367 isdigit(*(de_disk->d_name + len + 1))) || 1368 isdigit(*(de_disk->d_name + len))))) { 1369 continue; 1370 } 1371 1372 partition_dir = g_strdup_printf("%s/%s", 1373 disk_dir, de_disk->d_name); 1374 dev_name = get_device_for_syspath(partition_dir); 1375 if (dev_name == NULL) { 1376 g_debug("Failed to get device name for syspath: %s", 1377 disk_dir); 1378 continue; 1379 } 1380 partition = g_new0(GuestDiskInfo, 1); 1381 partition->name = dev_name; 1382 partition->partition = true; 1383 partition->has_dependencies = true; 1384 /* Add parent disk as dependent for easier tracking of hierarchy */ 1385 QAPI_LIST_PREPEND(partition->dependencies, g_strdup(disk_dev)); 1386 1387 QAPI_LIST_PREPEND(ret, partition); 1388 } 1389 closedir(dp_disk); 1390 1391 return ret; 1392 } 1393 1394 static void get_nvme_smart(GuestDiskInfo *disk) 1395 { 1396 int fd; 1397 GuestNVMeSmart *smart; 1398 NvmeSmartLog log = {0}; 1399 struct nvme_admin_cmd cmd = { 1400 .opcode = NVME_ADM_CMD_GET_LOG_PAGE, 1401 .nsid = NVME_NSID_BROADCAST, 1402 .addr = (uintptr_t)&log, 1403 .data_len = sizeof(log), 1404 .cdw10 = NVME_LOG_SMART_INFO | (1 << 15) /* RAE bit */ 1405 | (((sizeof(log) >> 2) - 1) << 16) 1406 }; 1407 1408 fd = qga_open_cloexec(disk->name, O_RDONLY, 0); 1409 if (fd == -1) { 1410 g_debug("Failed to open device: %s: %s", disk->name, g_strerror(errno)); 1411 return; 1412 } 1413 1414 if (ioctl(fd, NVME_IOCTL_ADMIN_CMD, &cmd)) { 1415 g_debug("Failed to get smart: %s: %s", disk->name, g_strerror(errno)); 1416 close(fd); 1417 return; 1418 } 1419 1420 disk->smart = g_new0(GuestDiskSmart, 1); 1421 disk->smart->type = GUEST_DISK_BUS_TYPE_NVME; 1422 1423 smart = &disk->smart->u.nvme; 1424 smart->critical_warning = log.critical_warning; 1425 smart->temperature = lduw_le_p(&log.temperature); /* unaligned field */ 1426 smart->available_spare = log.available_spare; 1427 smart->available_spare_threshold = log.available_spare_threshold; 1428 smart->percentage_used = log.percentage_used; 1429 smart->data_units_read_lo = le64_to_cpu(log.data_units_read[0]); 1430 smart->data_units_read_hi = le64_to_cpu(log.data_units_read[1]); 1431 smart->data_units_written_lo = le64_to_cpu(log.data_units_written[0]); 1432 smart->data_units_written_hi = le64_to_cpu(log.data_units_written[1]); 1433 smart->host_read_commands_lo = le64_to_cpu(log.host_read_commands[0]); 1434 smart->host_read_commands_hi = le64_to_cpu(log.host_read_commands[1]); 1435 smart->host_write_commands_lo = le64_to_cpu(log.host_write_commands[0]); 1436 smart->host_write_commands_hi = le64_to_cpu(log.host_write_commands[1]); 1437 smart->controller_busy_time_lo = le64_to_cpu(log.controller_busy_time[0]); 1438 smart->controller_busy_time_hi = le64_to_cpu(log.controller_busy_time[1]); 1439 smart->power_cycles_lo = le64_to_cpu(log.power_cycles[0]); 1440 smart->power_cycles_hi = le64_to_cpu(log.power_cycles[1]); 1441 smart->power_on_hours_lo = le64_to_cpu(log.power_on_hours[0]); 1442 smart->power_on_hours_hi = le64_to_cpu(log.power_on_hours[1]); 1443 smart->unsafe_shutdowns_lo = le64_to_cpu(log.unsafe_shutdowns[0]); 1444 smart->unsafe_shutdowns_hi = le64_to_cpu(log.unsafe_shutdowns[1]); 1445 smart->media_errors_lo = le64_to_cpu(log.media_errors[0]); 1446 smart->media_errors_hi = le64_to_cpu(log.media_errors[1]); 1447 smart->number_of_error_log_entries_lo = 1448 le64_to_cpu(log.number_of_error_log_entries[0]); 1449 smart->number_of_error_log_entries_hi = 1450 le64_to_cpu(log.number_of_error_log_entries[1]); 1451 1452 close(fd); 1453 } 1454 1455 static void get_disk_smart(GuestDiskInfo *disk) 1456 { 1457 if (disk->address 1458 && (disk->address->bus_type == GUEST_DISK_BUS_TYPE_NVME)) { 1459 get_nvme_smart(disk); 1460 } 1461 } 1462 1463 GuestDiskInfoList *qmp_guest_get_disks(Error **errp) 1464 { 1465 GuestDiskInfoList *ret = NULL; 1466 GuestDiskInfo *disk; 1467 DIR *dp = NULL; 1468 struct dirent *de = NULL; 1469 1470 g_debug("listing /sys/block directory"); 1471 dp = opendir("/sys/block"); 1472 if (dp == NULL) { 1473 error_setg_errno(errp, errno, "Can't open directory \"/sys/block\""); 1474 return NULL; 1475 } 1476 while ((de = readdir(dp)) != NULL) { 1477 g_autofree char *disk_dir = NULL, *line = NULL, 1478 *size_path = NULL; 1479 char *dev_name; 1480 Error *local_err = NULL; 1481 if (de->d_type != DT_LNK) { 1482 g_debug(" skipping entry: %s", de->d_name); 1483 continue; 1484 } 1485 1486 /* Check size and skip zero-sized disks */ 1487 g_debug(" checking disk size"); 1488 size_path = g_strdup_printf("/sys/block/%s/size", de->d_name); 1489 if (!g_file_get_contents(size_path, &line, NULL, NULL)) { 1490 g_debug(" failed to read disk size"); 1491 continue; 1492 } 1493 if (g_strcmp0(line, "0\n") == 0) { 1494 g_debug(" skipping zero-sized disk"); 1495 continue; 1496 } 1497 1498 g_debug(" adding %s", de->d_name); 1499 disk_dir = g_strdup_printf("/sys/block/%s", de->d_name); 1500 dev_name = get_device_for_syspath(disk_dir); 1501 if (dev_name == NULL) { 1502 g_debug("Failed to get device name for syspath: %s", 1503 disk_dir); 1504 continue; 1505 } 1506 disk = g_new0(GuestDiskInfo, 1); 1507 disk->name = dev_name; 1508 disk->partition = false; 1509 disk->alias = get_alias_for_syspath(disk_dir); 1510 QAPI_LIST_PREPEND(ret, disk); 1511 1512 /* Get address for non-virtual devices */ 1513 bool is_virtual = is_disk_virtual(disk_dir, &local_err); 1514 if (local_err != NULL) { 1515 g_debug(" failed to check disk path, ignoring error: %s", 1516 error_get_pretty(local_err)); 1517 error_free(local_err); 1518 local_err = NULL; 1519 /* Don't try to get the address */ 1520 is_virtual = true; 1521 } 1522 if (!is_virtual) { 1523 disk->address = get_disk_address(disk_dir, &local_err); 1524 if (local_err != NULL) { 1525 g_debug(" failed to get device info, ignoring error: %s", 1526 error_get_pretty(local_err)); 1527 error_free(local_err); 1528 local_err = NULL; 1529 } 1530 } 1531 1532 get_disk_deps(disk_dir, disk); 1533 get_disk_smart(disk); 1534 ret = get_disk_partitions(ret, de->d_name, disk_dir, dev_name); 1535 } 1536 1537 closedir(dp); 1538 1539 return ret; 1540 } 1541 1542 #else 1543 1544 GuestDiskInfoList *qmp_guest_get_disks(Error **errp) 1545 { 1546 error_setg(errp, QERR_UNSUPPORTED); 1547 return NULL; 1548 } 1549 1550 #endif 1551 1552 /* Return a list of the disk device(s)' info which @mount lies on */ 1553 static GuestFilesystemInfo *build_guest_fsinfo(struct FsMount *mount, 1554 Error **errp) 1555 { 1556 GuestFilesystemInfo *fs = g_malloc0(sizeof(*fs)); 1557 struct statvfs buf; 1558 unsigned long used, nonroot_total, fr_size; 1559 char *devpath = g_strdup_printf("/sys/dev/block/%u:%u", 1560 mount->devmajor, mount->devminor); 1561 1562 fs->mountpoint = g_strdup(mount->dirname); 1563 fs->type = g_strdup(mount->devtype); 1564 build_guest_fsinfo_for_device(devpath, fs, errp); 1565 1566 if (statvfs(fs->mountpoint, &buf) == 0) { 1567 fr_size = buf.f_frsize; 1568 used = buf.f_blocks - buf.f_bfree; 1569 nonroot_total = used + buf.f_bavail; 1570 fs->used_bytes = used * fr_size; 1571 fs->total_bytes = nonroot_total * fr_size; 1572 1573 fs->has_total_bytes = true; 1574 fs->has_used_bytes = true; 1575 } 1576 1577 g_free(devpath); 1578 1579 return fs; 1580 } 1581 1582 GuestFilesystemInfoList *qmp_guest_get_fsinfo(Error **errp) 1583 { 1584 FsMountList mounts; 1585 struct FsMount *mount; 1586 GuestFilesystemInfoList *ret = NULL; 1587 Error *local_err = NULL; 1588 1589 QTAILQ_INIT(&mounts); 1590 if (!build_fs_mount_list(&mounts, &local_err)) { 1591 error_propagate(errp, local_err); 1592 return NULL; 1593 } 1594 1595 QTAILQ_FOREACH(mount, &mounts, next) { 1596 g_debug("Building guest fsinfo for '%s'", mount->dirname); 1597 1598 QAPI_LIST_PREPEND(ret, build_guest_fsinfo(mount, &local_err)); 1599 if (local_err) { 1600 error_propagate(errp, local_err); 1601 qapi_free_GuestFilesystemInfoList(ret); 1602 ret = NULL; 1603 break; 1604 } 1605 } 1606 1607 free_fs_mount_list(&mounts); 1608 return ret; 1609 } 1610 #endif /* CONFIG_FSFREEZE */ 1611 1612 #if defined(CONFIG_FSTRIM) 1613 /* 1614 * Walk list of mounted file systems in the guest, and trim them. 1615 */ 1616 GuestFilesystemTrimResponse * 1617 qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp) 1618 { 1619 GuestFilesystemTrimResponse *response; 1620 GuestFilesystemTrimResult *result; 1621 int ret = 0; 1622 FsMountList mounts; 1623 struct FsMount *mount; 1624 int fd; 1625 struct fstrim_range r; 1626 1627 slog("guest-fstrim called"); 1628 1629 QTAILQ_INIT(&mounts); 1630 if (!build_fs_mount_list(&mounts, errp)) { 1631 return NULL; 1632 } 1633 1634 response = g_malloc0(sizeof(*response)); 1635 1636 QTAILQ_FOREACH(mount, &mounts, next) { 1637 result = g_malloc0(sizeof(*result)); 1638 result->path = g_strdup(mount->dirname); 1639 1640 QAPI_LIST_PREPEND(response->paths, result); 1641 1642 fd = qga_open_cloexec(mount->dirname, O_RDONLY, 0); 1643 if (fd == -1) { 1644 result->error = g_strdup_printf("failed to open: %s", 1645 strerror(errno)); 1646 continue; 1647 } 1648 1649 /* We try to cull filesystems we know won't work in advance, but other 1650 * filesystems may not implement fstrim for less obvious reasons. 1651 * These will report EOPNOTSUPP; while in some other cases ENOTTY 1652 * will be reported (e.g. CD-ROMs). 1653 * Any other error means an unexpected error. 1654 */ 1655 r.start = 0; 1656 r.len = -1; 1657 r.minlen = has_minimum ? minimum : 0; 1658 ret = ioctl(fd, FITRIM, &r); 1659 if (ret == -1) { 1660 if (errno == ENOTTY || errno == EOPNOTSUPP) { 1661 result->error = g_strdup("trim not supported"); 1662 } else { 1663 result->error = g_strdup_printf("failed to trim: %s", 1664 strerror(errno)); 1665 } 1666 close(fd); 1667 continue; 1668 } 1669 1670 result->has_minimum = true; 1671 result->minimum = r.minlen; 1672 result->has_trimmed = true; 1673 result->trimmed = r.len; 1674 close(fd); 1675 } 1676 1677 free_fs_mount_list(&mounts); 1678 return response; 1679 } 1680 #endif /* CONFIG_FSTRIM */ 1681 1682 1683 #define LINUX_SYS_STATE_FILE "/sys/power/state" 1684 #define SUSPEND_SUPPORTED 0 1685 #define SUSPEND_NOT_SUPPORTED 1 1686 1687 typedef enum { 1688 SUSPEND_MODE_DISK = 0, 1689 SUSPEND_MODE_RAM = 1, 1690 SUSPEND_MODE_HYBRID = 2, 1691 } SuspendMode; 1692 1693 /* 1694 * Executes a command in a child process using g_spawn_sync, 1695 * returning an int >= 0 representing the exit status of the 1696 * process. 1697 * 1698 * If the program wasn't found in path, returns -1. 1699 * 1700 * If a problem happened when creating the child process, 1701 * returns -1 and errp is set. 1702 */ 1703 static int run_process_child(const char *command[], Error **errp) 1704 { 1705 int exit_status, spawn_flag; 1706 GError *g_err = NULL; 1707 bool success; 1708 1709 spawn_flag = G_SPAWN_SEARCH_PATH | G_SPAWN_STDOUT_TO_DEV_NULL | 1710 G_SPAWN_STDERR_TO_DEV_NULL; 1711 1712 success = g_spawn_sync(NULL, (char **)command, NULL, spawn_flag, 1713 NULL, NULL, NULL, NULL, 1714 &exit_status, &g_err); 1715 1716 if (success) { 1717 return WEXITSTATUS(exit_status); 1718 } 1719 1720 if (g_err && (g_err->code != G_SPAWN_ERROR_NOENT)) { 1721 error_setg(errp, "failed to create child process, error '%s'", 1722 g_err->message); 1723 } 1724 1725 g_error_free(g_err); 1726 return -1; 1727 } 1728 1729 static bool systemd_supports_mode(SuspendMode mode, Error **errp) 1730 { 1731 const char *systemctl_args[3] = {"systemd-hibernate", "systemd-suspend", 1732 "systemd-hybrid-sleep"}; 1733 const char *cmd[4] = {"systemctl", "status", systemctl_args[mode], NULL}; 1734 int status; 1735 1736 status = run_process_child(cmd, errp); 1737 1738 /* 1739 * systemctl status uses LSB return codes so we can expect 1740 * status > 0 and be ok. To assert if the guest has support 1741 * for the selected suspend mode, status should be < 4. 4 is 1742 * the code for unknown service status, the return value when 1743 * the service does not exist. A common value is status = 3 1744 * (program is not running). 1745 */ 1746 if (status > 0 && status < 4) { 1747 return true; 1748 } 1749 1750 return false; 1751 } 1752 1753 static void systemd_suspend(SuspendMode mode, Error **errp) 1754 { 1755 Error *local_err = NULL; 1756 const char *systemctl_args[3] = {"hibernate", "suspend", "hybrid-sleep"}; 1757 const char *cmd[3] = {"systemctl", systemctl_args[mode], NULL}; 1758 int status; 1759 1760 status = run_process_child(cmd, &local_err); 1761 1762 if (status == 0) { 1763 return; 1764 } 1765 1766 if ((status == -1) && !local_err) { 1767 error_setg(errp, "the helper program 'systemctl %s' was not found", 1768 systemctl_args[mode]); 1769 return; 1770 } 1771 1772 if (local_err) { 1773 error_propagate(errp, local_err); 1774 } else { 1775 error_setg(errp, "the helper program 'systemctl %s' returned an " 1776 "unexpected exit status code (%d)", 1777 systemctl_args[mode], status); 1778 } 1779 } 1780 1781 static bool pmutils_supports_mode(SuspendMode mode, Error **errp) 1782 { 1783 Error *local_err = NULL; 1784 const char *pmutils_args[3] = {"--hibernate", "--suspend", 1785 "--suspend-hybrid"}; 1786 const char *cmd[3] = {"pm-is-supported", pmutils_args[mode], NULL}; 1787 int status; 1788 1789 status = run_process_child(cmd, &local_err); 1790 1791 if (status == SUSPEND_SUPPORTED) { 1792 return true; 1793 } 1794 1795 if ((status == -1) && !local_err) { 1796 return false; 1797 } 1798 1799 if (local_err) { 1800 error_propagate(errp, local_err); 1801 } else { 1802 error_setg(errp, 1803 "the helper program '%s' returned an unexpected exit" 1804 " status code (%d)", "pm-is-supported", status); 1805 } 1806 1807 return false; 1808 } 1809 1810 static void pmutils_suspend(SuspendMode mode, Error **errp) 1811 { 1812 Error *local_err = NULL; 1813 const char *pmutils_binaries[3] = {"pm-hibernate", "pm-suspend", 1814 "pm-suspend-hybrid"}; 1815 const char *cmd[2] = {pmutils_binaries[mode], NULL}; 1816 int status; 1817 1818 status = run_process_child(cmd, &local_err); 1819 1820 if (status == 0) { 1821 return; 1822 } 1823 1824 if ((status == -1) && !local_err) { 1825 error_setg(errp, "the helper program '%s' was not found", 1826 pmutils_binaries[mode]); 1827 return; 1828 } 1829 1830 if (local_err) { 1831 error_propagate(errp, local_err); 1832 } else { 1833 error_setg(errp, 1834 "the helper program '%s' returned an unexpected exit" 1835 " status code (%d)", pmutils_binaries[mode], status); 1836 } 1837 } 1838 1839 static bool linux_sys_state_supports_mode(SuspendMode mode, Error **errp) 1840 { 1841 const char *sysfile_strs[3] = {"disk", "mem", NULL}; 1842 const char *sysfile_str = sysfile_strs[mode]; 1843 char buf[32]; /* hopefully big enough */ 1844 int fd; 1845 ssize_t ret; 1846 1847 if (!sysfile_str) { 1848 error_setg(errp, "unknown guest suspend mode"); 1849 return false; 1850 } 1851 1852 fd = open(LINUX_SYS_STATE_FILE, O_RDONLY); 1853 if (fd < 0) { 1854 return false; 1855 } 1856 1857 ret = read(fd, buf, sizeof(buf) - 1); 1858 close(fd); 1859 if (ret <= 0) { 1860 return false; 1861 } 1862 buf[ret] = '\0'; 1863 1864 if (strstr(buf, sysfile_str)) { 1865 return true; 1866 } 1867 return false; 1868 } 1869 1870 static void linux_sys_state_suspend(SuspendMode mode, Error **errp) 1871 { 1872 Error *local_err = NULL; 1873 const char *sysfile_strs[3] = {"disk", "mem", NULL}; 1874 const char *sysfile_str = sysfile_strs[mode]; 1875 pid_t pid; 1876 int status; 1877 1878 if (!sysfile_str) { 1879 error_setg(errp, "unknown guest suspend mode"); 1880 return; 1881 } 1882 1883 pid = fork(); 1884 if (!pid) { 1885 /* child */ 1886 int fd; 1887 1888 setsid(); 1889 reopen_fd_to_null(0); 1890 reopen_fd_to_null(1); 1891 reopen_fd_to_null(2); 1892 1893 fd = open(LINUX_SYS_STATE_FILE, O_WRONLY); 1894 if (fd < 0) { 1895 _exit(EXIT_FAILURE); 1896 } 1897 1898 if (write(fd, sysfile_str, strlen(sysfile_str)) < 0) { 1899 _exit(EXIT_FAILURE); 1900 } 1901 1902 _exit(EXIT_SUCCESS); 1903 } else if (pid < 0) { 1904 error_setg_errno(errp, errno, "failed to create child process"); 1905 return; 1906 } 1907 1908 ga_wait_child(pid, &status, &local_err); 1909 if (local_err) { 1910 error_propagate(errp, local_err); 1911 return; 1912 } 1913 1914 if (WEXITSTATUS(status)) { 1915 error_setg(errp, "child process has failed to suspend"); 1916 } 1917 1918 } 1919 1920 static void guest_suspend(SuspendMode mode, Error **errp) 1921 { 1922 Error *local_err = NULL; 1923 bool mode_supported = false; 1924 1925 if (systemd_supports_mode(mode, &local_err)) { 1926 mode_supported = true; 1927 systemd_suspend(mode, &local_err); 1928 1929 if (!local_err) { 1930 return; 1931 } 1932 } 1933 1934 error_free(local_err); 1935 local_err = NULL; 1936 1937 if (pmutils_supports_mode(mode, &local_err)) { 1938 mode_supported = true; 1939 pmutils_suspend(mode, &local_err); 1940 1941 if (!local_err) { 1942 return; 1943 } 1944 } 1945 1946 error_free(local_err); 1947 local_err = NULL; 1948 1949 if (linux_sys_state_supports_mode(mode, &local_err)) { 1950 mode_supported = true; 1951 linux_sys_state_suspend(mode, &local_err); 1952 } 1953 1954 if (!mode_supported) { 1955 error_free(local_err); 1956 error_setg(errp, 1957 "the requested suspend mode is not supported by the guest"); 1958 } else { 1959 error_propagate(errp, local_err); 1960 } 1961 } 1962 1963 void qmp_guest_suspend_disk(Error **errp) 1964 { 1965 guest_suspend(SUSPEND_MODE_DISK, errp); 1966 } 1967 1968 void qmp_guest_suspend_ram(Error **errp) 1969 { 1970 guest_suspend(SUSPEND_MODE_RAM, errp); 1971 } 1972 1973 void qmp_guest_suspend_hybrid(Error **errp) 1974 { 1975 guest_suspend(SUSPEND_MODE_HYBRID, errp); 1976 } 1977 1978 /* Transfer online/offline status between @vcpu and the guest system. 1979 * 1980 * On input either @errp or *@errp must be NULL. 1981 * 1982 * In system-to-@vcpu direction, the following @vcpu fields are accessed: 1983 * - R: vcpu->logical_id 1984 * - W: vcpu->online 1985 * - W: vcpu->can_offline 1986 * 1987 * In @vcpu-to-system direction, the following @vcpu fields are accessed: 1988 * - R: vcpu->logical_id 1989 * - R: vcpu->online 1990 * 1991 * Written members remain unmodified on error. 1992 */ 1993 static void transfer_vcpu(GuestLogicalProcessor *vcpu, bool sys2vcpu, 1994 char *dirpath, Error **errp) 1995 { 1996 int fd; 1997 int res; 1998 int dirfd; 1999 static const char fn[] = "online"; 2000 2001 dirfd = open(dirpath, O_RDONLY | O_DIRECTORY); 2002 if (dirfd == -1) { 2003 error_setg_errno(errp, errno, "open(\"%s\")", dirpath); 2004 return; 2005 } 2006 2007 fd = openat(dirfd, fn, sys2vcpu ? O_RDONLY : O_RDWR); 2008 if (fd == -1) { 2009 if (errno != ENOENT) { 2010 error_setg_errno(errp, errno, "open(\"%s/%s\")", dirpath, fn); 2011 } else if (sys2vcpu) { 2012 vcpu->online = true; 2013 vcpu->can_offline = false; 2014 } else if (!vcpu->online) { 2015 error_setg(errp, "logical processor #%" PRId64 " can't be " 2016 "offlined", vcpu->logical_id); 2017 } /* otherwise pretend successful re-onlining */ 2018 } else { 2019 unsigned char status; 2020 2021 res = pread(fd, &status, 1, 0); 2022 if (res == -1) { 2023 error_setg_errno(errp, errno, "pread(\"%s/%s\")", dirpath, fn); 2024 } else if (res == 0) { 2025 error_setg(errp, "pread(\"%s/%s\"): unexpected EOF", dirpath, 2026 fn); 2027 } else if (sys2vcpu) { 2028 vcpu->online = (status != '0'); 2029 vcpu->can_offline = true; 2030 } else if (vcpu->online != (status != '0')) { 2031 status = '0' + vcpu->online; 2032 if (pwrite(fd, &status, 1, 0) == -1) { 2033 error_setg_errno(errp, errno, "pwrite(\"%s/%s\")", dirpath, 2034 fn); 2035 } 2036 } /* otherwise pretend successful re-(on|off)-lining */ 2037 2038 res = close(fd); 2039 g_assert(res == 0); 2040 } 2041 2042 res = close(dirfd); 2043 g_assert(res == 0); 2044 } 2045 2046 GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp) 2047 { 2048 GuestLogicalProcessorList *head, **tail; 2049 const char *cpu_dir = "/sys/devices/system/cpu"; 2050 const gchar *line; 2051 g_autoptr(GDir) cpu_gdir = NULL; 2052 Error *local_err = NULL; 2053 2054 head = NULL; 2055 tail = &head; 2056 cpu_gdir = g_dir_open(cpu_dir, 0, NULL); 2057 2058 if (cpu_gdir == NULL) { 2059 error_setg_errno(errp, errno, "failed to list entries: %s", cpu_dir); 2060 return NULL; 2061 } 2062 2063 while (local_err == NULL && (line = g_dir_read_name(cpu_gdir)) != NULL) { 2064 GuestLogicalProcessor *vcpu; 2065 int64_t id; 2066 if (sscanf(line, "cpu%" PRId64, &id)) { 2067 g_autofree char *path = g_strdup_printf("/sys/devices/system/cpu/" 2068 "cpu%" PRId64 "/", id); 2069 vcpu = g_malloc0(sizeof *vcpu); 2070 vcpu->logical_id = id; 2071 vcpu->has_can_offline = true; /* lolspeak ftw */ 2072 transfer_vcpu(vcpu, true, path, &local_err); 2073 QAPI_LIST_APPEND(tail, vcpu); 2074 } 2075 } 2076 2077 if (local_err == NULL) { 2078 /* there's no guest with zero VCPUs */ 2079 g_assert(head != NULL); 2080 return head; 2081 } 2082 2083 qapi_free_GuestLogicalProcessorList(head); 2084 error_propagate(errp, local_err); 2085 return NULL; 2086 } 2087 2088 int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp) 2089 { 2090 int64_t processed; 2091 Error *local_err = NULL; 2092 2093 processed = 0; 2094 while (vcpus != NULL) { 2095 char *path = g_strdup_printf("/sys/devices/system/cpu/cpu%" PRId64 "/", 2096 vcpus->value->logical_id); 2097 2098 transfer_vcpu(vcpus->value, false, path, &local_err); 2099 g_free(path); 2100 if (local_err != NULL) { 2101 break; 2102 } 2103 ++processed; 2104 vcpus = vcpus->next; 2105 } 2106 2107 if (local_err != NULL) { 2108 if (processed == 0) { 2109 error_propagate(errp, local_err); 2110 } else { 2111 error_free(local_err); 2112 } 2113 } 2114 2115 return processed; 2116 } 2117 #endif /* __linux__ */ 2118 2119 #if defined(__linux__) || defined(__FreeBSD__) 2120 void qmp_guest_set_user_password(const char *username, 2121 const char *password, 2122 bool crypted, 2123 Error **errp) 2124 { 2125 Error *local_err = NULL; 2126 char *passwd_path = NULL; 2127 pid_t pid; 2128 int status; 2129 int datafd[2] = { -1, -1 }; 2130 char *rawpasswddata = NULL; 2131 size_t rawpasswdlen; 2132 char *chpasswddata = NULL; 2133 size_t chpasswdlen; 2134 2135 rawpasswddata = (char *)qbase64_decode(password, -1, &rawpasswdlen, errp); 2136 if (!rawpasswddata) { 2137 return; 2138 } 2139 rawpasswddata = g_renew(char, rawpasswddata, rawpasswdlen + 1); 2140 rawpasswddata[rawpasswdlen] = '\0'; 2141 2142 if (strchr(rawpasswddata, '\n')) { 2143 error_setg(errp, "forbidden characters in raw password"); 2144 goto out; 2145 } 2146 2147 if (strchr(username, '\n') || 2148 strchr(username, ':')) { 2149 error_setg(errp, "forbidden characters in username"); 2150 goto out; 2151 } 2152 2153 #ifdef __FreeBSD__ 2154 chpasswddata = g_strdup(rawpasswddata); 2155 passwd_path = g_find_program_in_path("pw"); 2156 #else 2157 chpasswddata = g_strdup_printf("%s:%s\n", username, rawpasswddata); 2158 passwd_path = g_find_program_in_path("chpasswd"); 2159 #endif 2160 2161 chpasswdlen = strlen(chpasswddata); 2162 2163 if (!passwd_path) { 2164 error_setg(errp, "cannot find 'passwd' program in PATH"); 2165 goto out; 2166 } 2167 2168 if (!g_unix_open_pipe(datafd, FD_CLOEXEC, NULL)) { 2169 error_setg(errp, "cannot create pipe FDs"); 2170 goto out; 2171 } 2172 2173 pid = fork(); 2174 if (pid == 0) { 2175 close(datafd[1]); 2176 /* child */ 2177 setsid(); 2178 dup2(datafd[0], 0); 2179 reopen_fd_to_null(1); 2180 reopen_fd_to_null(2); 2181 2182 #ifdef __FreeBSD__ 2183 const char *h_arg; 2184 h_arg = (crypted) ? "-H" : "-h"; 2185 execl(passwd_path, "pw", "usermod", "-n", username, h_arg, "0", NULL); 2186 #else 2187 if (crypted) { 2188 execl(passwd_path, "chpasswd", "-e", NULL); 2189 } else { 2190 execl(passwd_path, "chpasswd", NULL); 2191 } 2192 #endif 2193 _exit(EXIT_FAILURE); 2194 } else if (pid < 0) { 2195 error_setg_errno(errp, errno, "failed to create child process"); 2196 goto out; 2197 } 2198 close(datafd[0]); 2199 datafd[0] = -1; 2200 2201 if (qemu_write_full(datafd[1], chpasswddata, chpasswdlen) != chpasswdlen) { 2202 error_setg_errno(errp, errno, "cannot write new account password"); 2203 goto out; 2204 } 2205 close(datafd[1]); 2206 datafd[1] = -1; 2207 2208 ga_wait_child(pid, &status, &local_err); 2209 if (local_err) { 2210 error_propagate(errp, local_err); 2211 goto out; 2212 } 2213 2214 if (!WIFEXITED(status)) { 2215 error_setg(errp, "child process has terminated abnormally"); 2216 goto out; 2217 } 2218 2219 if (WEXITSTATUS(status)) { 2220 error_setg(errp, "child process has failed to set user password"); 2221 goto out; 2222 } 2223 2224 out: 2225 g_free(chpasswddata); 2226 g_free(rawpasswddata); 2227 g_free(passwd_path); 2228 if (datafd[0] != -1) { 2229 close(datafd[0]); 2230 } 2231 if (datafd[1] != -1) { 2232 close(datafd[1]); 2233 } 2234 } 2235 #else /* __linux__ || __FreeBSD__ */ 2236 void qmp_guest_set_user_password(const char *username, 2237 const char *password, 2238 bool crypted, 2239 Error **errp) 2240 { 2241 error_setg(errp, QERR_UNSUPPORTED); 2242 } 2243 #endif /* __linux__ || __FreeBSD__ */ 2244 2245 #ifdef __linux__ 2246 static void ga_read_sysfs_file(int dirfd, const char *pathname, char *buf, 2247 int size, Error **errp) 2248 { 2249 int fd; 2250 int res; 2251 2252 errno = 0; 2253 fd = openat(dirfd, pathname, O_RDONLY); 2254 if (fd == -1) { 2255 error_setg_errno(errp, errno, "open sysfs file \"%s\"", pathname); 2256 return; 2257 } 2258 2259 res = pread(fd, buf, size, 0); 2260 if (res == -1) { 2261 error_setg_errno(errp, errno, "pread sysfs file \"%s\"", pathname); 2262 } else if (res == 0) { 2263 error_setg(errp, "pread sysfs file \"%s\": unexpected EOF", pathname); 2264 } 2265 close(fd); 2266 } 2267 2268 static void ga_write_sysfs_file(int dirfd, const char *pathname, 2269 const char *buf, int size, Error **errp) 2270 { 2271 int fd; 2272 2273 errno = 0; 2274 fd = openat(dirfd, pathname, O_WRONLY); 2275 if (fd == -1) { 2276 error_setg_errno(errp, errno, "open sysfs file \"%s\"", pathname); 2277 return; 2278 } 2279 2280 if (pwrite(fd, buf, size, 0) == -1) { 2281 error_setg_errno(errp, errno, "pwrite sysfs file \"%s\"", pathname); 2282 } 2283 2284 close(fd); 2285 } 2286 2287 /* Transfer online/offline status between @mem_blk and the guest system. 2288 * 2289 * On input either @errp or *@errp must be NULL. 2290 * 2291 * In system-to-@mem_blk direction, the following @mem_blk fields are accessed: 2292 * - R: mem_blk->phys_index 2293 * - W: mem_blk->online 2294 * - W: mem_blk->can_offline 2295 * 2296 * In @mem_blk-to-system direction, the following @mem_blk fields are accessed: 2297 * - R: mem_blk->phys_index 2298 * - R: mem_blk->online 2299 *- R: mem_blk->can_offline 2300 * Written members remain unmodified on error. 2301 */ 2302 static void transfer_memory_block(GuestMemoryBlock *mem_blk, bool sys2memblk, 2303 GuestMemoryBlockResponse *result, 2304 Error **errp) 2305 { 2306 char *dirpath; 2307 int dirfd; 2308 char *status; 2309 Error *local_err = NULL; 2310 2311 if (!sys2memblk) { 2312 DIR *dp; 2313 2314 if (!result) { 2315 error_setg(errp, "Internal error, 'result' should not be NULL"); 2316 return; 2317 } 2318 errno = 0; 2319 dp = opendir("/sys/devices/system/memory/"); 2320 /* if there is no 'memory' directory in sysfs, 2321 * we think this VM does not support online/offline memory block, 2322 * any other solution? 2323 */ 2324 if (!dp) { 2325 if (errno == ENOENT) { 2326 result->response = 2327 GUEST_MEMORY_BLOCK_RESPONSE_TYPE_OPERATION_NOT_SUPPORTED; 2328 } 2329 goto out1; 2330 } 2331 closedir(dp); 2332 } 2333 2334 dirpath = g_strdup_printf("/sys/devices/system/memory/memory%" PRId64 "/", 2335 mem_blk->phys_index); 2336 dirfd = open(dirpath, O_RDONLY | O_DIRECTORY); 2337 if (dirfd == -1) { 2338 if (sys2memblk) { 2339 error_setg_errno(errp, errno, "open(\"%s\")", dirpath); 2340 } else { 2341 if (errno == ENOENT) { 2342 result->response = GUEST_MEMORY_BLOCK_RESPONSE_TYPE_NOT_FOUND; 2343 } else { 2344 result->response = 2345 GUEST_MEMORY_BLOCK_RESPONSE_TYPE_OPERATION_FAILED; 2346 } 2347 } 2348 g_free(dirpath); 2349 goto out1; 2350 } 2351 g_free(dirpath); 2352 2353 status = g_malloc0(10); 2354 ga_read_sysfs_file(dirfd, "state", status, 10, &local_err); 2355 if (local_err) { 2356 /* treat with sysfs file that not exist in old kernel */ 2357 if (errno == ENOENT) { 2358 error_free(local_err); 2359 if (sys2memblk) { 2360 mem_blk->online = true; 2361 mem_blk->can_offline = false; 2362 } else if (!mem_blk->online) { 2363 result->response = 2364 GUEST_MEMORY_BLOCK_RESPONSE_TYPE_OPERATION_NOT_SUPPORTED; 2365 } 2366 } else { 2367 if (sys2memblk) { 2368 error_propagate(errp, local_err); 2369 } else { 2370 error_free(local_err); 2371 result->response = 2372 GUEST_MEMORY_BLOCK_RESPONSE_TYPE_OPERATION_FAILED; 2373 } 2374 } 2375 goto out2; 2376 } 2377 2378 if (sys2memblk) { 2379 char removable = '0'; 2380 2381 mem_blk->online = (strncmp(status, "online", 6) == 0); 2382 2383 ga_read_sysfs_file(dirfd, "removable", &removable, 1, &local_err); 2384 if (local_err) { 2385 /* if no 'removable' file, it doesn't support offline mem blk */ 2386 if (errno == ENOENT) { 2387 error_free(local_err); 2388 mem_blk->can_offline = false; 2389 } else { 2390 error_propagate(errp, local_err); 2391 } 2392 } else { 2393 mem_blk->can_offline = (removable != '0'); 2394 } 2395 } else { 2396 if (mem_blk->online != (strncmp(status, "online", 6) == 0)) { 2397 const char *new_state = mem_blk->online ? "online" : "offline"; 2398 2399 ga_write_sysfs_file(dirfd, "state", new_state, strlen(new_state), 2400 &local_err); 2401 if (local_err) { 2402 error_free(local_err); 2403 result->response = 2404 GUEST_MEMORY_BLOCK_RESPONSE_TYPE_OPERATION_FAILED; 2405 goto out2; 2406 } 2407 2408 result->response = GUEST_MEMORY_BLOCK_RESPONSE_TYPE_SUCCESS; 2409 result->has_error_code = false; 2410 } /* otherwise pretend successful re-(on|off)-lining */ 2411 } 2412 g_free(status); 2413 close(dirfd); 2414 return; 2415 2416 out2: 2417 g_free(status); 2418 close(dirfd); 2419 out1: 2420 if (!sys2memblk) { 2421 result->has_error_code = true; 2422 result->error_code = errno; 2423 } 2424 } 2425 2426 GuestMemoryBlockList *qmp_guest_get_memory_blocks(Error **errp) 2427 { 2428 GuestMemoryBlockList *head, **tail; 2429 Error *local_err = NULL; 2430 struct dirent *de; 2431 DIR *dp; 2432 2433 head = NULL; 2434 tail = &head; 2435 2436 dp = opendir("/sys/devices/system/memory/"); 2437 if (!dp) { 2438 /* it's ok if this happens to be a system that doesn't expose 2439 * memory blocks via sysfs, but otherwise we should report 2440 * an error 2441 */ 2442 if (errno != ENOENT) { 2443 error_setg_errno(errp, errno, "Can't open directory" 2444 "\"/sys/devices/system/memory/\""); 2445 } 2446 return NULL; 2447 } 2448 2449 /* Note: the phys_index of memory block may be discontinuous, 2450 * this is because a memblk is the unit of the Sparse Memory design, which 2451 * allows discontinuous memory ranges (ex. NUMA), so here we should 2452 * traverse the memory block directory. 2453 */ 2454 while ((de = readdir(dp)) != NULL) { 2455 GuestMemoryBlock *mem_blk; 2456 2457 if ((strncmp(de->d_name, "memory", 6) != 0) || 2458 !(de->d_type & DT_DIR)) { 2459 continue; 2460 } 2461 2462 mem_blk = g_malloc0(sizeof *mem_blk); 2463 /* The d_name is "memoryXXX", phys_index is block id, same as XXX */ 2464 mem_blk->phys_index = strtoul(&de->d_name[6], NULL, 10); 2465 mem_blk->has_can_offline = true; /* lolspeak ftw */ 2466 transfer_memory_block(mem_blk, true, NULL, &local_err); 2467 if (local_err) { 2468 break; 2469 } 2470 2471 QAPI_LIST_APPEND(tail, mem_blk); 2472 } 2473 2474 closedir(dp); 2475 if (local_err == NULL) { 2476 /* there's no guest with zero memory blocks */ 2477 if (head == NULL) { 2478 error_setg(errp, "guest reported zero memory blocks!"); 2479 } 2480 return head; 2481 } 2482 2483 qapi_free_GuestMemoryBlockList(head); 2484 error_propagate(errp, local_err); 2485 return NULL; 2486 } 2487 2488 GuestMemoryBlockResponseList * 2489 qmp_guest_set_memory_blocks(GuestMemoryBlockList *mem_blks, Error **errp) 2490 { 2491 GuestMemoryBlockResponseList *head, **tail; 2492 Error *local_err = NULL; 2493 2494 head = NULL; 2495 tail = &head; 2496 2497 while (mem_blks != NULL) { 2498 GuestMemoryBlockResponse *result; 2499 GuestMemoryBlock *current_mem_blk = mem_blks->value; 2500 2501 result = g_malloc0(sizeof(*result)); 2502 result->phys_index = current_mem_blk->phys_index; 2503 transfer_memory_block(current_mem_blk, false, result, &local_err); 2504 if (local_err) { /* should never happen */ 2505 goto err; 2506 } 2507 2508 QAPI_LIST_APPEND(tail, result); 2509 mem_blks = mem_blks->next; 2510 } 2511 2512 return head; 2513 err: 2514 qapi_free_GuestMemoryBlockResponseList(head); 2515 error_propagate(errp, local_err); 2516 return NULL; 2517 } 2518 2519 GuestMemoryBlockInfo *qmp_guest_get_memory_block_info(Error **errp) 2520 { 2521 Error *local_err = NULL; 2522 char *dirpath; 2523 int dirfd; 2524 char *buf; 2525 GuestMemoryBlockInfo *info; 2526 2527 dirpath = g_strdup_printf("/sys/devices/system/memory/"); 2528 dirfd = open(dirpath, O_RDONLY | O_DIRECTORY); 2529 if (dirfd == -1) { 2530 error_setg_errno(errp, errno, "open(\"%s\")", dirpath); 2531 g_free(dirpath); 2532 return NULL; 2533 } 2534 g_free(dirpath); 2535 2536 buf = g_malloc0(20); 2537 ga_read_sysfs_file(dirfd, "block_size_bytes", buf, 20, &local_err); 2538 close(dirfd); 2539 if (local_err) { 2540 g_free(buf); 2541 error_propagate(errp, local_err); 2542 return NULL; 2543 } 2544 2545 info = g_new0(GuestMemoryBlockInfo, 1); 2546 info->size = strtol(buf, NULL, 16); /* the unit is bytes */ 2547 2548 g_free(buf); 2549 2550 return info; 2551 } 2552 2553 #define MAX_NAME_LEN 128 2554 static GuestDiskStatsInfoList *guest_get_diskstats(Error **errp) 2555 { 2556 #ifdef CONFIG_LINUX 2557 GuestDiskStatsInfoList *head = NULL, **tail = &head; 2558 const char *diskstats = "/proc/diskstats"; 2559 FILE *fp; 2560 size_t n; 2561 char *line = NULL; 2562 2563 fp = fopen(diskstats, "r"); 2564 if (fp == NULL) { 2565 error_setg_errno(errp, errno, "open(\"%s\")", diskstats); 2566 return NULL; 2567 } 2568 2569 while (getline(&line, &n, fp) != -1) { 2570 g_autofree GuestDiskStatsInfo *diskstatinfo = NULL; 2571 g_autofree GuestDiskStats *diskstat = NULL; 2572 char dev_name[MAX_NAME_LEN]; 2573 unsigned int ios_pgr, tot_ticks, rq_ticks, wr_ticks, dc_ticks, fl_ticks; 2574 unsigned long rd_ios, rd_merges_or_rd_sec, rd_ticks_or_wr_sec, wr_ios; 2575 unsigned long wr_merges, rd_sec_or_wr_ios, wr_sec; 2576 unsigned long dc_ios, dc_merges, dc_sec, fl_ios; 2577 unsigned int major, minor; 2578 int i; 2579 2580 i = sscanf(line, "%u %u %s %lu %lu %lu" 2581 "%lu %lu %lu %lu %u %u %u %u" 2582 "%lu %lu %lu %u %lu %u", 2583 &major, &minor, dev_name, 2584 &rd_ios, &rd_merges_or_rd_sec, &rd_sec_or_wr_ios, 2585 &rd_ticks_or_wr_sec, &wr_ios, &wr_merges, &wr_sec, 2586 &wr_ticks, &ios_pgr, &tot_ticks, &rq_ticks, 2587 &dc_ios, &dc_merges, &dc_sec, &dc_ticks, 2588 &fl_ios, &fl_ticks); 2589 2590 if (i < 7) { 2591 continue; 2592 } 2593 2594 diskstatinfo = g_new0(GuestDiskStatsInfo, 1); 2595 diskstatinfo->name = g_strdup(dev_name); 2596 diskstatinfo->major = major; 2597 diskstatinfo->minor = minor; 2598 2599 diskstat = g_new0(GuestDiskStats, 1); 2600 if (i == 7) { 2601 diskstat->has_read_ios = true; 2602 diskstat->read_ios = rd_ios; 2603 diskstat->has_read_sectors = true; 2604 diskstat->read_sectors = rd_merges_or_rd_sec; 2605 diskstat->has_write_ios = true; 2606 diskstat->write_ios = rd_sec_or_wr_ios; 2607 diskstat->has_write_sectors = true; 2608 diskstat->write_sectors = rd_ticks_or_wr_sec; 2609 } 2610 if (i >= 14) { 2611 diskstat->has_read_ios = true; 2612 diskstat->read_ios = rd_ios; 2613 diskstat->has_read_sectors = true; 2614 diskstat->read_sectors = rd_sec_or_wr_ios; 2615 diskstat->has_read_merges = true; 2616 diskstat->read_merges = rd_merges_or_rd_sec; 2617 diskstat->has_read_ticks = true; 2618 diskstat->read_ticks = rd_ticks_or_wr_sec; 2619 diskstat->has_write_ios = true; 2620 diskstat->write_ios = wr_ios; 2621 diskstat->has_write_sectors = true; 2622 diskstat->write_sectors = wr_sec; 2623 diskstat->has_write_merges = true; 2624 diskstat->write_merges = wr_merges; 2625 diskstat->has_write_ticks = true; 2626 diskstat->write_ticks = wr_ticks; 2627 diskstat->has_ios_pgr = true; 2628 diskstat->ios_pgr = ios_pgr; 2629 diskstat->has_total_ticks = true; 2630 diskstat->total_ticks = tot_ticks; 2631 diskstat->has_weight_ticks = true; 2632 diskstat->weight_ticks = rq_ticks; 2633 } 2634 if (i >= 18) { 2635 diskstat->has_discard_ios = true; 2636 diskstat->discard_ios = dc_ios; 2637 diskstat->has_discard_merges = true; 2638 diskstat->discard_merges = dc_merges; 2639 diskstat->has_discard_sectors = true; 2640 diskstat->discard_sectors = dc_sec; 2641 diskstat->has_discard_ticks = true; 2642 diskstat->discard_ticks = dc_ticks; 2643 } 2644 if (i >= 20) { 2645 diskstat->has_flush_ios = true; 2646 diskstat->flush_ios = fl_ios; 2647 diskstat->has_flush_ticks = true; 2648 diskstat->flush_ticks = fl_ticks; 2649 } 2650 2651 diskstatinfo->stats = g_steal_pointer(&diskstat); 2652 QAPI_LIST_APPEND(tail, diskstatinfo); 2653 diskstatinfo = NULL; 2654 } 2655 free(line); 2656 fclose(fp); 2657 return head; 2658 #else 2659 g_debug("disk stats reporting available only for Linux"); 2660 return NULL; 2661 #endif 2662 } 2663 2664 GuestDiskStatsInfoList *qmp_guest_get_diskstats(Error **errp) 2665 { 2666 return guest_get_diskstats(errp); 2667 } 2668 2669 GuestCpuStatsList *qmp_guest_get_cpustats(Error **errp) 2670 { 2671 GuestCpuStatsList *head = NULL, **tail = &head; 2672 const char *cpustats = "/proc/stat"; 2673 int clk_tck = sysconf(_SC_CLK_TCK); 2674 FILE *fp; 2675 size_t n; 2676 char *line = NULL; 2677 2678 fp = fopen(cpustats, "r"); 2679 if (fp == NULL) { 2680 error_setg_errno(errp, errno, "open(\"%s\")", cpustats); 2681 return NULL; 2682 } 2683 2684 while (getline(&line, &n, fp) != -1) { 2685 GuestCpuStats *cpustat = NULL; 2686 GuestLinuxCpuStats *linuxcpustat; 2687 int i; 2688 unsigned long user, system, idle, iowait, irq, softirq, steal, guest; 2689 unsigned long nice, guest_nice; 2690 char name[64]; 2691 2692 i = sscanf(line, "%s %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu", 2693 name, &user, &nice, &system, &idle, &iowait, &irq, &softirq, 2694 &steal, &guest, &guest_nice); 2695 2696 /* drop "cpu 1 2 3 ...", get "cpuX 1 2 3 ..." only */ 2697 if ((i == EOF) || strncmp(name, "cpu", 3) || (name[3] == '\0')) { 2698 continue; 2699 } 2700 2701 if (i < 5) { 2702 slog("Parsing cpu stat from %s failed, see \"man proc\"", cpustats); 2703 break; 2704 } 2705 2706 cpustat = g_new0(GuestCpuStats, 1); 2707 cpustat->type = GUEST_CPU_STATS_TYPE_LINUX; 2708 2709 linuxcpustat = &cpustat->u.q_linux; 2710 linuxcpustat->cpu = atoi(&name[3]); 2711 linuxcpustat->user = user * 1000 / clk_tck; 2712 linuxcpustat->nice = nice * 1000 / clk_tck; 2713 linuxcpustat->system = system * 1000 / clk_tck; 2714 linuxcpustat->idle = idle * 1000 / clk_tck; 2715 2716 if (i > 5) { 2717 linuxcpustat->has_iowait = true; 2718 linuxcpustat->iowait = iowait * 1000 / clk_tck; 2719 } 2720 2721 if (i > 6) { 2722 linuxcpustat->has_irq = true; 2723 linuxcpustat->irq = irq * 1000 / clk_tck; 2724 linuxcpustat->has_softirq = true; 2725 linuxcpustat->softirq = softirq * 1000 / clk_tck; 2726 } 2727 2728 if (i > 8) { 2729 linuxcpustat->has_steal = true; 2730 linuxcpustat->steal = steal * 1000 / clk_tck; 2731 } 2732 2733 if (i > 9) { 2734 linuxcpustat->has_guest = true; 2735 linuxcpustat->guest = guest * 1000 / clk_tck; 2736 } 2737 2738 if (i > 10) { 2739 linuxcpustat->has_guest = true; 2740 linuxcpustat->guest = guest * 1000 / clk_tck; 2741 linuxcpustat->has_guestnice = true; 2742 linuxcpustat->guestnice = guest_nice * 1000 / clk_tck; 2743 } 2744 2745 QAPI_LIST_APPEND(tail, cpustat); 2746 } 2747 2748 free(line); 2749 fclose(fp); 2750 return head; 2751 } 2752 2753 #else /* defined(__linux__) */ 2754 2755 void qmp_guest_suspend_disk(Error **errp) 2756 { 2757 error_setg(errp, QERR_UNSUPPORTED); 2758 } 2759 2760 void qmp_guest_suspend_ram(Error **errp) 2761 { 2762 error_setg(errp, QERR_UNSUPPORTED); 2763 } 2764 2765 void qmp_guest_suspend_hybrid(Error **errp) 2766 { 2767 error_setg(errp, QERR_UNSUPPORTED); 2768 } 2769 2770 GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp) 2771 { 2772 error_setg(errp, QERR_UNSUPPORTED); 2773 return NULL; 2774 } 2775 2776 int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp) 2777 { 2778 error_setg(errp, QERR_UNSUPPORTED); 2779 return -1; 2780 } 2781 2782 GuestMemoryBlockList *qmp_guest_get_memory_blocks(Error **errp) 2783 { 2784 error_setg(errp, QERR_UNSUPPORTED); 2785 return NULL; 2786 } 2787 2788 GuestMemoryBlockResponseList * 2789 qmp_guest_set_memory_blocks(GuestMemoryBlockList *mem_blks, Error **errp) 2790 { 2791 error_setg(errp, QERR_UNSUPPORTED); 2792 return NULL; 2793 } 2794 2795 GuestMemoryBlockInfo *qmp_guest_get_memory_block_info(Error **errp) 2796 { 2797 error_setg(errp, QERR_UNSUPPORTED); 2798 return NULL; 2799 } 2800 2801 #endif 2802 2803 #ifdef HAVE_GETIFADDRS 2804 static GuestNetworkInterface * 2805 guest_find_interface(GuestNetworkInterfaceList *head, 2806 const char *name) 2807 { 2808 for (; head; head = head->next) { 2809 if (strcmp(head->value->name, name) == 0) { 2810 return head->value; 2811 } 2812 } 2813 2814 return NULL; 2815 } 2816 2817 static int guest_get_network_stats(const char *name, 2818 GuestNetworkInterfaceStat *stats) 2819 { 2820 #ifdef CONFIG_LINUX 2821 int name_len; 2822 char const *devinfo = "/proc/net/dev"; 2823 FILE *fp; 2824 char *line = NULL, *colon; 2825 size_t n = 0; 2826 fp = fopen(devinfo, "r"); 2827 if (!fp) { 2828 g_debug("failed to open network stats %s: %s", devinfo, 2829 g_strerror(errno)); 2830 return -1; 2831 } 2832 name_len = strlen(name); 2833 while (getline(&line, &n, fp) != -1) { 2834 long long dummy; 2835 long long rx_bytes; 2836 long long rx_packets; 2837 long long rx_errs; 2838 long long rx_dropped; 2839 long long tx_bytes; 2840 long long tx_packets; 2841 long long tx_errs; 2842 long long tx_dropped; 2843 char *trim_line; 2844 trim_line = g_strchug(line); 2845 if (trim_line[0] == '\0') { 2846 continue; 2847 } 2848 colon = strchr(trim_line, ':'); 2849 if (!colon) { 2850 continue; 2851 } 2852 if (colon - name_len == trim_line && 2853 strncmp(trim_line, name, name_len) == 0) { 2854 if (sscanf(colon + 1, 2855 "%lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld", 2856 &rx_bytes, &rx_packets, &rx_errs, &rx_dropped, 2857 &dummy, &dummy, &dummy, &dummy, 2858 &tx_bytes, &tx_packets, &tx_errs, &tx_dropped, 2859 &dummy, &dummy, &dummy, &dummy) != 16) { 2860 continue; 2861 } 2862 stats->rx_bytes = rx_bytes; 2863 stats->rx_packets = rx_packets; 2864 stats->rx_errs = rx_errs; 2865 stats->rx_dropped = rx_dropped; 2866 stats->tx_bytes = tx_bytes; 2867 stats->tx_packets = tx_packets; 2868 stats->tx_errs = tx_errs; 2869 stats->tx_dropped = tx_dropped; 2870 fclose(fp); 2871 g_free(line); 2872 return 0; 2873 } 2874 } 2875 fclose(fp); 2876 g_free(line); 2877 g_debug("/proc/net/dev: Interface '%s' not found", name); 2878 #else /* !CONFIG_LINUX */ 2879 g_debug("Network stats reporting available only for Linux"); 2880 #endif /* !CONFIG_LINUX */ 2881 return -1; 2882 } 2883 2884 #ifndef CONFIG_BSD 2885 /* 2886 * Fill "buf" with MAC address by ifaddrs. Pointer buf must point to a 2887 * buffer with ETHER_ADDR_LEN length at least. 2888 * 2889 * Returns false in case of an error, otherwise true. "obtained" argument 2890 * is true if a MAC address was obtained successful, otherwise false. 2891 */ 2892 bool guest_get_hw_addr(struct ifaddrs *ifa, unsigned char *buf, 2893 bool *obtained, Error **errp) 2894 { 2895 struct ifreq ifr; 2896 int sock; 2897 2898 *obtained = false; 2899 2900 /* we haven't obtained HW address yet */ 2901 sock = socket(PF_INET, SOCK_STREAM, 0); 2902 if (sock == -1) { 2903 error_setg_errno(errp, errno, "failed to create socket"); 2904 return false; 2905 } 2906 2907 memset(&ifr, 0, sizeof(ifr)); 2908 pstrcpy(ifr.ifr_name, IF_NAMESIZE, ifa->ifa_name); 2909 if (ioctl(sock, SIOCGIFHWADDR, &ifr) == -1) { 2910 /* 2911 * We can't get the hw addr of this interface, but that's not a 2912 * fatal error. 2913 */ 2914 if (errno == EADDRNOTAVAIL) { 2915 /* The interface doesn't have a hw addr (e.g. loopback). */ 2916 g_debug("failed to get MAC address of %s: %s", 2917 ifa->ifa_name, strerror(errno)); 2918 } else{ 2919 g_warning("failed to get MAC address of %s: %s", 2920 ifa->ifa_name, strerror(errno)); 2921 } 2922 } else { 2923 #ifdef CONFIG_SOLARIS 2924 memcpy(buf, &ifr.ifr_addr.sa_data, ETHER_ADDR_LEN); 2925 #else 2926 memcpy(buf, &ifr.ifr_hwaddr.sa_data, ETHER_ADDR_LEN); 2927 #endif 2928 *obtained = true; 2929 } 2930 close(sock); 2931 return true; 2932 } 2933 #endif /* CONFIG_BSD */ 2934 2935 /* 2936 * Build information about guest interfaces 2937 */ 2938 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp) 2939 { 2940 GuestNetworkInterfaceList *head = NULL, **tail = &head; 2941 struct ifaddrs *ifap, *ifa; 2942 2943 if (getifaddrs(&ifap) < 0) { 2944 error_setg_errno(errp, errno, "getifaddrs failed"); 2945 goto error; 2946 } 2947 2948 for (ifa = ifap; ifa; ifa = ifa->ifa_next) { 2949 GuestNetworkInterface *info; 2950 GuestIpAddressList **address_tail; 2951 GuestIpAddress *address_item = NULL; 2952 GuestNetworkInterfaceStat *interface_stat = NULL; 2953 char addr4[INET_ADDRSTRLEN]; 2954 char addr6[INET6_ADDRSTRLEN]; 2955 unsigned char mac_addr[ETHER_ADDR_LEN]; 2956 bool obtained; 2957 void *p; 2958 2959 g_debug("Processing %s interface", ifa->ifa_name); 2960 2961 info = guest_find_interface(head, ifa->ifa_name); 2962 2963 if (!info) { 2964 info = g_malloc0(sizeof(*info)); 2965 info->name = g_strdup(ifa->ifa_name); 2966 2967 QAPI_LIST_APPEND(tail, info); 2968 } 2969 2970 if (!info->hardware_address) { 2971 if (!guest_get_hw_addr(ifa, mac_addr, &obtained, errp)) { 2972 goto error; 2973 } 2974 if (obtained) { 2975 info->hardware_address = 2976 g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x", 2977 (int) mac_addr[0], (int) mac_addr[1], 2978 (int) mac_addr[2], (int) mac_addr[3], 2979 (int) mac_addr[4], (int) mac_addr[5]); 2980 } 2981 } 2982 2983 if (ifa->ifa_addr && 2984 ifa->ifa_addr->sa_family == AF_INET) { 2985 /* interface with IPv4 address */ 2986 p = &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr; 2987 if (!inet_ntop(AF_INET, p, addr4, sizeof(addr4))) { 2988 error_setg_errno(errp, errno, "inet_ntop failed"); 2989 goto error; 2990 } 2991 2992 address_item = g_malloc0(sizeof(*address_item)); 2993 address_item->ip_address = g_strdup(addr4); 2994 address_item->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4; 2995 2996 if (ifa->ifa_netmask) { 2997 /* Count the number of set bits in netmask. 2998 * This is safe as '1' and '0' cannot be shuffled in netmask. */ 2999 p = &((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr; 3000 address_item->prefix = ctpop32(((uint32_t *) p)[0]); 3001 } 3002 } else if (ifa->ifa_addr && 3003 ifa->ifa_addr->sa_family == AF_INET6) { 3004 /* interface with IPv6 address */ 3005 p = &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr; 3006 if (!inet_ntop(AF_INET6, p, addr6, sizeof(addr6))) { 3007 error_setg_errno(errp, errno, "inet_ntop failed"); 3008 goto error; 3009 } 3010 3011 address_item = g_malloc0(sizeof(*address_item)); 3012 address_item->ip_address = g_strdup(addr6); 3013 address_item->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6; 3014 3015 if (ifa->ifa_netmask) { 3016 /* Count the number of set bits in netmask. 3017 * This is safe as '1' and '0' cannot be shuffled in netmask. */ 3018 p = &((struct sockaddr_in6 *)ifa->ifa_netmask)->sin6_addr; 3019 address_item->prefix = 3020 ctpop32(((uint32_t *) p)[0]) + 3021 ctpop32(((uint32_t *) p)[1]) + 3022 ctpop32(((uint32_t *) p)[2]) + 3023 ctpop32(((uint32_t *) p)[3]); 3024 } 3025 } 3026 3027 if (!address_item) { 3028 continue; 3029 } 3030 3031 address_tail = &info->ip_addresses; 3032 while (*address_tail) { 3033 address_tail = &(*address_tail)->next; 3034 } 3035 QAPI_LIST_APPEND(address_tail, address_item); 3036 3037 info->has_ip_addresses = true; 3038 3039 if (!info->statistics) { 3040 interface_stat = g_malloc0(sizeof(*interface_stat)); 3041 if (guest_get_network_stats(info->name, interface_stat) == -1) { 3042 g_free(interface_stat); 3043 } else { 3044 info->statistics = interface_stat; 3045 } 3046 } 3047 } 3048 3049 freeifaddrs(ifap); 3050 return head; 3051 3052 error: 3053 freeifaddrs(ifap); 3054 qapi_free_GuestNetworkInterfaceList(head); 3055 return NULL; 3056 } 3057 3058 #else 3059 3060 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp) 3061 { 3062 error_setg(errp, QERR_UNSUPPORTED); 3063 return NULL; 3064 } 3065 3066 #endif /* HAVE_GETIFADDRS */ 3067 3068 #if !defined(CONFIG_FSFREEZE) 3069 3070 GuestFilesystemInfoList *qmp_guest_get_fsinfo(Error **errp) 3071 { 3072 error_setg(errp, QERR_UNSUPPORTED); 3073 return NULL; 3074 } 3075 3076 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **errp) 3077 { 3078 error_setg(errp, QERR_UNSUPPORTED); 3079 3080 return 0; 3081 } 3082 3083 int64_t qmp_guest_fsfreeze_freeze(Error **errp) 3084 { 3085 error_setg(errp, QERR_UNSUPPORTED); 3086 3087 return 0; 3088 } 3089 3090 int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints, 3091 strList *mountpoints, 3092 Error **errp) 3093 { 3094 error_setg(errp, QERR_UNSUPPORTED); 3095 3096 return 0; 3097 } 3098 3099 int64_t qmp_guest_fsfreeze_thaw(Error **errp) 3100 { 3101 error_setg(errp, QERR_UNSUPPORTED); 3102 3103 return 0; 3104 } 3105 3106 GuestDiskInfoList *qmp_guest_get_disks(Error **errp) 3107 { 3108 error_setg(errp, QERR_UNSUPPORTED); 3109 return NULL; 3110 } 3111 3112 GuestDiskStatsInfoList *qmp_guest_get_diskstats(Error **errp) 3113 { 3114 error_setg(errp, QERR_UNSUPPORTED); 3115 return NULL; 3116 } 3117 3118 GuestCpuStatsList *qmp_guest_get_cpustats(Error **errp) 3119 { 3120 error_setg(errp, QERR_UNSUPPORTED); 3121 return NULL; 3122 } 3123 3124 #endif /* CONFIG_FSFREEZE */ 3125 3126 #if !defined(CONFIG_FSTRIM) 3127 GuestFilesystemTrimResponse * 3128 qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp) 3129 { 3130 error_setg(errp, QERR_UNSUPPORTED); 3131 return NULL; 3132 } 3133 #endif 3134 3135 /* add unsupported commands to the list of blocked RPCs */ 3136 GList *ga_command_init_blockedrpcs(GList *blockedrpcs) 3137 { 3138 #if !defined(__linux__) 3139 { 3140 const char *list[] = { 3141 "guest-suspend-disk", "guest-suspend-ram", 3142 "guest-suspend-hybrid", "guest-get-vcpus", "guest-set-vcpus", 3143 "guest-get-memory-blocks", "guest-set-memory-blocks", 3144 "guest-get-memory-block-size", "guest-get-memory-block-info", 3145 NULL}; 3146 char **p = (char **)list; 3147 3148 while (*p) { 3149 blockedrpcs = g_list_append(blockedrpcs, g_strdup(*p++)); 3150 } 3151 } 3152 #endif 3153 3154 #if !defined(HAVE_GETIFADDRS) 3155 blockedrpcs = g_list_append(blockedrpcs, 3156 g_strdup("guest-network-get-interfaces")); 3157 #endif 3158 3159 #if !defined(CONFIG_FSFREEZE) 3160 { 3161 const char *list[] = { 3162 "guest-get-fsinfo", "guest-fsfreeze-status", 3163 "guest-fsfreeze-freeze", "guest-fsfreeze-freeze-list", 3164 "guest-fsfreeze-thaw", "guest-get-fsinfo", 3165 "guest-get-disks", NULL}; 3166 char **p = (char **)list; 3167 3168 while (*p) { 3169 blockedrpcs = g_list_append(blockedrpcs, g_strdup(*p++)); 3170 } 3171 } 3172 #endif 3173 3174 #if !defined(CONFIG_FSTRIM) 3175 blockedrpcs = g_list_append(blockedrpcs, g_strdup("guest-fstrim")); 3176 #endif 3177 3178 blockedrpcs = g_list_append(blockedrpcs, g_strdup("guest-get-devices")); 3179 3180 return blockedrpcs; 3181 } 3182 3183 /* register init/cleanup routines for stateful command groups */ 3184 void ga_command_state_init(GAState *s, GACommandState *cs) 3185 { 3186 #if defined(CONFIG_FSFREEZE) 3187 ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup); 3188 #endif 3189 } 3190 3191 #ifdef HAVE_UTMPX 3192 3193 #define QGA_MICRO_SECOND_TO_SECOND 1000000 3194 3195 static double ga_get_login_time(struct utmpx *user_info) 3196 { 3197 double seconds = (double)user_info->ut_tv.tv_sec; 3198 double useconds = (double)user_info->ut_tv.tv_usec; 3199 useconds /= QGA_MICRO_SECOND_TO_SECOND; 3200 return seconds + useconds; 3201 } 3202 3203 GuestUserList *qmp_guest_get_users(Error **errp) 3204 { 3205 GHashTable *cache = NULL; 3206 GuestUserList *head = NULL, **tail = &head; 3207 struct utmpx *user_info = NULL; 3208 gpointer value = NULL; 3209 GuestUser *user = NULL; 3210 double login_time = 0; 3211 3212 cache = g_hash_table_new(g_str_hash, g_str_equal); 3213 setutxent(); 3214 3215 for (;;) { 3216 user_info = getutxent(); 3217 if (user_info == NULL) { 3218 break; 3219 } else if (user_info->ut_type != USER_PROCESS) { 3220 continue; 3221 } else if (g_hash_table_contains(cache, user_info->ut_user)) { 3222 value = g_hash_table_lookup(cache, user_info->ut_user); 3223 user = (GuestUser *)value; 3224 login_time = ga_get_login_time(user_info); 3225 /* We're ensuring the earliest login time to be sent */ 3226 if (login_time < user->login_time) { 3227 user->login_time = login_time; 3228 } 3229 continue; 3230 } 3231 3232 user = g_new0(GuestUser, 1); 3233 user->user = g_strdup(user_info->ut_user); 3234 user->login_time = ga_get_login_time(user_info); 3235 3236 g_hash_table_insert(cache, user->user, user); 3237 3238 QAPI_LIST_APPEND(tail, user); 3239 } 3240 endutxent(); 3241 g_hash_table_destroy(cache); 3242 return head; 3243 } 3244 3245 #else 3246 3247 GuestUserList *qmp_guest_get_users(Error **errp) 3248 { 3249 error_setg(errp, QERR_UNSUPPORTED); 3250 return NULL; 3251 } 3252 3253 #endif 3254 3255 /* Replace escaped special characters with their real values. The replacement 3256 * is done in place -- returned value is in the original string. 3257 */ 3258 static void ga_osrelease_replace_special(gchar *value) 3259 { 3260 gchar *p, *p2, quote; 3261 3262 /* Trim the string at first space or semicolon if it is not enclosed in 3263 * single or double quotes. */ 3264 if ((value[0] != '"') || (value[0] == '\'')) { 3265 p = strchr(value, ' '); 3266 if (p != NULL) { 3267 *p = 0; 3268 } 3269 p = strchr(value, ';'); 3270 if (p != NULL) { 3271 *p = 0; 3272 } 3273 return; 3274 } 3275 3276 quote = value[0]; 3277 p2 = value; 3278 p = value + 1; 3279 while (*p != 0) { 3280 if (*p == '\\') { 3281 p++; 3282 switch (*p) { 3283 case '$': 3284 case '\'': 3285 case '"': 3286 case '\\': 3287 case '`': 3288 break; 3289 default: 3290 /* Keep literal backslash followed by whatever is there */ 3291 p--; 3292 break; 3293 } 3294 } else if (*p == quote) { 3295 *p2 = 0; 3296 break; 3297 } 3298 *(p2++) = *(p++); 3299 } 3300 } 3301 3302 static GKeyFile *ga_parse_osrelease(const char *fname) 3303 { 3304 gchar *content = NULL; 3305 gchar *content2 = NULL; 3306 GError *err = NULL; 3307 GKeyFile *keys = g_key_file_new(); 3308 const char *group = "[os-release]\n"; 3309 3310 if (!g_file_get_contents(fname, &content, NULL, &err)) { 3311 slog("failed to read '%s', error: %s", fname, err->message); 3312 goto fail; 3313 } 3314 3315 if (!g_utf8_validate(content, -1, NULL)) { 3316 slog("file is not utf-8 encoded: %s", fname); 3317 goto fail; 3318 } 3319 content2 = g_strdup_printf("%s%s", group, content); 3320 3321 if (!g_key_file_load_from_data(keys, content2, -1, G_KEY_FILE_NONE, 3322 &err)) { 3323 slog("failed to parse file '%s', error: %s", fname, err->message); 3324 goto fail; 3325 } 3326 3327 g_free(content); 3328 g_free(content2); 3329 return keys; 3330 3331 fail: 3332 g_error_free(err); 3333 g_free(content); 3334 g_free(content2); 3335 g_key_file_free(keys); 3336 return NULL; 3337 } 3338 3339 GuestOSInfo *qmp_guest_get_osinfo(Error **errp) 3340 { 3341 GuestOSInfo *info = NULL; 3342 struct utsname kinfo; 3343 GKeyFile *osrelease = NULL; 3344 const char *qga_os_release = g_getenv("QGA_OS_RELEASE"); 3345 3346 info = g_new0(GuestOSInfo, 1); 3347 3348 if (uname(&kinfo) != 0) { 3349 error_setg_errno(errp, errno, "uname failed"); 3350 } else { 3351 info->kernel_version = g_strdup(kinfo.version); 3352 info->kernel_release = g_strdup(kinfo.release); 3353 info->machine = g_strdup(kinfo.machine); 3354 } 3355 3356 if (qga_os_release != NULL) { 3357 osrelease = ga_parse_osrelease(qga_os_release); 3358 } else { 3359 osrelease = ga_parse_osrelease("/etc/os-release"); 3360 if (osrelease == NULL) { 3361 osrelease = ga_parse_osrelease("/usr/lib/os-release"); 3362 } 3363 } 3364 3365 if (osrelease != NULL) { 3366 char *value; 3367 3368 #define GET_FIELD(field, osfield) do { \ 3369 value = g_key_file_get_value(osrelease, "os-release", osfield, NULL); \ 3370 if (value != NULL) { \ 3371 ga_osrelease_replace_special(value); \ 3372 info->field = value; \ 3373 } \ 3374 } while (0) 3375 GET_FIELD(id, "ID"); 3376 GET_FIELD(name, "NAME"); 3377 GET_FIELD(pretty_name, "PRETTY_NAME"); 3378 GET_FIELD(version, "VERSION"); 3379 GET_FIELD(version_id, "VERSION_ID"); 3380 GET_FIELD(variant, "VARIANT"); 3381 GET_FIELD(variant_id, "VARIANT_ID"); 3382 #undef GET_FIELD 3383 3384 g_key_file_free(osrelease); 3385 } 3386 3387 return info; 3388 } 3389 3390 GuestDeviceInfoList *qmp_guest_get_devices(Error **errp) 3391 { 3392 error_setg(errp, QERR_UNSUPPORTED); 3393 3394 return NULL; 3395 } 3396 3397 #ifndef HOST_NAME_MAX 3398 # ifdef _POSIX_HOST_NAME_MAX 3399 # define HOST_NAME_MAX _POSIX_HOST_NAME_MAX 3400 # else 3401 # define HOST_NAME_MAX 255 3402 # endif 3403 #endif 3404 3405 char *qga_get_host_name(Error **errp) 3406 { 3407 long len = -1; 3408 g_autofree char *hostname = NULL; 3409 3410 #ifdef _SC_HOST_NAME_MAX 3411 len = sysconf(_SC_HOST_NAME_MAX); 3412 #endif /* _SC_HOST_NAME_MAX */ 3413 3414 if (len < 0) { 3415 len = HOST_NAME_MAX; 3416 } 3417 3418 /* Unfortunately, gethostname() below does not guarantee a 3419 * NULL terminated string. Therefore, allocate one byte more 3420 * to be sure. */ 3421 hostname = g_new0(char, len + 1); 3422 3423 if (gethostname(hostname, len) < 0) { 3424 error_setg_errno(errp, errno, 3425 "cannot get hostname"); 3426 return NULL; 3427 } 3428 3429 return g_steal_pointer(&hostname); 3430 } 3431