qga/commands-posix.c

   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 <glib.h>
  15 #include <sys/types.h>
  16 #include <sys/ioctl.h>
  17 #include <sys/wait.h>
  18 #include <unistd.h>
  19 #include <errno.h>
  20 #include <fcntl.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <sys/stat.h>
  24 #include <inttypes.h>
  25 #include "qga/guest-agent-core.h"
  26 #include "qga-qmp-commands.h"
  27 #include "qapi/qmp/qerror.h"
  28 #include "qemu/queue.h"
  29 #include "qemu/host-utils.h"
  30
  31 #ifndef CONFIG_HAS_ENVIRON
  32 #ifdef __APPLE__
  33 #include <crt_externs.h>
  34 #define environ (*_NSGetEnviron())
  35 #else
  36 extern char **environ;
  37 #endif
  38 #endif
  39
  40 #if defined(__linux__)
  41 #include <mntent.h>
  42 #include <linux/fs.h>
  43 #include <ifaddrs.h>
  44 #include <arpa/inet.h>
  45 #include <sys/socket.h>
  46 #include <net/if.h>
  47
  48 #ifdef FIFREEZE
  49 #define CONFIG_FSFREEZE
  50 #endif
  51 #ifdef FITRIM
  52 #define CONFIG_FSTRIM
  53 #endif
  54 #endif
  55
  56 static void ga_wait_child(pid_t pid, int *status, Error **err)
  57 {
  58     pid_t rpid;
  59
  60     *status = 0;
  61
  62     do {
  63         rpid = waitpid(pid, status, 0);
  64     } while (rpid == -1 && errno == EINTR);
  65
  66     if (rpid == -1) {
  67         error_setg_errno(err, errno, "failed to wait for child (pid: %d)", pid);
  68         return;
  69     }
  70
  71     g_assert(rpid == pid);
  72 }
  73
  74 void qmp_guest_shutdown(bool has_mode, const char *mode, Error **err)
  75 {
  76     const char *shutdown_flag;
  77     Error *local_err = NULL;
  78     pid_t pid;
  79     int status;
  80
  81     slog("guest-shutdown called, mode: %s", mode);
  82     if (!has_mode || strcmp(mode, "powerdown") == 0) {
  83         shutdown_flag = "-P";
  84     } else if (strcmp(mode, "halt") == 0) {
  85         shutdown_flag = "-H";
  86     } else if (strcmp(mode, "reboot") == 0) {
  87         shutdown_flag = "-r";
  88     } else {
  89         error_setg(err,
  90                    "mode is invalid (valid values are: halt|powerdown|reboot");
  91         return;
  92     }
  93
  94     pid = fork();
  95     if (pid == 0) {
  96         /* child, start the shutdown */
  97         setsid();
  98         reopen_fd_to_null(0);
  99         reopen_fd_to_null(1);
 100         reopen_fd_to_null(2);
 101
 102         execle("/sbin/shutdown", "shutdown", "-h", shutdown_flag, "+0",
 103                "hypervisor initiated shutdown", (char*)NULL, environ);
 104         _exit(EXIT_FAILURE);
 105     } else if (pid < 0) {
 106         error_setg_errno(err, errno, "failed to create child process");
 107         return;
 108     }
 109
 110     ga_wait_child(pid, &status, &local_err);
 111     if (local_err) {
 112         error_propagate(err, local_err);
 113         return;
 114     }
 115
 116     if (!WIFEXITED(status)) {
 117         error_setg(err, "child process has terminated abnormally");
 118         return;
 119     }
 120
 121     if (WEXITSTATUS(status)) {
 122         error_setg(err, "child process has failed to shutdown");
 123         return;
 124     }
 125
 126     /* succeeded */
 127 }
 128
 129 int64_t qmp_guest_get_time(Error **errp)
 130 {
 131    int ret;
 132    qemu_timeval tq;
 133    int64_t time_ns;
 134
 135    ret = qemu_gettimeofday(&tq);
 136    if (ret < 0) {
 137        error_setg_errno(errp, errno, "Failed to get time");
 138        return -1;
 139    }
 140
 141    time_ns = tq.tv_sec * 1000000000LL + tq.tv_usec * 1000;
 142    return time_ns;
 143 }
 144
 145 void qmp_guest_set_time(bool has_time, int64_t time_ns, Error **errp)
 146 {
 147     int ret;
 148     int status;
 149     pid_t pid;
 150     Error *local_err = NULL;
 151     struct timeval tv;
 152
 153     /* If user has passed a time, validate and set it. */
 154     if (has_time) {
 155         /* 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
 164         ret = settimeofday(&tv, NULL);
 165         if (ret < 0) {
 166             error_setg_errno(errp, errno, "Failed to set time to guest");
 167             return;
 168         }
 169     }
 170
 171     /* Now, if user has passed a time to set and the system time is set, we
 172      * just need to synchronize the hardware clock. However, if no time was
 173      * passed, user is requesting the opposite: set the system time from the
 174      * hardware clock. */
 175     pid = fork();
 176     if (pid == 0) {
 177         setsid();
 178         reopen_fd_to_null(0);
 179         reopen_fd_to_null(1);
 180         reopen_fd_to_null(2);
 181
 182         /* Use '/sbin/hwclock -w' to set RTC from the system time,
 183          * or '/sbin/hwclock -s' to set the system time from RTC. */
 184         execle("/sbin/hwclock", "hwclock", has_time ? "-w" : "-s",
 185                NULL, environ);
 186         _exit(EXIT_FAILURE);
 187     } else if (pid < 0) {
 188         error_setg_errno(errp, errno, "failed to create child process");
 189         return;
 190     }
 191
 192     ga_wait_child(pid, &status, &local_err);
 193     if (local_err) {
 194         error_propagate(errp, local_err);
 195         return;
 196     }
 197
 198     if (!WIFEXITED(status)) {
 199         error_setg(errp, "child process has terminated abnormally");
 200         return;
 201     }
 202
 203     if (WEXITSTATUS(status)) {
 204         error_setg(errp, "hwclock failed to set hardware clock to system time");
 205         return;
 206     }
 207 }
 208
 209 typedef struct GuestFileHandle {
 210     uint64_t id;
 211     FILE *fh;
 212     QTAILQ_ENTRY(GuestFileHandle) next;
 213 } GuestFileHandle;
 214
 215 static struct {
 216     QTAILQ_HEAD(, GuestFileHandle) filehandles;
 217 } guest_file_state;
 218
 219 static int64_t guest_file_handle_add(FILE *fh, Error **errp)
 220 {
 221     GuestFileHandle *gfh;
 222     int64_t handle;
 223
 224     handle = ga_get_fd_handle(ga_state, errp);
 225     if (error_is_set(errp)) {
 226         return 0;
 227     }
 228
 229     gfh = g_malloc0(sizeof(GuestFileHandle));
 230     gfh->id = handle;
 231     gfh->fh = fh;
 232     QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next);
 233
 234     return handle;
 235 }
 236
 237 static GuestFileHandle *guest_file_handle_find(int64_t id, Error **err)
 238 {
 239     GuestFileHandle *gfh;
 240
 241     QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next)
 242     {
 243         if (gfh->id == id) {
 244             return gfh;
 245         }
 246     }
 247
 248     error_setg(err, "handle '%" PRId64 "' has not been found", id);
 249     return NULL;
 250 }
 251
 252 typedef const char * const ccpc;
 253
 254 #ifndef O_BINARY
 255 #define O_BINARY 0
 256 #endif
 257
 258 /* http://pubs.opengroup.org/onlinepubs/9699919799/functions/fopen.html */
 259 static const struct {
 260     ccpc *forms;
 261     int oflag_base;
 262 } guest_file_open_modes[] = {
 263     { (ccpc[]){ "r",          NULL }, O_RDONLY                                 },
 264     { (ccpc[]){ "rb",         NULL }, O_RDONLY                      | O_BINARY },
 265     { (ccpc[]){ "w",          NULL }, O_WRONLY | O_CREAT | O_TRUNC             },
 266     { (ccpc[]){ "wb",         NULL }, O_WRONLY | O_CREAT | O_TRUNC  | O_BINARY },
 267     { (ccpc[]){ "a",          NULL }, O_WRONLY | O_CREAT | O_APPEND            },
 268     { (ccpc[]){ "ab",         NULL }, O_WRONLY | O_CREAT | O_APPEND | O_BINARY },
 269     { (ccpc[]){ "r+",         NULL }, O_RDWR                                   },
 270     { (ccpc[]){ "rb+", "r+b", NULL }, O_RDWR                        | O_BINARY },
 271     { (ccpc[]){ "w+",         NULL }, O_RDWR   | O_CREAT | O_TRUNC             },
 272     { (ccpc[]){ "wb+", "w+b", NULL }, O_RDWR   | O_CREAT | O_TRUNC  | O_BINARY },
 273     { (ccpc[]){ "a+",         NULL }, O_RDWR   | O_CREAT | O_APPEND            },
 274     { (ccpc[]){ "ab+", "a+b", NULL }, O_RDWR   | O_CREAT | O_APPEND | O_BINARY }
 275 };
 276
 277 static int
 278 find_open_flag(const char *mode_str, Error **err)
 279 {
 280     unsigned mode;
 281
 282     for (mode = 0; mode < ARRAY_SIZE(guest_file_open_modes); ++mode) {
 283         ccpc *form;
 284
 285         form = guest_file_open_modes[mode].forms;
 286         while (*form != NULL && strcmp(*form, mode_str) != 0) {
 287             ++form;
 288         }
 289         if (*form != NULL) {
 290             break;
 291         }
 292     }
 293
 294     if (mode == ARRAY_SIZE(guest_file_open_modes)) {
 295         error_setg(err, "invalid file open mode '%s'", mode_str);
 296         return -1;
 297     }
 298     return guest_file_open_modes[mode].oflag_base | O_NOCTTY | O_NONBLOCK;
 299 }
 300
 301 #define DEFAULT_NEW_FILE_MODE (S_IRUSR | S_IWUSR | \
 302                                S_IRGRP | S_IWGRP | \
 303                                S_IROTH | S_IWOTH)
 304
 305 static FILE *
 306 safe_open_or_create(const char *path, const char *mode, Error **err)
 307 {
 308     Error *local_err = NULL;
 309     int oflag;
 310
 311     oflag = find_open_flag(mode, &local_err);
 312     if (local_err == NULL) {
 313         int fd;
 314
 315         /* If the caller wants / allows creation of a new file, we implement it
 316          * with a two step process: open() + (open() / fchmod()).
 317          *
 318          * First we insist on creating the file exclusively as a new file. If
 319          * that succeeds, we're free to set any file-mode bits on it. (The
 320          * motivation is that we want to set those file-mode bits independently
 321          * of the current umask.)
 322          *
 323          * If the exclusive creation fails because the file already exists
 324          * (EEXIST is not possible for any other reason), we just attempt to
 325          * open the file, but in this case we won't be allowed to change the
 326          * file-mode bits on the preexistent file.
 327          *
 328          * The pathname should never disappear between the two open()s in
 329          * practice. If it happens, then someone very likely tried to race us.
 330          * In this case just go ahead and report the ENOENT from the second
 331          * open() to the caller.
 332          *
 333          * If the caller wants to open a preexistent file, then the first
 334          * open() is decisive and its third argument is ignored, and the second
 335          * open() and the fchmod() are never called.
 336          */
 337         fd = open(path, oflag | ((oflag & O_CREAT) ? O_EXCL : 0), 0);
 338         if (fd == -1 && errno == EEXIST) {
 339             oflag &= ~(unsigned)O_CREAT;
 340             fd = open(path, oflag);
 341         }
 342
 343         if (fd == -1) {
 344             error_setg_errno(&local_err, errno, "failed to open file '%s' "
 345                              "(mode: '%s')", path, mode);
 346         } else {
 347             qemu_set_cloexec(fd);
 348
 349             if ((oflag & O_CREAT) && fchmod(fd, DEFAULT_NEW_FILE_MODE) == -1) {
 350                 error_setg_errno(&local_err, errno, "failed to set permission "
 351                                  "0%03o on new file '%s' (mode: '%s')",
 352                                  (unsigned)DEFAULT_NEW_FILE_MODE, path, mode);
 353             } else {
 354                 FILE *f;
 355
 356                 f = fdopen(fd, mode);
 357                 if (f == NULL) {
 358                     error_setg_errno(&local_err, errno, "failed to associate "
 359                                      "stdio stream with file descriptor %d, "
 360                                      "file '%s' (mode: '%s')", fd, path, mode);
 361                 } else {
 362                     return f;
 363                 }
 364             }
 365
 366             close(fd);
 367             if (oflag & O_CREAT) {
 368                 unlink(path);
 369             }
 370         }
 371     }
 372
 373     error_propagate(err, local_err);
 374     return NULL;
 375 }
 376
 377 int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode, Error **err)
 378 {
 379     FILE *fh;
 380     Error *local_err = NULL;
 381     int fd;
 382     int64_t ret = -1, handle;
 383
 384     if (!has_mode) {
 385         mode = "r";
 386     }
 387     slog("guest-file-open called, filepath: %s, mode: %s", path, mode);
 388     fh = safe_open_or_create(path, mode, &local_err);
 389     if (local_err != NULL) {
 390         error_propagate(err, local_err);
 391         return -1;
 392     }
 393
 394     /* set fd non-blocking to avoid common use cases (like reading from a
 395      * named pipe) from hanging the agent
 396      */
 397     fd = fileno(fh);
 398     ret = fcntl(fd, F_GETFL);
 399     ret = fcntl(fd, F_SETFL, ret | O_NONBLOCK);
 400     if (ret == -1) {
 401         error_setg_errno(err, errno, "failed to make file '%s' non-blocking",
 402                          path);
 403         fclose(fh);
 404         return -1;
 405     }
 406
 407     handle = guest_file_handle_add(fh, err);
 408     if (error_is_set(err)) {
 409         fclose(fh);
 410         return -1;
 411     }
 412
 413     slog("guest-file-open, handle: %" PRId64, handle);
 414     return handle;
 415 }
 416
 417 void qmp_guest_file_close(int64_t handle, Error **err)
 418 {
 419     GuestFileHandle *gfh = guest_file_handle_find(handle, err);
 420     int ret;
 421
 422     slog("guest-file-close called, handle: %" PRId64, handle);
 423     if (!gfh) {
 424         return;
 425     }
 426
 427     ret = fclose(gfh->fh);
 428     if (ret == EOF) {
 429         error_setg_errno(err, errno, "failed to close handle");
 430         return;
 431     }
 432
 433     QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next);
 434     g_free(gfh);
 435 }
 436
 437 struct GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count,
 438                                           int64_t count, Error **err)
 439 {
 440     GuestFileHandle *gfh = guest_file_handle_find(handle, err);
 441     GuestFileRead *read_data = NULL;
 442     guchar *buf;
 443     FILE *fh;
 444     size_t read_count;
 445
 446     if (!gfh) {
 447         return NULL;
 448     }
 449
 450     if (!has_count) {
 451         count = QGA_READ_COUNT_DEFAULT;
 452     } else if (count < 0) {
 453         error_setg(err, "value '%" PRId64 "' is invalid for argument count",
 454                    count);
 455         return NULL;
 456     }
 457
 458     fh = gfh->fh;
 459     buf = g_malloc0(count+1);
 460     read_count = fread(buf, 1, count, fh);
 461     if (ferror(fh)) {
 462         error_setg_errno(err, errno, "failed to read file");
 463         slog("guest-file-read failed, handle: %" PRId64, handle);
 464     } else {
 465         buf[read_count] = 0;
 466         read_data = g_malloc0(sizeof(GuestFileRead));
 467         read_data->count = read_count;
 468         read_data->eof = feof(fh);
 469         if (read_count) {
 470             read_data->buf_b64 = g_base64_encode(buf, read_count);
 471         }
 472     }
 473     g_free(buf);
 474     clearerr(fh);
 475
 476     return read_data;
 477 }
 478
 479 GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
 480                                      bool has_count, int64_t count, Error **err)
 481 {
 482     GuestFileWrite *write_data = NULL;
 483     guchar *buf;
 484     gsize buf_len;
 485     int write_count;
 486     GuestFileHandle *gfh = guest_file_handle_find(handle, err);
 487     FILE *fh;
 488
 489     if (!gfh) {
 490         return NULL;
 491     }
 492
 493     fh = gfh->fh;
 494     buf = g_base64_decode(buf_b64, &buf_len);
 495
 496     if (!has_count) {
 497         count = buf_len;
 498     } else if (count < 0 || count > buf_len) {
 499         error_setg(err, "value '%" PRId64 "' is invalid for argument count",
 500                    count);
 501         g_free(buf);
 502         return NULL;
 503     }
 504
 505     write_count = fwrite(buf, 1, count, fh);
 506     if (ferror(fh)) {
 507         error_setg_errno(err, errno, "failed to write to file");
 508         slog("guest-file-write failed, handle: %" PRId64, handle);
 509     } else {
 510         write_data = g_malloc0(sizeof(GuestFileWrite));
 511         write_data->count = write_count;
 512         write_data->eof = feof(fh);
 513     }
 514     g_free(buf);
 515     clearerr(fh);
 516
 517     return write_data;
 518 }
 519
 520 struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset,
 521                                           int64_t whence, Error **err)
 522 {
 523     GuestFileHandle *gfh = guest_file_handle_find(handle, err);
 524     GuestFileSeek *seek_data = NULL;
 525     FILE *fh;
 526     int ret;
 527
 528     if (!gfh) {
 529         return NULL;
 530     }
 531
 532     fh = gfh->fh;
 533     ret = fseek(fh, offset, whence);
 534     if (ret == -1) {
 535         error_setg_errno(err, errno, "failed to seek file");
 536     } else {
 537         seek_data = g_new0(GuestFileSeek, 1);
 538         seek_data->position = ftell(fh);
 539         seek_data->eof = feof(fh);
 540     }
 541     clearerr(fh);
 542
 543     return seek_data;
 544 }
 545
 546 void qmp_guest_file_flush(int64_t handle, Error **err)
 547 {
 548     GuestFileHandle *gfh = guest_file_handle_find(handle, err);
 549     FILE *fh;
 550     int ret;
 551
 552     if (!gfh) {
 553         return;
 554     }
 555
 556     fh = gfh->fh;
 557     ret = fflush(fh);
 558     if (ret == EOF) {
 559         error_setg_errno(err, errno, "failed to flush file");
 560     }
 561 }
 562
 563 static void guest_file_init(void)
 564 {
 565     QTAILQ_INIT(&guest_file_state.filehandles);
 566 }
 567
 568 /* linux-specific implementations. avoid this if at all possible. */
 569 #if defined(__linux__)
 570
 571 #if defined(CONFIG_FSFREEZE) || defined(CONFIG_FSTRIM)
 572 typedef struct FsMount {
 573     char *dirname;
 574     char *devtype;
 575     QTAILQ_ENTRY(FsMount) next;
 576 } FsMount;
 577
 578 typedef QTAILQ_HEAD(FsMountList, FsMount) FsMountList;
 579
 580 static void free_fs_mount_list(FsMountList *mounts)
 581 {
 582      FsMount *mount, *temp;
 583
 584      if (!mounts) {
 585          return;
 586      }
 587
 588      QTAILQ_FOREACH_SAFE(mount, mounts, next, temp) {
 589          QTAILQ_REMOVE(mounts, mount, next);
 590          g_free(mount->dirname);
 591          g_free(mount->devtype);
 592          g_free(mount);
 593      }
 594 }
 595
 596 /*
 597  * Walk the mount table and build a list of local file systems
 598  */
 599 static void build_fs_mount_list(FsMountList *mounts, Error **err)
 600 {
 601     struct mntent *ment;
 602     FsMount *mount;
 603     char const *mtab = "/proc/self/mounts";
 604     FILE *fp;
 605
 606     fp = setmntent(mtab, "r");
 607     if (!fp) {
 608         error_setg(err, "failed to open mtab file: '%s'", mtab);
 609         return;
 610     }
 611
 612     while ((ment = getmntent(fp))) {
 613         /*
 614          * An entry which device name doesn't start with a '/' is
 615          * either a dummy file system or a network file system.
 616          * Add special handling for smbfs and cifs as is done by
 617          * coreutils as well.
 618          */
 619         if ((ment->mnt_fsname[0] != '/') ||
 620             (strcmp(ment->mnt_type, "smbfs") == 0) ||
 621             (strcmp(ment->mnt_type, "cifs") == 0)) {
 622             continue;
 623         }
 624
 625         mount = g_malloc0(sizeof(FsMount));
 626         mount->dirname = g_strdup(ment->mnt_dir);
 627         mount->devtype = g_strdup(ment->mnt_type);
 628
 629         QTAILQ_INSERT_TAIL(mounts, mount, next);
 630     }
 631
 632     endmntent(fp);
 633 }
 634 #endif
 635
 636 #if defined(CONFIG_FSFREEZE)
 637
 638 typedef enum {
 639     FSFREEZE_HOOK_THAW = 0,
 640     FSFREEZE_HOOK_FREEZE,
 641 } FsfreezeHookArg;
 642
 643 const char *fsfreeze_hook_arg_string[] = {
 644     "thaw",
 645     "freeze",
 646 };
 647
 648 static void execute_fsfreeze_hook(FsfreezeHookArg arg, Error **err)
 649 {
 650     int status;
 651     pid_t pid;
 652     const char *hook;
 653     const char *arg_str = fsfreeze_hook_arg_string[arg];
 654     Error *local_err = NULL;
 655
 656     hook = ga_fsfreeze_hook(ga_state);
 657     if (!hook) {
 658         return;
 659     }
 660     if (access(hook, X_OK) != 0) {
 661         error_setg_errno(err, errno, "can't access fsfreeze hook '%s'", hook);
 662         return;
 663     }
 664
 665     slog("executing fsfreeze hook with arg '%s'", arg_str);
 666     pid = fork();
 667     if (pid == 0) {
 668         setsid();
 669         reopen_fd_to_null(0);
 670         reopen_fd_to_null(1);
 671         reopen_fd_to_null(2);
 672
 673         execle(hook, hook, arg_str, NULL, environ);
 674         _exit(EXIT_FAILURE);
 675     } else if (pid < 0) {
 676         error_setg_errno(err, errno, "failed to create child process");
 677         return;
 678     }
 679
 680     ga_wait_child(pid, &status, &local_err);
 681     if (local_err) {
 682         error_propagate(err, local_err);
 683         return;
 684     }
 685
 686     if (!WIFEXITED(status)) {
 687         error_setg(err, "fsfreeze hook has terminated abnormally");
 688         return;
 689     }
 690
 691     status = WEXITSTATUS(status);
 692     if (status) {
 693         error_setg(err, "fsfreeze hook has failed with status %d", status);
 694         return;
 695     }
 696 }
 697
 698 /*
 699  * Return status of freeze/thaw
 700  */
 701 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err)
 702 {
 703     if (ga_is_frozen(ga_state)) {
 704         return GUEST_FSFREEZE_STATUS_FROZEN;
 705     }
 706
 707     return GUEST_FSFREEZE_STATUS_THAWED;
 708 }
 709
 710 /*
 711  * Walk list of mounted file systems in the guest, and freeze the ones which
 712  * are real local file systems.
 713  */
 714 int64_t qmp_guest_fsfreeze_freeze(Error **err)
 715 {
 716     int ret = 0, i = 0;
 717     FsMountList mounts;
 718     struct FsMount *mount;
 719     Error *local_err = NULL;
 720     int fd;
 721
 722     slog("guest-fsfreeze called");
 723
 724     execute_fsfreeze_hook(FSFREEZE_HOOK_FREEZE, &local_err);
 725     if (local_err) {
 726         error_propagate(err, local_err);
 727         return -1;
 728     }
 729
 730     QTAILQ_INIT(&mounts);
 731     build_fs_mount_list(&mounts, &local_err);
 732     if (local_err) {
 733         error_propagate(err, local_err);
 734         return -1;
 735     }
 736
 737     /* cannot risk guest agent blocking itself on a write in this state */
 738     ga_set_frozen(ga_state);
 739
 740     QTAILQ_FOREACH_REVERSE(mount, &mounts, FsMountList, next) {
 741         fd = qemu_open(mount->dirname, O_RDONLY);
 742         if (fd == -1) {
 743             error_setg_errno(err, errno, "failed to open %s", mount->dirname);
 744             goto error;
 745         }
 746
 747         /* we try to cull filesytems we know won't work in advance, but other
 748          * filesytems may not implement fsfreeze for less obvious reasons.
 749          * these will report EOPNOTSUPP. we simply ignore these when tallying
 750          * the number of frozen filesystems.
 751          *
 752          * any other error means a failure to freeze a filesystem we
 753          * expect to be freezable, so return an error in those cases
 754          * and return system to thawed state.
 755          */
 756         ret = ioctl(fd, FIFREEZE);
 757         if (ret == -1) {
 758             if (errno != EOPNOTSUPP) {
 759                 error_setg_errno(err, errno, "failed to freeze %s",
 760                                  mount->dirname);
 761                 close(fd);
 762                 goto error;
 763             }
 764         } else {
 765             i++;
 766         }
 767         close(fd);
 768     }
 769
 770     free_fs_mount_list(&mounts);
 771     return i;
 772
 773 error:
 774     free_fs_mount_list(&mounts);
 775     qmp_guest_fsfreeze_thaw(NULL);
 776     return 0;
 777 }
 778
 779 /*
 780  * Walk list of frozen file systems in the guest, and thaw them.
 781  */
 782 int64_t qmp_guest_fsfreeze_thaw(Error **err)
 783 {
 784     int ret;
 785     FsMountList mounts;
 786     FsMount *mount;
 787     int fd, i = 0, logged;
 788     Error *local_err = NULL;
 789
 790     QTAILQ_INIT(&mounts);
 791     build_fs_mount_list(&mounts, &local_err);
 792     if (local_err) {
 793         error_propagate(err, local_err);
 794         return 0;
 795     }
 796
 797     QTAILQ_FOREACH(mount, &mounts, next) {
 798         logged = false;
 799         fd = qemu_open(mount->dirname, O_RDONLY);
 800         if (fd == -1) {
 801             continue;
 802         }
 803         /* we have no way of knowing whether a filesystem was actually unfrozen
 804          * as a result of a successful call to FITHAW, only that if an error
 805          * was returned the filesystem was *not* unfrozen by that particular
 806          * call.
 807          *
 808          * since multiple preceding FIFREEZEs require multiple calls to FITHAW
 809          * to unfreeze, continuing issuing FITHAW until an error is returned,
 810          * in which case either the filesystem is in an unfreezable state, or,
 811          * more likely, it was thawed previously (and remains so afterward).
 812          *
 813          * also, since the most recent successful call is the one that did
 814          * the actual unfreeze, we can use this to provide an accurate count
 815          * of the number of filesystems unfrozen by guest-fsfreeze-thaw, which
 816          * may * be useful for determining whether a filesystem was unfrozen
 817          * during the freeze/thaw phase by a process other than qemu-ga.
 818          */
 819         do {
 820             ret = ioctl(fd, FITHAW);
 821             if (ret == 0 && !logged) {
 822                 i++;
 823                 logged = true;
 824             }
 825         } while (ret == 0);
 826         close(fd);
 827     }
 828
 829     ga_unset_frozen(ga_state);
 830     free_fs_mount_list(&mounts);
 831
 832     execute_fsfreeze_hook(FSFREEZE_HOOK_THAW, err);
 833
 834     return i;
 835 }
 836
 837 static void guest_fsfreeze_cleanup(void)
 838 {
 839     Error *err = NULL;
 840
 841     if (ga_is_frozen(ga_state) == GUEST_FSFREEZE_STATUS_FROZEN) {
 842         qmp_guest_fsfreeze_thaw(&err);
 843         if (err) {
 844             slog("failed to clean up frozen filesystems: %s",
 845                  error_get_pretty(err));
 846             error_free(err);
 847         }
 848     }
 849 }
 850 #endif /* CONFIG_FSFREEZE */
 851
 852 #if defined(CONFIG_FSTRIM)
 853 /*
 854  * Walk list of mounted file systems in the guest, and trim them.
 855  */
 856 void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **err)
 857 {
 858     int ret = 0;
 859     FsMountList mounts;
 860     struct FsMount *mount;
 861     int fd;
 862     Error *local_err = NULL;
 863     struct fstrim_range r = {
 864         .start = 0,
 865         .len = -1,
 866         .minlen = has_minimum ? minimum : 0,
 867     };
 868
 869     slog("guest-fstrim called");
 870
 871     QTAILQ_INIT(&mounts);
 872     build_fs_mount_list(&mounts, &local_err);
 873     if (local_err) {
 874         error_propagate(err, local_err);
 875         return;
 876     }
 877
 878     QTAILQ_FOREACH(mount, &mounts, next) {
 879         fd = qemu_open(mount->dirname, O_RDONLY);
 880         if (fd == -1) {
 881             error_setg_errno(err, errno, "failed to open %s", mount->dirname);
 882             goto error;
 883         }
 884
 885         /* We try to cull filesytems we know won't work in advance, but other
 886          * filesytems may not implement fstrim for less obvious reasons.  These
 887          * will report EOPNOTSUPP; we simply ignore these errors.  Any other
 888          * error means an unexpected error, so return it in those cases.  In
 889          * some other cases ENOTTY will be reported (e.g. CD-ROMs).
 890          */
 891         ret = ioctl(fd, FITRIM, &r);
 892         if (ret == -1) {
 893             if (errno != ENOTTY && errno != EOPNOTSUPP) {
 894                 error_setg_errno(err, errno, "failed to trim %s",
 895                                  mount->dirname);
 896                 close(fd);
 897                 goto error;
 898             }
 899         }
 900         close(fd);
 901     }
 902
 903 error:
 904     free_fs_mount_list(&mounts);
 905 }
 906 #endif /* CONFIG_FSTRIM */
 907
 908
 909 #define LINUX_SYS_STATE_FILE "/sys/power/state"
 910 #define SUSPEND_SUPPORTED 0
 911 #define SUSPEND_NOT_SUPPORTED 1
 912
 913 static void bios_supports_mode(const char *pmutils_bin, const char *pmutils_arg,
 914                                const char *sysfile_str, Error **err)
 915 {
 916     Error *local_err = NULL;
 917     char *pmutils_path;
 918     pid_t pid;
 919     int status;
 920
 921     pmutils_path = g_find_program_in_path(pmutils_bin);
 922
 923     pid = fork();
 924     if (!pid) {
 925         char buf[32]; /* hopefully big enough */
 926         ssize_t ret;
 927         int fd;
 928
 929         setsid();
 930         reopen_fd_to_null(0);
 931         reopen_fd_to_null(1);
 932         reopen_fd_to_null(2);
 933
 934         if (pmutils_path) {
 935             execle(pmutils_path, pmutils_bin, pmutils_arg, NULL, environ);
 936         }
 937
 938         /*
 939          * If we get here either pm-utils is not installed or execle() has
 940          * failed. Let's try the manual method if the caller wants it.
 941          */
 942
 943         if (!sysfile_str) {
 944             _exit(SUSPEND_NOT_SUPPORTED);
 945         }
 946
 947         fd = open(LINUX_SYS_STATE_FILE, O_RDONLY);
 948         if (fd < 0) {
 949             _exit(SUSPEND_NOT_SUPPORTED);
 950         }
 951
 952         ret = read(fd, buf, sizeof(buf)-1);
 953         if (ret <= 0) {
 954             _exit(SUSPEND_NOT_SUPPORTED);
 955         }
 956         buf[ret] = '\0';
 957
 958         if (strstr(buf, sysfile_str)) {
 959             _exit(SUSPEND_SUPPORTED);
 960         }
 961
 962         _exit(SUSPEND_NOT_SUPPORTED);
 963     } else if (pid < 0) {
 964         error_setg_errno(err, errno, "failed to create child process");
 965         goto out;
 966     }
 967
 968     ga_wait_child(pid, &status, &local_err);
 969     if (local_err) {
 970         error_propagate(err, local_err);
 971         goto out;
 972     }
 973
 974     if (!WIFEXITED(status)) {
 975         error_setg(err, "child process has terminated abnormally");
 976         goto out;
 977     }
 978
 979     switch (WEXITSTATUS(status)) {
 980     case SUSPEND_SUPPORTED:
 981         goto out;
 982     case SUSPEND_NOT_SUPPORTED:
 983         error_setg(err,
 984                    "the requested suspend mode is not supported by the guest");
 985         goto out;
 986     default:
 987         error_setg(err,
 988                    "the helper program '%s' returned an unexpected exit status"
 989                    " code (%d)", pmutils_path, WEXITSTATUS(status));
 990         goto out;
 991     }
 992
 993 out:
 994     g_free(pmutils_path);
 995 }
 996
 997 static void guest_suspend(const char *pmutils_bin, const char *sysfile_str,
 998                           Error **err)
 999 {
1000     Error *local_err = NULL;
1001     char *pmutils_path;
1002     pid_t pid;
1003     int status;
1004
1005     pmutils_path = g_find_program_in_path(pmutils_bin);
1006
1007     pid = fork();
1008     if (pid == 0) {
1009         /* child */
1010         int fd;
1011
1012         setsid();
1013         reopen_fd_to_null(0);
1014         reopen_fd_to_null(1);
1015         reopen_fd_to_null(2);
1016
1017         if (pmutils_path) {
1018             execle(pmutils_path, pmutils_bin, NULL, environ);
1019         }
1020
1021         /*
1022          * If we get here either pm-utils is not installed or execle() has
1023          * failed. Let's try the manual method if the caller wants it.
1024          */
1025
1026         if (!sysfile_str) {
1027             _exit(EXIT_FAILURE);
1028         }
1029
1030         fd = open(LINUX_SYS_STATE_FILE, O_WRONLY);
1031         if (fd < 0) {
1032             _exit(EXIT_FAILURE);
1033         }
1034
1035         if (write(fd, sysfile_str, strlen(sysfile_str)) < 0) {
1036             _exit(EXIT_FAILURE);
1037         }
1038
1039         _exit(EXIT_SUCCESS);
1040     } else if (pid < 0) {
1041         error_setg_errno(err, errno, "failed to create child process");
1042         goto out;
1043     }
1044
1045     ga_wait_child(pid, &status, &local_err);
1046     if (local_err) {
1047         error_propagate(err, local_err);
1048         goto out;
1049     }
1050
1051     if (!WIFEXITED(status)) {
1052         error_setg(err, "child process has terminated abnormally");
1053         goto out;
1054     }
1055
1056     if (WEXITSTATUS(status)) {
1057         error_setg(err, "child process has failed to suspend");
1058         goto out;
1059     }
1060
1061 out:
1062     g_free(pmutils_path);
1063 }
1064
1065 void qmp_guest_suspend_disk(Error **err)
1066 {
1067     bios_supports_mode("pm-is-supported", "--hibernate", "disk", err);
1068     if (error_is_set(err)) {
1069         return;
1070     }
1071
1072     guest_suspend("pm-hibernate", "disk", err);
1073 }
1074
1075 void qmp_guest_suspend_ram(Error **err)
1076 {
1077     bios_supports_mode("pm-is-supported", "--suspend", "mem", err);
1078     if (error_is_set(err)) {
1079         return;
1080     }
1081
1082     guest_suspend("pm-suspend", "mem", err);
1083 }
1084
1085 void qmp_guest_suspend_hybrid(Error **err)
1086 {
1087     bios_supports_mode("pm-is-supported", "--suspend-hybrid", NULL, err);
1088     if (error_is_set(err)) {
1089         return;
1090     }
1091
1092     guest_suspend("pm-suspend-hybrid", NULL, err);
1093 }
1094
1095 static GuestNetworkInterfaceList *
1096 guest_find_interface(GuestNetworkInterfaceList *head,
1097                      const char *name)
1098 {
1099     for (; head; head = head->next) {
1100         if (strcmp(head->value->name, name) == 0) {
1101             break;
1102         }
1103     }
1104
1105     return head;
1106 }
1107
1108 /*
1109  * Build information about guest interfaces
1110  */
1111 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
1112 {
1113     GuestNetworkInterfaceList *head = NULL, *cur_item = NULL;
1114     struct ifaddrs *ifap, *ifa;
1115
1116     if (getifaddrs(&ifap) < 0) {
1117         error_setg_errno(errp, errno, "getifaddrs failed");
1118         goto error;
1119     }
1120
1121     for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
1122         GuestNetworkInterfaceList *info;
1123         GuestIpAddressList **address_list = NULL, *address_item = NULL;
1124         char addr4[INET_ADDRSTRLEN];
1125         char addr6[INET6_ADDRSTRLEN];
1126         int sock;
1127         struct ifreq ifr;
1128         unsigned char *mac_addr;
1129         void *p;
1130
1131         g_debug("Processing %s interface", ifa->ifa_name);
1132
1133         info = guest_find_interface(head, ifa->ifa_name);
1134
1135         if (!info) {
1136             info = g_malloc0(sizeof(*info));
1137             info->value = g_malloc0(sizeof(*info->value));
1138             info->value->name = g_strdup(ifa->ifa_name);
1139
1140             if (!cur_item) {
1141                 head = cur_item = info;
1142             } else {
1143                 cur_item->next = info;
1144                 cur_item = info;
1145             }
1146         }
1147
1148         if (!info->value->has_hardware_address &&
1149             ifa->ifa_flags & SIOCGIFHWADDR) {
1150             /* we haven't obtained HW address yet */
1151             sock = socket(PF_INET, SOCK_STREAM, 0);
1152             if (sock == -1) {
1153                 error_setg_errno(errp, errno, "failed to create socket");
1154                 goto error;
1155             }
1156
1157             memset(&ifr, 0, sizeof(ifr));
1158             pstrcpy(ifr.ifr_name, IF_NAMESIZE, info->value->name);
1159             if (ioctl(sock, SIOCGIFHWADDR, &ifr) == -1) {
1160                 error_setg_errno(errp, errno,
1161                                  "failed to get MAC address of %s",
1162                                  ifa->ifa_name);
1163                 close(sock);
1164                 goto error;
1165             }
1166
1167             close(sock);
1168             mac_addr = (unsigned char *) &ifr.ifr_hwaddr.sa_data;
1169
1170             info->value->hardware_address =
1171                 g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x",
1172                                 (int) mac_addr[0], (int) mac_addr[1],
1173                                 (int) mac_addr[2], (int) mac_addr[3],
1174                                 (int) mac_addr[4], (int) mac_addr[5]);
1175
1176             info->value->has_hardware_address = true;
1177         }
1178
1179         if (ifa->ifa_addr &&
1180             ifa->ifa_addr->sa_family == AF_INET) {
1181             /* interface with IPv4 address */
1182             p = &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr;
1183             if (!inet_ntop(AF_INET, p, addr4, sizeof(addr4))) {
1184                 error_setg_errno(errp, errno, "inet_ntop failed");
1185                 goto error;
1186             }
1187
1188             address_item = g_malloc0(sizeof(*address_item));
1189             address_item->value = g_malloc0(sizeof(*address_item->value));
1190             address_item->value->ip_address = g_strdup(addr4);
1191             address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4;
1192
1193             if (ifa->ifa_netmask) {
1194                 /* Count the number of set bits in netmask.
1195                  * This is safe as '1' and '0' cannot be shuffled in netmask. */
1196                 p = &((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr;
1197                 address_item->value->prefix = ctpop32(((uint32_t *) p)[0]);
1198             }
1199         } else if (ifa->ifa_addr &&
1200                    ifa->ifa_addr->sa_family == AF_INET6) {
1201             /* interface with IPv6 address */
1202             p = &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr;
1203             if (!inet_ntop(AF_INET6, p, addr6, sizeof(addr6))) {
1204                 error_setg_errno(errp, errno, "inet_ntop failed");
1205                 goto error;
1206             }
1207
1208             address_item = g_malloc0(sizeof(*address_item));
1209             address_item->value = g_malloc0(sizeof(*address_item->value));
1210             address_item->value->ip_address = g_strdup(addr6);
1211             address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6;
1212
1213             if (ifa->ifa_netmask) {
1214                 /* Count the number of set bits in netmask.
1215                  * This is safe as '1' and '0' cannot be shuffled in netmask. */
1216                 p = &((struct sockaddr_in6 *)ifa->ifa_netmask)->sin6_addr;
1217                 address_item->value->prefix =
1218                     ctpop32(((uint32_t *) p)[0]) +
1219                     ctpop32(((uint32_t *) p)[1]) +
1220                     ctpop32(((uint32_t *) p)[2]) +
1221                     ctpop32(((uint32_t *) p)[3]);
1222             }
1223         }
1224
1225         if (!address_item) {
1226             continue;
1227         }
1228
1229         address_list = &info->value->ip_addresses;
1230
1231         while (*address_list && (*address_list)->next) {
1232             address_list = &(*address_list)->next;
1233         }
1234
1235         if (!*address_list) {
1236             *address_list = address_item;
1237         } else {
1238             (*address_list)->next = address_item;
1239         }
1240
1241         info->value->has_ip_addresses = true;
1242
1243
1244     }
1245
1246     freeifaddrs(ifap);
1247     return head;
1248
1249 error:
1250     freeifaddrs(ifap);
1251     qapi_free_GuestNetworkInterfaceList(head);
1252     return NULL;
1253 }
1254
1255 #define SYSCONF_EXACT(name, err) sysconf_exact((name), #name, (err))
1256
1257 static long sysconf_exact(int name, const char *name_str, Error **err)
1258 {
1259     long ret;
1260
1261     errno = 0;
1262     ret = sysconf(name);
1263     if (ret == -1) {
1264         if (errno == 0) {
1265             error_setg(err, "sysconf(%s): value indefinite", name_str);
1266         } else {
1267             error_setg_errno(err, errno, "sysconf(%s)", name_str);
1268         }
1269     }
1270     return ret;
1271 }
1272
1273 /* Transfer online/offline status between @vcpu and the guest system.
1274  *
1275  * On input either @errp or *@errp must be NULL.
1276  *
1277  * In system-to-@vcpu direction, the following @vcpu fields are accessed:
1278  * - R: vcpu->logical_id
1279  * - W: vcpu->online
1280  * - W: vcpu->can_offline
1281  *
1282  * In @vcpu-to-system direction, the following @vcpu fields are accessed:
1283  * - R: vcpu->logical_id
1284  * - R: vcpu->online
1285  *
1286  * Written members remain unmodified on error.
1287  */
1288 static void transfer_vcpu(GuestLogicalProcessor *vcpu, bool sys2vcpu,
1289                           Error **errp)
1290 {
1291     char *dirpath;
1292     int dirfd;
1293
1294     dirpath = g_strdup_printf("/sys/devices/system/cpu/cpu%" PRId64 "/",
1295                               vcpu->logical_id);
1296     dirfd = open(dirpath, O_RDONLY | O_DIRECTORY);
1297     if (dirfd == -1) {
1298         error_setg_errno(errp, errno, "open(\"%s\")", dirpath);
1299     } else {
1300         static const char fn[] = "online";
1301         int fd;
1302         int res;
1303
1304         fd = openat(dirfd, fn, sys2vcpu ? O_RDONLY : O_RDWR);
1305         if (fd == -1) {
1306             if (errno != ENOENT) {
1307                 error_setg_errno(errp, errno, "open(\"%s/%s\")", dirpath, fn);
1308             } else if (sys2vcpu) {
1309                 vcpu->online = true;
1310                 vcpu->can_offline = false;
1311             } else if (!vcpu->online) {
1312                 error_setg(errp, "logical processor #%" PRId64 " can't be "
1313                            "offlined", vcpu->logical_id);
1314             } /* otherwise pretend successful re-onlining */
1315         } else {
1316             unsigned char status;
1317
1318             res = pread(fd, &status, 1, 0);
1319             if (res == -1) {
1320                 error_setg_errno(errp, errno, "pread(\"%s/%s\")", dirpath, fn);
1321             } else if (res == 0) {
1322                 error_setg(errp, "pread(\"%s/%s\"): unexpected EOF", dirpath,
1323                            fn);
1324             } else if (sys2vcpu) {
1325                 vcpu->online = (status != '0');
1326                 vcpu->can_offline = true;
1327             } else if (vcpu->online != (status != '0')) {
1328                 status = '0' + vcpu->online;
1329                 if (pwrite(fd, &status, 1, 0) == -1) {
1330                     error_setg_errno(errp, errno, "pwrite(\"%s/%s\")", dirpath,
1331                                      fn);
1332                 }
1333             } /* otherwise pretend successful re-(on|off)-lining */
1334
1335             res = close(fd);
1336             g_assert(res == 0);
1337         }
1338
1339         res = close(dirfd);
1340         g_assert(res == 0);
1341     }
1342
1343     g_free(dirpath);
1344 }
1345
1346 GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp)
1347 {
1348     int64_t current;
1349     GuestLogicalProcessorList *head, **link;
1350     long sc_max;
1351     Error *local_err = NULL;
1352
1353     current = 0;
1354     head = NULL;
1355     link = &head;
1356     sc_max = SYSCONF_EXACT(_SC_NPROCESSORS_CONF, &local_err);
1357
1358     while (local_err == NULL && current < sc_max) {
1359         GuestLogicalProcessor *vcpu;
1360         GuestLogicalProcessorList *entry;
1361
1362         vcpu = g_malloc0(sizeof *vcpu);
1363         vcpu->logical_id = current++;
1364         vcpu->has_can_offline = true; /* lolspeak ftw */
1365         transfer_vcpu(vcpu, true, &local_err);
1366
1367         entry = g_malloc0(sizeof *entry);
1368         entry->value = vcpu;
1369
1370         *link = entry;
1371         link = &entry->next;
1372     }
1373
1374     if (local_err == NULL) {
1375         /* there's no guest with zero VCPUs */
1376         g_assert(head != NULL);
1377         return head;
1378     }
1379
1380     qapi_free_GuestLogicalProcessorList(head);
1381     error_propagate(errp, local_err);
1382     return NULL;
1383 }
1384
1385 int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp)
1386 {
1387     int64_t processed;
1388     Error *local_err = NULL;
1389
1390     processed = 0;
1391     while (vcpus != NULL) {
1392         transfer_vcpu(vcpus->value, false, &local_err);
1393         if (local_err != NULL) {
1394             break;
1395         }
1396         ++processed;
1397         vcpus = vcpus->next;
1398     }
1399
1400     if (local_err != NULL) {
1401         if (processed == 0) {
1402             error_propagate(errp, local_err);
1403         } else {
1404             error_free(local_err);
1405         }
1406     }
1407
1408     return processed;
1409 }
1410
1411 #else /* defined(__linux__) */
1412
1413 void qmp_guest_suspend_disk(Error **err)
1414 {
1415     error_set(err, QERR_UNSUPPORTED);
1416 }
1417
1418 void qmp_guest_suspend_ram(Error **err)
1419 {
1420     error_set(err, QERR_UNSUPPORTED);
1421 }
1422
1423 void qmp_guest_suspend_hybrid(Error **err)
1424 {
1425     error_set(err, QERR_UNSUPPORTED);
1426 }
1427
1428 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
1429 {
1430     error_set(errp, QERR_UNSUPPORTED);
1431     return NULL;
1432 }
1433
1434 GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp)
1435 {
1436     error_set(errp, QERR_UNSUPPORTED);
1437     return NULL;
1438 }
1439
1440 int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp)
1441 {
1442     error_set(errp, QERR_UNSUPPORTED);
1443     return -1;
1444 }
1445
1446 #endif
1447
1448 #if !defined(CONFIG_FSFREEZE)
1449
1450 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err)
1451 {
1452     error_set(err, QERR_UNSUPPORTED);
1453
1454     return 0;
1455 }
1456
1457 int64_t qmp_guest_fsfreeze_freeze(Error **err)
1458 {
1459     error_set(err, QERR_UNSUPPORTED);
1460
1461     return 0;
1462 }
1463
1464 int64_t qmp_guest_fsfreeze_thaw(Error **err)
1465 {
1466     error_set(err, QERR_UNSUPPORTED);
1467
1468     return 0;
1469 }
1470 #endif /* CONFIG_FSFREEZE */
1471
1472 #if !defined(CONFIG_FSTRIM)
1473 void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **err)
1474 {
1475     error_set(err, QERR_UNSUPPORTED);
1476 }
1477 #endif
1478
1479 /* register init/cleanup routines for stateful command groups */
1480 void ga_command_state_init(GAState *s, GACommandState *cs)
1481 {
1482 #if defined(CONFIG_FSFREEZE)
1483     ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup);
1484 #endif
1485     ga_command_state_add(cs, guest_file_init, NULL);
1486 }