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