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