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