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