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